sneakoscope 6.0.3 → 6.1.2

package/dist/core/zellij/zellij-official-subagent-telemetry.js

@@ -0,0 +1,264 @@
+import { sha256 } from '../fsx.js';
+import { normalizeSubagentParentSummary } from '../subagents/subagent-evidence.js';
+import { appendZellijSlotTelemetry, readZellijSlotTelemetrySnapshotNoRebuild } from './zellij-slot-telemetry.js';
+export const SKS_ZELLIJ_HOST_MISSION_ENV = 'SKS_ZELLIJ_HOST_MISSION_ID';
+export async function recordOfficialSubagentZellijTelemetry(input) {
+    const threadId = String(input.event?.thread_id || '').trim();
+    if (!threadId)
+        return { written: false, mission_ids: [], blocker: 'official_subagent_thread_id_missing' };
+    const missionIds = officialSubagentTelemetryMissionIds(input.routeMissionId, input.env);
+    if (!missionIds.length)
+        return { written: false, mission_ids: [], blocker: 'official_subagent_telemetry_mission_missing' };
+    const payload = objectValue(input.payload);
+    const plan = objectValue(input.plan);
+    const role = resolveRole(payload, plan);
+    const rolePolicy = objectValue(objectValue(plan.agents)[role]);
+    const model = firstText(input.event.model, payload.model, rolePolicy.model) || 'unknown';
+    const reasoning = firstText(payload.model_reasoning_effort, payload.reasoning_effort, payload.reasoningEffort, rolePolicy.model_reasoning_effort) || 'unknown';
+    const provider = firstText(payload.provider, payload.model_provider, payload.modelProvider) || 'unknown';
+    const serviceTier = firstText(payload.service_tier, payload.serviceTier) || 'unknown';
+    const stopped = input.event.event_name === 'SubagentStop';
+    const slotId = officialSubagentSlotId(threadId);
+    const latest = await latestThreadSlot(input.root, missionIds, threadId);
+    const generationIndex = stopped
+        ? latest?.generation_index || 1
+        : latest && isTerminal(latest.status) ? latest.generation_index + 1 : latest?.generation_index || 1;
+    const nickname = firstText(payload.nickname, payload.display_name, payload.displayName, payload.agent_name, payload.agentName);
+    const summary = boundedText(firstText(payload.last_assistant_message, payload.lastAssistantMessage, payload.summary, payload.result), 1200);
+    const explicitTaskTitle = boundedText(firstText(payload.task_title, payload.taskTitle, payload.task, nickname ? `${nickname} (${role})` : null), 240);
+    const taskTitle = stopped ? explicitTaskTitle : explicitTaskTitle || `${role} active`;
+    const lifecycleEvent = {
+        schema: 'sks.zellij-slot-telemetry-event.v1',
+        ts: input.event.occurred_at,
+        slot_id: slotId,
+        generation_index: generationIndex,
+        worker_id: threadId,
+        event_type: stopped ? 'verification_started' : 'worker_spawned',
+        status: stopped ? 'verifying' : 'running',
+        role,
+        backend: 'official-codex-subagent',
+        provider,
+        service_tier: serviceTier,
+        model,
+        reasoning_effort: reasoning,
+        task_id: threadId,
+        ...(taskTitle ? { task_title: taskTitle } : {}),
+        current_file: null,
+        ...(!stopped ? { spawned_at: input.event.occurred_at } : {}),
+        artifact_paths: routeArtifactPaths(input.routeMissionId),
+        log_tail: summary || `${stopped ? 'SubagentStop received; parent verdict pending' : 'Started'} · ${role} · ${model}/${reasoning}`,
+        blockers: stopped && input.event.outcome !== 'stopped' ? [`awaiting_parent_verdict:${input.event.outcome}`] : []
+    };
+    const appendResult = await appendToMissions(input.root, missionIds, lifecycleEvent);
+    return {
+        written: appendResult.written_mission_ids.length > 0,
+        mission_ids: missionIds,
+        written_mission_ids: appendResult.written_mission_ids,
+        failed_mission_ids: appendResult.failed_mission_ids,
+        ...(appendResult.failed_mission_ids.length > 0
+            ? { blocker: appendResult.written_mission_ids.length > 0 ? 'official_subagent_telemetry_partial_write' : 'official_subagent_telemetry_write_failed' }
+            : {}),
+        slot_id: slotId,
+        generation_index: generationIndex,
+        status: lifecycleEvent.status,
+        role,
+        model
+    };
+}
+export async function recordOfficialSubagentParentOutcomesTelemetry(input) {
+    const normalized = normalizeSubagentParentSummary(input.parentSummary);
+    const parent = normalized.raw;
+    if (!normalized.trustworthy || !parent) {
+        return { written: false, mission_ids: [], blocker: 'trustworthy_parent_summary_missing' };
+    }
+    const plan = objectValue(input.plan);
+    const activeRunId = firstText(plan.workflow_run_id, plan.run_id);
+    if (activeRunId && parent.run_id !== activeRunId) {
+        return { written: false, mission_ids: [], blocker: 'parent_summary_run_id_mismatch' };
+    }
+    const missionIds = officialSubagentTelemetryMissionIds(input.routeMissionId, input.env);
+    const rows = Array.isArray(parent.thread_outcomes) ? parent.thread_outcomes : [];
+    if (!missionIds.length || !rows.length) {
+        return { written: false, mission_ids: missionIds, blocker: rows.length ? 'official_subagent_telemetry_mission_missing' : 'parent_thread_outcomes_missing' };
+    }
+    const written = [];
+    const skipped = [];
+    const alreadyApplied = [];
+    const successfulThreadIds = [];
+    const failedWrites = [];
+    for (const outcome of rows) {
+        const threadId = String(outcome?.thread_id || '').trim();
+        if (!threadId)
+            continue;
+        for (const missionId of missionIds) {
+            const latest = await latestThreadSlotForMission(input.root, missionId, threadId);
+            const stopFailureBlocker = failedOrAmbiguousStopBlocker(latest?.blockers);
+            // SubagentStop has no trustworthy success status of its own, but a
+            // normalized failed/ambiguous outcome is still negative evidence. A
+            // structurally valid parent summary must not erase that evidence by
+            // declaring the same thread completed. Surface the contradiction as a
+            // failed slot so the CLI/Zellij observer remains fail closed.
+            const completed = outcome.status === 'completed' && !stopFailureBlocker;
+            const desiredStatus = completed ? 'completed' : 'failed';
+            if (latest?.status === desiredStatus) {
+                alreadyApplied.push(`${missionId}:${threadId}`);
+                successfulThreadIds.push(threadId);
+                continue;
+            }
+            if (!latest || latest.status !== 'verifying') {
+                skipped.push(`${missionId}:${threadId}`);
+                continue;
+            }
+            const role = latest.role || singleSuggestedAgent(plan) || 'official_subagent';
+            const parentOutcomeConflict = outcome.status === 'completed' && Boolean(stopFailureBlocker);
+            const event = {
+                schema: 'sks.zellij-slot-telemetry-event.v1',
+                ts: new Date().toISOString(),
+                mission_id: missionId,
+                slot_id: officialSubagentSlotId(threadId),
+                generation_index: latest.generation_index || 1,
+                worker_id: threadId,
+                event_type: completed ? 'verification_passed' : 'verification_failed',
+                status: desiredStatus,
+                role,
+                backend: latest.backend || 'official-codex-subagent',
+                provider: latest.provider || 'unknown',
+                service_tier: latest.service_tier || 'unknown',
+                model: latest.model || modelForRole(plan, role) || 'unknown',
+                reasoning_effort: latest.reasoning_effort || reasoningForRole(plan, role) || 'unknown',
+                task_id: threadId,
+                task_title: boundedText(latest.task_title || `${role} parent verdict`, 240) || `${role} parent verdict`,
+                current_file: latest.current_file || null,
+                artifact_paths: routeArtifactPaths(input.routeMissionId),
+                log_tail: parentOutcomeConflict
+                    ? `${role}: completed parent verdict rejected because ${stopFailureBlocker}`
+                    : boundedText(outcome.summary, 1200) || `${role}: ${outcome.status}`,
+                blockers: completed
+                    ? []
+                    : parentOutcomeConflict
+                        ? [String(stopFailureBlocker), 'parent_thread_outcome_conflict:completed']
+                        : [`parent_thread_outcome:${outcome.status}`]
+            };
+            try {
+                await appendZellijSlotTelemetry(input.root, event);
+                written.push(`${missionId}:${threadId}`);
+                successfulThreadIds.push(threadId);
+            }
+            catch (err) {
+                failedWrites.push({ mission_id: missionId, thread_id: threadId, error: boundedText(err?.message || String(err), 320) || 'telemetry_write_failed' });
+            }
+        }
+    }
+    return {
+        written: written.length > 0 || alreadyApplied.length > 0,
+        mission_ids: missionIds,
+        thread_ids: unique(successfulThreadIds),
+        written_mission_threads: written,
+        already_applied_mission_threads: alreadyApplied,
+        skipped_thread_ids: skipped,
+        failed_writes: failedWrites,
+        failed_mission_ids: unique(failedWrites.map((row) => row.mission_id)),
+        ...(failedWrites.length > 0
+            ? { blocker: written.length > 0 || alreadyApplied.length > 0 ? 'official_subagent_parent_telemetry_partial_write' : 'official_subagent_parent_telemetry_write_failed' }
+            : written.length === 0 && alreadyApplied.length === 0 && skipped.length > 0
+                ? { blocker: 'subagent_stop_telemetry_missing' }
+                : {})
+    };
+}
+export function officialSubagentTelemetryMissionIds(routeMissionId, env = process.env) {
+    return unique([
+        safeMissionId(routeMissionId),
+        safeMissionId(env[SKS_ZELLIJ_HOST_MISSION_ENV])
+    ]);
+}
+export function officialSubagentSlotId(threadId) {
+    return `sub-${sha256(String(threadId || '')).slice(0, 8)}`;
+}
+async function appendToMissions(root, missionIds, event) {
+    const results = await Promise.allSettled(missionIds.map((missionId) => appendZellijSlotTelemetry(root, { ...event, mission_id: missionId })));
+    return {
+        written_mission_ids: missionIds.filter((_missionId, index) => results[index]?.status === 'fulfilled'),
+        failed_mission_ids: missionIds.filter((_missionId, index) => results[index]?.status === 'rejected')
+    };
+}
+async function latestThreadSlot(root, missionIds, threadId) {
+    let latest = null;
+    for (const missionId of missionIds) {
+        const snapshot = await readZellijSlotTelemetrySnapshotNoRebuild(root, missionId).catch(() => null);
+        for (const row of Object.values(snapshot?.slots || {})) {
+            if (row.worker_id !== threadId)
+                continue;
+            if (!latest || row.generation_index > latest.generation_index || Date.parse(row.latest_ts) > Date.parse(latest.latest_ts))
+                latest = row;
+        }
+    }
+    return latest;
+}
+async function latestThreadSlotForMission(root, missionId, threadId) {
+    const snapshot = await readZellijSlotTelemetrySnapshotNoRebuild(root, missionId).catch(() => null);
+    let latest = null;
+    for (const row of Object.values(snapshot?.slots || {})) {
+        if (row.worker_id !== threadId)
+            continue;
+        if (!latest || row.generation_index > latest.generation_index || Date.parse(row.latest_ts) > Date.parse(latest.latest_ts))
+            latest = row;
+    }
+    return latest;
+}
+function resolveRole(payload, plan) {
+    return firstText(payload.agent_type, payload.agentType, payload.custom_agent, payload.customAgent, payload.role, payload.name, singleSuggestedAgent(plan)) || 'official_subagent';
+}
+function singleSuggestedAgent(plan) {
+    const suggested = Array.isArray(plan.suggested_agents) ? plan.suggested_agents.map(String).filter(Boolean) : [];
+    return suggested.length === 1 ? suggested[0] || null : null;
+}
+function modelForRole(plan, role) {
+    return firstText(objectValue(objectValue(plan).agents)[role]?.model);
+}
+function reasoningForRole(plan, role) {
+    return firstText(objectValue(objectValue(plan).agents)[role]?.model_reasoning_effort);
+}
+function routeArtifactPaths(missionId) {
+    const mission = safeMissionId(missionId);
+    if (!mission)
+        return [];
+    const base = `.sneakoscope/missions/${mission}`;
+    return [`${base}/subagent-plan.json`, `${base}/subagent-events.jsonl`, `${base}/subagent-evidence.json`];
+}
+function isTerminal(status) {
+    return ['completed', 'failed', 'drained'].includes(String(status || '').toLowerCase());
+}
+function failedOrAmbiguousStopBlocker(blockers) {
+    if (!Array.isArray(blockers))
+        return null;
+    return blockers
+        .map((value) => String(value || '').trim())
+        .find((value) => /^awaiting_parent_verdict:(failed|ambiguous)$/.test(value)) || null;
+}
+function safeMissionId(value) {
+    const text = String(value || '').trim();
+    if (!text || !/^[A-Za-z0-9._:-]+$/.test(text))
+        return '';
+    return text;
+}
+function boundedText(value, max) {
+    const text = String(value || '').replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '').replace(/\s+/g, ' ').trim();
+    if (!text)
+        return null;
+    return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text;
+}
+function firstText(...values) {
+    for (const value of values) {
+        const text = String(value || '').replace(/\s+/g, ' ').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+function objectValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function unique(values) {
+    return [...new Set(values.map(String).filter(Boolean))];
+}
+//# sourceMappingURL=zellij-official-subagent-telemetry.js.map

package/dist/core/zellij/zellij-pane-proof.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { reconcileZellijLaneSupervisorPaneIds } from '../agents/zellij-lane-supervisor.js';
 import { checkZellijCapability } from './zellij-capability.js';
-import { runZellij } from './zellij-command.js';
+import { runZellij, zellijCommandStdout } from './zellij-command.js';
 export const ZELLIJ_PANE_PROOF_SCHEMA = 'sks.zellij-pane-proof.v1';
 export async function writeZellijPaneProof(root, opts = {}) {
     const outRoot = path.resolve(opts.ledgerRoot || (opts.missionId ? path.join(root, '.sneakoscope', 'missions', opts.missionId) : path.join(root, '.sneakoscope', 'reports')));
@@ -13,10 +13,31 @@ export async function writeZellijPaneProof(root, opts = {}) {
     const command = sessionName
         ? ['--session', sessionName, 'action', 'list-panes', '--json', '--all']
         : ['action', 'list-panes', '--json', '--all'];
-    const paneRun = capability.status === 'ok'
-        ? await runZellij(command, { cwd: root, timeoutMs: 5000, optional: opts.require !== true })
-        : null;
-    const rawRows = parsePaneRows(paneRun?.stdout_tail || '');
+    let paneRun = null;
+    let rawRows = [];
+    const probeAttempts = [];
+    const maxProbeAttempts = opts.phase === 'post_launch' && opts.require === true ? 8 : 1;
+    if (capability.status === 'ok') {
+        for (let attempt = 1; attempt <= maxProbeAttempts; attempt += 1) {
+            paneRun = await runZellij(command, {
+                cwd: root,
+                timeoutMs: 5000,
+                maxOutputBytes: 1024 * 1024,
+                optional: opts.require !== true
+            });
+            rawRows = parseZellijPaneRows(zellijCommandStdout(paneRun));
+            probeAttempts.push({
+                attempt,
+                ok: paneRun.ok,
+                pane_count: rawRows.length,
+                duration_ms: paneRun.duration_ms,
+                output_truncated: paneRun.output_truncated
+            });
+            if (rawRows.length > 0 || !paneRun.ok || attempt === maxProbeAttempts)
+                break;
+            await delay(Math.min(400, 75 * attempt));
+        }
+    }
     const paneRows = normalizeZellijPaneRows(rawRows);
     const evaluationOpts = { expectedCwd: opts.expectedCwd || root };
     if (opts.expectedLaneCount !== undefined)
@@ -37,6 +58,7 @@ export async function writeZellijPaneProof(root, opts = {}) {
     const blockers = [
         ...capability.blockers,
         ...(opts.require === true && paneRun && !paneRun.ok ? paneRun.blockers.map((blocker) => `zellij_pane_${blocker}`) : []),
+        ...(opts.require === true && paneRun?.output_truncated ? ['zellij_pane_output_truncated'] : []),
         ...(opts.require === true && capability.status === 'ok' && paneRows.length === 0 ? ['zellij_no_panes_listed'] : []),
         ...(opts.require === true ? evaluation.blockers : [])
     ];
@@ -58,6 +80,7 @@ export async function writeZellijPaneProof(root, opts = {}) {
         geometry_distinct: evaluation.geometry_distinct,
         pane_id_reconciliation: paneIdReconciliation,
         panes: paneRows,
+        probe_attempts: probeAttempts,
         command: ['zellij', ...command],
         command_result: paneRun,
         blockers,
@@ -73,7 +96,7 @@ export async function writeZellijPaneProof(root, opts = {}) {
 export async function readZellijPaneProof(root) {
     return readJson(path.join(root, 'zellij-pane-proof.json'), null);
 }
-function parsePaneRows(text) {
+export function parseZellijPaneRows(text) {
     if (!text.trim())
         return [];
     try {
@@ -88,6 +111,9 @@ function parsePaneRows(text) {
         return [];
     }
 }
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 export function normalizeZellijPaneRows(rows) {
     return rows.map((row, index) => {
         const paneId = stringValue(row.pane_id ?? row.paneId ?? row.id ?? row.index ?? index);

package/dist/core/zellij/zellij-slot-pane-renderer.js

@@ -13,7 +13,7 @@ export function renderZellijSlotPane(input) {
     const stderr = (input.stderrTail || []).filter(Boolean).slice(-1);
     const fullDebug = mode === 'full-debug';
     const fixtureLoopProof = String(input.backend || '').includes('fixture') || String(input.patchStatus || '').includes('fixture');
-    const meta = [input.model || input.provider || '?', input.serviceTier || '?'].filter(Boolean).join('·');
+    const meta = [input.model || input.provider || '?', input.reasoningEffort || '?', input.serviceTier || '?'].filter(Boolean).join('·');
     const head = `${statusBadge(theme, input.status || 'queued')}  ${paint(theme, ANSI_CODES.bold, input.slotId)}` +
         `  ${t(input.role || 'worker', 12)}  ${paint(theme, ANSI_CODES.dim, t(meta, 28))}`;
     const prog = input.progress && input.progress.total > 0
@@ -101,16 +101,28 @@ function mergeRenderInputWithLiveTelemetry(detail, live) {
         currentTask: live.task_title || detail.currentTask || null,
         currentFile: live.current_file || detail.currentFile || null,
         role: live.role || detail.role || null,
-        backend: live.backend || detail.backend || null,
-        provider: live.provider || detail.provider || null,
-        serviceTier: live.service_tier || detail.serviceTier || null,
+        backend: preferKnownTelemetryValue(live.backend, detail.backend),
+        provider: preferKnownTelemetryValue(live.provider, detail.provider),
+        model: preferKnownTelemetryValue(live.model, detail.model),
+        serviceTier: preferKnownTelemetryValue(live.service_tier, detail.serviceTier),
+        reasoningEffort: preferKnownTelemetryValue(live.reasoning_effort, detail.reasoningEffort),
         progress: live.progress ?? null,
         blockers: live.blockers || [],
         telemetryTs: live.latest_ts || null,
         heartbeatAgeMs: live.latest_ts ? Math.max(0, Date.now() - Date.parse(live.latest_ts)) : detail.heartbeatAgeMs ?? null,
-        worktreeId: live.worktree_id || detail.worktreeId || null
+        worktreeId: live.worktree_id || detail.worktreeId || null,
+        stdoutTail: live.log_tail
+            ? [...(detail.stdoutTail || []), ...String(live.log_tail).split(/\r?\n/).filter(Boolean)].slice(-6)
+            : detail.stdoutTail || []
     };
 }
+function preferKnownTelemetryValue(live, fallback) {
+    const liveText = String(live || '').trim();
+    if (liveText && liveText.toLowerCase() !== 'unknown' && liveText !== '?')
+        return liveText;
+    const fallbackText = String(fallback || '').trim();
+    return fallbackText && fallbackText.toLowerCase() !== 'unknown' && fallbackText !== '?' ? fallbackText : null;
+}
 async function renderZellijSlotPaneFromArtifactDir(input) {
     const detail = await renderInputFromArtifactDir(input);
     if (!detail)

package/dist/core/zellij/zellij-slot-telemetry.js

@@ -22,7 +22,11 @@ export async function appendZellijSlotTelemetry(root, event) {
     const normalized = normalizeTelemetryEvent(event);
     const file = slotTelemetryEventPath(root, missionId);
     await ensureDir(path.dirname(file));
-    await appendJsonlBounded(file, normalized);
+    await withFileLock({
+        lockPath: `${file}.append.lock`,
+        timeoutMs: 30_000,
+        staleMs: 2 * 60 * 1000
+    }, async () => appendJsonlBounded(file, normalized));
     const previous = await readZellijSlotTelemetrySnapshotNoRebuild(root, missionId);
     if (previous) {
         const snapshotPath = slotTelemetrySnapshotPath(root, missionId);
@@ -181,6 +185,8 @@ function normalizeTelemetryEvent(event) {
         ...(event.backend ? { backend: String(event.backend) } : {}),
         ...(event.provider ? { provider: String(event.provider) } : {}),
         ...(event.service_tier ? { service_tier: String(event.service_tier) } : {}),
+        ...(event.model ? { model: String(event.model) } : {}),
+        ...(event.reasoning_effort ? { reasoning_effort: String(event.reasoning_effort) } : {}),
         worktree_id: event.worktree_id == null ? null : String(event.worktree_id),
         worktree_path: event.worktree_path == null ? null : String(event.worktree_path),
         ...(event.task_id ? { task_id: String(event.task_id) } : {}),
@@ -193,7 +199,9 @@ function normalizeTelemetryEvent(event) {
         })() : {}),
         ...(Array.isArray(event.artifact_paths) ? { artifact_paths: event.artifact_paths.map(String).filter(Boolean) } : {}),
         ...(event.log_tail ? { log_tail: tail(event.log_tail, 1200) } : {}),
-        ...(Array.isArray(event.blockers) ? { blockers: event.blockers.map(String).filter(Boolean) } : {})
+        ...(Array.isArray(event.blockers) ? { blockers: event.blockers.map(String).filter(Boolean) } : {}),
+        ...(event.activity_source ? { activity_source: String(event.activity_source) } : {}),
+        ...(event.activity_hash ? { activity_hash: String(event.activity_hash) } : {})
     };
 }
 function mergeSlotTelemetry(previous, event) {
@@ -214,6 +222,8 @@ function mergeSlotTelemetry(previous, event) {
         backend: event.backend || previous?.backend || 'unknown',
         provider: event.provider || previous?.provider || 'unknown',
         service_tier: event.service_tier || previous?.service_tier || 'unknown',
+        model: event.model || previous?.model || 'unknown',
+        reasoning_effort: event.reasoning_effort || previous?.reasoning_effort || 'unknown',
         worktree_id: event.worktree_id ?? previous?.worktree_id ?? null,
         worktree_path: event.worktree_path ?? previous?.worktree_path ?? null,
         task_title: event.task_title || previous?.task_title || event.task_id || 'waiting for task',
@@ -225,7 +235,9 @@ function mergeSlotTelemetry(previous, event) {
         progress: stale ? previous.progress || (terminalRegression ? null : event.progress || null) : event.progress || previous?.progress || null,
         artifact_paths: unique([...(previous?.artifact_paths || []), ...(event.artifact_paths || [])]),
         blockers: unique([...(previous?.blockers || []), ...(event.blockers || [])]),
-        log_tail: stale ? previous.log_tail || (terminalRegression ? '' : event.log_tail || '') : event.log_tail || previous?.log_tail || ''
+        log_tail: stale ? previous.log_tail || (terminalRegression ? '' : event.log_tail || '') : event.log_tail || previous?.log_tail || '',
+        activity_source: stale ? previous.activity_source ?? null : event.activity_source || previous?.activity_source || null,
+        activity_hash: stale ? previous.activity_hash ?? null : event.activity_hash || previous?.activity_hash || null
     };
 }
 function countSlotTelemetry(slots) {

package/dist/core/zellij/zellij-ui-mode.js

@@ -3,7 +3,7 @@ export function resolveZellijUiConfig(args = [], env = process.env) {
         mode: resolveZellijUiMode(args, env),
         color: env.SKS_ZELLIJ_COLOR !== '0' && env.NO_COLOR !== '1',
         visiblePanes: Number(env.SKS_ZELLIJ_VISIBLE_PANES) || null,
-        viewports: boundedInt(env.SKS_ZELLIJ_VIEWPORTS, 4, 0, 6),
+        viewports: boundedInt(env.SKS_ZELLIJ_VIEWPORTS, 1, 0, 3),
         monitorRows: Math.max(4, Number(env.SKS_ZELLIJ_MONITOR_ROWS || 12)),
         monitor: env.SKS_ZELLIJ_MONITOR_PANE !== '0',
         intervalMs: Math.max(500, Number(env.SKS_ZELLIJ_REFRESH_MS) || 1000)

package/dist/core/zellij/zellij-viewport-binder.js

@@ -1,5 +1,6 @@
 const ACTIVE = new Set(['running', 'verifying', 'launching']);
 const ATTENTION = new Set(['failed', 'blocked', 'timed_out']);
+const RECENT_COMPLETED_GRACE_MS = 60_000;
 function scoreSlot(s, now) {
     const ts = Date.parse(String(s.latest_ts || '')) || 0;
     const age = Math.max(0, now - ts);
@@ -12,6 +13,8 @@ function scoreSlot(s, now) {
         return 2_000_000 - age / 1000;
     if (st === 'queued' || st === 'launching')
         return 1_000_000 - age / 1000;
+    if ((st === 'completed' || st === 'done' || st === 'drained') && age < RECENT_COMPLETED_GRACE_MS)
+        return 500_000 - age / 1000;
     return -1;
 }
 export function bindViewports(input) {

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -4,7 +4,7 @@ import { appendParallelRuntimeEvent } from '../agents/parallel-runtime-proof.js'
 import { providerPaneLabel } from '../provider/provider-badge.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
 import { checkZellijStackedPaneCapability } from './zellij-capability.js';
-import { runZellij } from './zellij-command.js';
+import { runZellij, zellijCommandStdout } from './zellij-command.js';
 import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
 import { buildZellijSlotColumnAnchorCommand } from './zellij-slot-column-anchor.js';
 import { closeWorkerInRightColumn, prepareWorkerInRightColumn, readRightColumnState, recordSlotColumnAnchorInRightColumn, recordWorkerPaneInRightColumn } from './zellij-right-column-manager.js';
@@ -629,6 +629,7 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
     const listed = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], {
         cwd,
         timeoutMs: 5000,
+        maxOutputBytes: 1024 * 1024,
         optional: true
     });
     const screen = await runZellij(['--session', sessionName, 'action', 'dump-screen'], {
@@ -636,7 +637,7 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
         timeoutMs: 5000,
         optional: true
     });
-    const rows = parsePaneRows(listed.stdout_tail);
+    const rows = parsePaneRows(zellijCommandStdout(listed));
     const pane = rows.find((row) => {
         const title = String(row.title || row.name || row.pane_name || '');
         const command = String(row.terminal_command || row.command || row.command_line || row.running_command || '');
@@ -665,11 +666,12 @@ async function findExistingSlotsAnchorPaneId(sessionName, cwd) {
     const listed = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], {
         cwd,
         timeoutMs: 5000,
+        maxOutputBytes: 1024 * 1024,
         optional: true
     });
     if (!listed.ok)
         return null;
-    const rows = parsePaneRows(listed.stdout_tail);
+    const rows = parsePaneRows(zellijCommandStdout(listed));
     const pane = rows.find((row) => {
         if (row?.is_plugin === true)
             return false;

package/dist/scripts/agent-fast-mode-default-check.js

@@ -1,37 +1,54 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
 const distCli = path.join(root, 'dist', 'bin', 'sks.js');
 function run(extra = []) {
-    return JSON.parse(execFileSync(process.execPath, [
-        distCli,
-        'agent',
-        'run',
-        'fast mode default fixture',
-        '--mock',
-        '--agents',
-        '2',
-        '--concurrency',
-        '2',
-        '--work-items',
-        '2',
-        '--minimum-work-items',
-        '2',
-        '--json',
-        ...extra
-    ], {
-        cwd: root,
-        encoding: 'utf8',
-        env: {
-            ...process.env,
-            SKS_TEST_ISOLATION: '1',
-            SKS_RELEASE_FIXTURE_ACTIVE_ROUTE_BYPASS: '1'
-        },
-        maxBuffer: 32 * 1024 * 1024
-    }));
+    const fixtureRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-agent-fast-mode-fixture-'));
+    const fixtureHome = path.join(fixtureRoot, 'home');
+    try {
+        return JSON.parse(execFileSync(process.execPath, [
+            distCli,
+            'agent',
+            'run',
+            'fast mode default fixture',
+            '--mock',
+            '--agents',
+            '2',
+            '--concurrency',
+            '2',
+            '--work-items',
+            '2',
+            '--minimum-work-items',
+            '2',
+            '--json',
+            ...extra
+        ], {
+            cwd: fixtureRoot,
+            encoding: 'utf8',
+            env: {
+                ...process.env,
+                HOME: fixtureHome,
+                CODEX_HOME: path.join(fixtureHome, '.codex'),
+                SKS_GLOBAL_ROOT: path.join(fixtureHome, '.sneakoscope-global'),
+                TMPDIR: fixtureRoot,
+                TMP: fixtureRoot,
+                TEMP: fixtureRoot,
+                PWD: fixtureRoot,
+                SKS_TEST_ISOLATION: '1',
+                SKS_UPDATE_MIGRATION_GATE_DISABLED: '1',
+                NODE_ENV: 'test',
+                CI: 'true'
+            },
+            maxBuffer: 32 * 1024 * 1024
+        }));
+    }
+    finally {
+        fs.rmSync(fixtureRoot, { recursive: true, force: true });
+    }
 }
 const defaultRun = run();
 const fastRun = run(['--fast']);
@@ -44,6 +61,7 @@ const report = {
         mission_id: defaultRun.mission_id,
         fast_mode: defaultRun.fast_mode_policy?.fast_mode,
         service_tier: defaultRun.fast_mode_policy?.service_tier,
+        default_fast_mode: defaultRun.fast_mode_policy?.default_fast_mode,
         preference_mode: defaultRun.fast_mode_policy?.preference_mode,
         explicit_fast: defaultRun.fast_mode_policy?.explicit_fast,
         explicit_service_tier: defaultRun.fast_mode_policy?.explicit_service_tier,
@@ -73,11 +91,12 @@ fs.mkdirSync(path.dirname(out), { recursive: true });
 fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
 assertGate(defaultRun.ok === true, 'default agent run must pass', report);
 assertGate(defaultRun.fast_mode_policy?.explicit_fast === false && defaultRun.fast_mode_policy?.explicit_service_tier === null, 'default run must not use explicit fast/service-tier flags', report);
-if (defaultRun.fast_mode_policy?.preference_mode === 'fast') {
-    assertGate(defaultRun.fast_mode_policy?.fast_mode === true && defaultRun.fast_mode_policy?.service_tier === 'fast', 'default run must honor saved fast preference', report);
+assertGate(defaultRun.fast_mode_policy?.default_fast_mode === true, 'built-in Fast default must be recorded', report);
+if (defaultRun.fast_mode_policy?.preference_mode === 'standard') {
+    assertGate(defaultRun.fast_mode_policy?.fast_mode === false && defaultRun.fast_mode_policy?.service_tier === 'standard', 'default run must honor saved standard preference', report);
 }
 else {
-    assertGate(defaultRun.fast_mode_policy?.fast_mode === false && defaultRun.fast_mode_policy?.service_tier === 'standard', 'default run without saved fast preference must record service_tier standard', report);
+    assertGate(defaultRun.fast_mode_policy?.fast_mode === true && defaultRun.fast_mode_policy?.service_tier === 'fast', 'default run without a saved standard preference must use Fast', report);
 }
 assertGate(fastRun.fast_mode_policy?.fast_mode === true, '--fast must enable fast mode', report);
 assertGate(fastRun.fast_mode_policy?.service_tier === 'fast', '--fast must record service_tier fast', report);