sneakoscope 4.8.6 → 5.1.2

package/dist/core/zellij/zellij-self-heal.js

@@ -1,9 +1,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { ensureDir, nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+import { withHeartbeat } from '../../cli/cli-theme.js';
 import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
 import { guardContextForRoute, guardedPackageInstall } from '../safety/mutation-guard.js';
 import { mutationLedgerPath } from '../safety/mutation-ledger.js';
+import { confirmRepair } from '../doctor/confirm-repair.js';
 import { checkZellijCapability, ZELLIJ_MIN_VERSION } from './zellij-capability.js';
 import { compareVersionLike } from './zellij-command.js';
 import { askHomebrewInstallAllowed, HOMEBREW_INSTALL_COMMAND, resolveHomebrewInstallPolicy } from './homebrew-policy.js';
@@ -44,17 +46,20 @@ export async function repairZellijForSks(input) {
     if (dryRun) {
         return dryRunResult(root, input, env, before, latest, brew, mutationArtifact);
     }
-    if (!autoApproved && input.interactive !== true) {
-        return input.allowHeadlessFallback === true
-            ? headlessResult(root, input, before, latest, brew, 'noninteractive_without_auto_approval')
-            : manualResult(root, input, env, before, latest, brew, 'noninteractive_without_auto_approval');
-    }
-    if (!autoApproved && input.interactive === true) {
-        const accepted = await askZellijRepairAllowed(before.status === 'missing'
-            ? 'Zellij is missing. Install it with Homebrew now? [Y/n] '
-            : `Zellij ${before.version || 'unknown'} needs repair. Upgrade with Homebrew now? [Y/n] `);
-        if (!accepted)
-            return manualResult(root, input, env, before, latest, brew, 'operator_declined_zellij_repair');
+    if (!autoApproved) {
+        const approval = await confirmRepair({
+            autoApprove: autoApproved,
+            interactive: input.interactive === true,
+            question: before.status === 'missing'
+                ? 'Zellij is missing. Install it with Homebrew now? [Y/n] '
+                : `Zellij ${before.version || 'unknown'} needs repair. Upgrade with Homebrew now? [Y/n] `
+        });
+        if (!approval.approved) {
+            const reason = approval.reason === 'non_interactive_requires_yes' ? approval.reason : 'operator_declined_zellij_repair';
+            return input.allowHeadlessFallback === true
+                ? headlessResult(root, input, before, latest, brew, reason)
+                : manualResult(root, input, env, before, latest, brew, reason, approval.next_actions);
+        }
     }
     let brewBin = brew.bin;
     let homebrewInstallAttempted = false;
@@ -76,7 +81,7 @@ export async function repairZellijForSks(input) {
                 : manualResult(root, input, env, before, latest, brew, policy.blockers[0] || 'homebrew_missing');
         }
         homebrewInstallAttempted = true;
-        const homebrewRun = await runHomebrewInstall(root, env);
+        const homebrewRun = await runHomebrewInstall(root, env, input.quiet === true);
         if (homebrewRun.code !== 0) {
             return persistSelfHeal(root, input.missionDir, {
                 schema: 'sks.zellij-self-heal.v1',
@@ -108,7 +113,7 @@ export async function repairZellijForSks(input) {
         : install ? 'brew-install-zellij'
             : 'brew-upgrade-zellij';
     const command = `brew ${brewArgs.join(' ')}`;
-    const run = await runZellijBrew(root, env, brewBin, brewArgs, command);
+    const run = await runZellijBrew(root, env, brewBin, brewArgs, command, input.quiet === true);
     if (run.code !== 0 && /already installed|already up-to-date/i.test(`${run.stdout}\n${run.stderr}`)) {
         const after = await capabilitySnapshot(root, env, 'after-noop');
         return persistSelfHeal(root, input.missionDir, {
@@ -246,7 +251,7 @@ async function findBrew(env) {
         return { present: true, bin: 'brew' };
     return { present: false, bin: null };
 }
-async function runZellijBrew(root, env, brewBin, args, command) {
+async function runZellijBrew(root, env, brewBin, args, command, quiet = false) {
     if (env.SKS_ZELLIJ_SELF_HEAL_FAKE_RUN === '1') {
         await appendFakeBrewLog(env, args);
         return { code: Number(env.SKS_ZELLIJ_SELF_HEAL_FAKE_RUN_CODE || 0), stdout: 'fake brew ok', stderr: '' };
@@ -257,7 +262,7 @@ async function runZellijBrew(root, env, brewBin, args, command) {
         projectRoot: root,
         overrides: { package_install: true, zellij_install: true }
     });
-    return guardedPackageInstall(guardContextForRoute(root, contract, command), 'zellij', {
+    const work = guardedPackageInstall(guardContextForRoute(root, contract, command), 'zellij', {
         confirmed: true,
         command: brewBin,
         args,
@@ -265,8 +270,9 @@ async function runZellijBrew(root, env, brewBin, args, command) {
         timeoutMs: 180000,
         maxOutputBytes: 256 * 1024
     }).catch((err) => ({ code: 1, stdout: '', stderr: errorMessage(err) }));
+    return quiet ? await work : await withHeartbeat('brew zellij repair', work, { warnAfterMs: 30_000 });
 }
-async function runHomebrewInstall(root, env) {
+async function runHomebrewInstall(root, env, quiet = false) {
     if (env.SKS_ZELLIJ_SELF_HEAL_FAKE_RUN === '1') {
         await appendFakeBrewLog(env, ['install-homebrew']);
         return { code: Number(env.SKS_ZELLIJ_SELF_HEAL_FAKE_HOMEBREW_CODE || 0), stdout: 'fake homebrew install ok', stderr: '' };
@@ -277,7 +283,7 @@ async function runHomebrewInstall(root, env) {
         projectRoot: root,
         overrides: { package_install: true, zellij_install: true }
     });
-    return guardedPackageInstall(guardContextForRoute(root, contract, HOMEBREW_INSTALL_COMMAND), 'homebrew', {
+    const work = guardedPackageInstall(guardContextForRoute(root, contract, HOMEBREW_INSTALL_COMMAND), 'homebrew', {
         confirmed: true,
         command: '/bin/bash',
         args: ['-c', 'curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh | /bin/bash'],
@@ -285,6 +291,7 @@ async function runHomebrewInstall(root, env) {
         timeoutMs: 600000,
         maxOutputBytes: 256 * 1024
     }).catch((err) => ({ code: 1, stdout: '', stderr: errorMessage(err) }));
+    return quiet ? await work : await withHeartbeat('Homebrew install', work, { warnAfterMs: 60_000 });
 }
 async function appendFakeBrewLog(env, args) {
     if (!env.SKS_FAKE_BREW_LOG)
@@ -342,7 +349,7 @@ async function dryRunResult(root, input, env, before, latest, brew, mutationArti
         warnings: ['dry_run_no_mutation_performed']
     });
 }
-async function manualResult(root, input, env, before, latest, brew, reason) {
+async function manualResult(root, input, env, before, latest, brew, reason, nextActions = []) {
     const command = brew.present ? 'sks doctor --fix --yes' : 'sks doctor --fix --install-homebrew --yes';
     return persistSelfHeal(root, input.missionDir, {
         schema: 'sks.zellij-self-heal.v1',
@@ -359,7 +366,8 @@ async function manualResult(root, input, env, before, latest, brew, reason) {
         mutation_guard_artifact: null,
         homebrew: { present: brew.present, bin: brew.bin, install_attempted: false, install_allowed: false },
         blockers: [reason],
-        warnings: []
+        warnings: [],
+        next_actions: nextActions.length ? nextActions : [`Run: ${command}`]
     });
 }
 async function headlessResult(root, input, before, latest, brew, reason) {
@@ -392,19 +400,6 @@ async function persistSelfHeal(root, missionDir, result) {
         await writeJsonAtomic(path.join(missionDir, 'zellij-self-heal.json'), normalized).catch(() => undefined);
     return normalized;
 }
-async function askZellijRepairAllowed(question) {
-    if (!(process.stdin.isTTY && process.stdout.isTTY))
-        return false;
-    const rl = (await import('node:readline')).createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = await new Promise((resolve) => rl.question(question, resolve));
-        const trimmed = String(answer || '').trim();
-        return trimmed === '' || /^(y|yes|예|네|응)$/i.test(trimmed);
-    }
-    finally {
-        rl.close();
-    }
-}
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }

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

@@ -1,76 +1,158 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { readZellijSlotTelemetrySnapshot } from './zellij-slot-telemetry.js';
+import { resolveZellijTheme, paint, statusBadge, progressBar, elapsed, ANSI_CODES } from './zellij-theme.js';
 export function renderZellijSlotPane(input) {
+    const theme = resolveZellijTheme();
+    const W = Math.max(20, theme.width - 4);
+    const t = (s, w = W) => trimInline(String(s ?? ''), w);
     const mode = input.mode || 'compact-slots';
-    const maxLines = mode === 'compact-slots' ? 17 : mode === 'dashboard-plus-slots' ? 20 : 32;
-    const task = trimInline(input.currentTask || input.currentFile || 'waiting for worker intake', 78);
-    const heartbeat = input.heartbeatAgeMs == null
-        ? 'unknown'
-        : input.heartbeatAgeMs < 1000
-            ? 'now'
-            : `${Math.max(1, Math.round(input.heartbeatAgeMs / 1000))}s ago`;
-    const files = firstNonEmptyList(input.changedFiles, input.patchFiles, input.plannedFiles, input.currentFile ? [input.currentFile] : []);
+    const maxLines = mode === 'compact-slots' ? 14 : mode === 'dashboard-plus-slots' ? 18 : 30;
     const events = (input.eventLines || []).filter(Boolean).slice(-10);
     const stdout = (input.stdoutTail || []).filter(Boolean).slice(-6);
     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 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
+        ? progressBar(theme, input.progress.done, input.progress.total)
+        : paint(theme, ANSI_CODES.dim, `elapsed ${elapsed(input.telemetryTs) || '-'}  heartbeat ${formatHeartbeat(input.heartbeatAgeMs)}`);
+    const doing = `${paint(theme, ANSI_CODES.bold, '▸ ')}${t(input.currentTask || 'waiting for work item')}`;
+    const file = input.currentFile ? paint(theme, ANSI_CODES.dim, `file ${t(input.currentFile)}`) : null;
+    const worktree = input.worktreeId ? paint(theme, ANSI_CODES.dim, `worktree ${t(input.worktreeId, 32)}`) : null;
+    const patch = ((input.patchStatus && input.patchStatus !== 'queued') || (input.verifyStatus && input.verifyStatus !== 'queued'))
+        ? `patch ${t(input.patchStatus || '-', 18)} · verify ${t(input.verifyStatus || '-', 18)}`
+        : null;
+    const blockers = (input.blockers || []).slice(0, 2).map((b) => paint(theme, ANSI_CODES.red, `! ${t(b)}`));
+    const tail = [
+        ...stderr.slice(-1).map((line) => paint(theme, ANSI_CODES.red, `err ${t(line)}`)),
+        ...stdout.slice(-3).map((line) => paint(theme, ANSI_CODES.dim, `    ${t(line)}`))
+    ];
     const rows = [
-        input.loopId ? `${trimInline(input.loopId, 28)} · ${trimInline(input.loopRole || input.role || 'worker', 14)} · ${input.slotId}` : null,
-        `slot: ${input.slotId} / gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))} / ${trimInline(input.status || 'running', 18)}`,
-        `role: ${trimInline(input.role || 'worker', 18)}  backend: ${trimInline(input.backend || 'codex-sdk', 20)}  worktree: ${trimInline(input.worktreeId || '-', 18)}`,
-        `runtime: fast ${formatFastMode(input.fastMode, input.serviceTier)}  tier: ${trimInline(input.serviceTier || 'unknown', 12)}  provider: ${trimInline(input.provider || 'unknown', 18)}`,
-        `model: ${trimInline(input.model || 'unknown', 28)}  reasoning: ${trimInline(input.reasoningEffort || 'unknown', 16)}${input.authMode ? `  auth: ${trimInline(input.authMode, 14)}` : ''}`,
-        input.sessionId ? `session: ${trimInline(input.sessionId, 62)}` : null,
-        `heartbeat: ${heartbeat}${input.heartbeatEvent ? `  event: ${trimInline(input.heartbeatEvent, 40)}` : ''}`,
-        `doing: ${task}`,
-        input.loopGate ? `gate: ${trimInline(input.loopGate, 68)}${input.verifyStatus ? ` · ${trimInline(input.verifyStatus, 18)}` : ''}` : null,
-        fixtureLoopProof ? 'fixture loop proof · not production execution' : null,
-        `files: ${trimInline(files.length ? files.join(', ') : 'no changed file yet', 78)}`,
-        `patch: ${trimInline(input.patchStatus || 'queued', 24)}  verify: ${trimInline(input.verifyStatus || 'queued', 24)}`,
-        input.qaAppHandoffPending ? `QA app handoff pending: ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 55)}` : null,
-        ...events.map((event) => `event: ${trimInline(event, 78)}`),
-        ...stdout.map((line) => `out: ${trimInline(line, 79)}`),
-        ...stderr.map((line) => `err: ${trimInline(line, 79)}`)
+        head,
+        prog,
+        doing,
+        file,
+        worktree,
+        patch,
+        input.qaAppHandoffPending ? `QA app handoff pending: ${t(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json')}` : null,
+        ...blockers,
+        ...tail,
+        ...(fullDebug ? [
+            input.sessionId ? `session ${t(input.sessionId, 62)}` : null,
+            input.loopId ? `loop ${t(input.loopId, 28)} · ${t(input.loopRole || input.role || 'worker', 14)}` : null,
+            input.loopGate ? `gate ${t(input.loopGate)}` : null,
+            fixtureLoopProof ? 'fixture loop proof · not production execution' : null,
+            ...events.map((event) => `event ${t(event)}`)
+        ] : [])
     ].filter((row) => Boolean(row));
-    return frameSlotPane(`LIVE SLOT ${input.slotId}`, rows.slice(0, Math.max(1, maxLines - 2)));
+    return frameSlotPane(input.slotId, rows.slice(0, Math.max(1, maxLines - 2)), theme);
 }
 export async function renderZellijSlotPaneFromArtifacts(input) {
-    const artifactRender = await renderZellijSlotPaneFromArtifactDir(input).catch(() => null);
+    const detail = await renderInputFromArtifactDir(input).catch(() => null);
     if (input.missionId && input.missionId !== 'latest') {
-        const telemetry = await tryRenderTelemetrySlotPane({
-            artifactRoot: input.artifactRoot || input.artifactDir,
-            missionId: input.missionId,
+        const telemetry = await readZellijSlotTelemetrySnapshot(path.resolve(input.artifactRoot || input.artifactDir), input.missionId).catch(() => null);
+        const live = findTelemetrySlot(telemetry, input.slotId, input.generationIndex);
+        const merged = mergeRenderInputWithLiveTelemetry({
             slotId: input.slotId,
             generationIndex: input.generationIndex,
-            artifactRender
-        });
-        if (telemetry)
-            return telemetry;
-        if (artifactRender)
-            return artifactRender;
-        return [
-            `${input.slotId} gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))}`,
-            'waiting for telemetry...',
-            `mission ${input.missionId}`
-        ].join('\n');
+            role: input.role ?? null,
+            backend: input.backend ?? null,
+            provider: input.provider ?? null,
+            model: input.model ?? null,
+            serviceTier: input.serviceTier ?? null,
+            reasoningEffort: input.reasoningEffort ?? null,
+            currentTask: input.currentTask ?? null,
+            status: 'launching',
+            mode: input.mode || 'compact-slots',
+            ...(detail || {})
+        }, live);
+        return renderZellijSlotPane(merged);
     }
-    if (artifactRender)
-        return artifactRender;
     const fallbackInput = {
         slotId: input.slotId,
         generationIndex: input.generationIndex,
         status: 'launching',
-        currentTask: 'waiting for worker intake',
+        currentTask: input.currentTask || 'waiting for worker intake',
         mode: input.mode || 'compact-slots'
     };
     if (input.role !== undefined)
         fallbackInput.role = input.role;
     if (input.backend !== undefined)
         fallbackInput.backend = input.backend;
-    return renderZellijSlotPane(fallbackInput);
+    if (input.provider !== undefined)
+        fallbackInput.provider = input.provider;
+    if (input.model !== undefined)
+        fallbackInput.model = input.model;
+    if (input.serviceTier !== undefined)
+        fallbackInput.serviceTier = input.serviceTier;
+    if (input.reasoningEffort !== undefined)
+        fallbackInput.reasoningEffort = input.reasoningEffort;
+    return renderZellijSlotPane(detail || fallbackInput);
+}
+function mergeRenderInputWithLiveTelemetry(detail, live) {
+    if (!live)
+        return detail;
+    return {
+        ...detail,
+        status: live.status ?? detail.status,
+        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,
+        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
+    };
 }
 async function renderZellijSlotPaneFromArtifactDir(input) {
+    const detail = await renderInputFromArtifactDir(input);
+    if (!detail)
+        return null;
+    return renderZellijSlotPane(detail);
+}
+async function renderInputFromArtifactDir(input) {
+    const envDefaults = {
+        provider: (input.provider ?? process.env.SKS_SLOT_PROVIDER) || null,
+        model: (input.model ?? process.env.SKS_SLOT_MODEL) || null,
+        serviceTier: (input.serviceTier ?? process.env.SKS_SLOT_TIER) || null,
+        reasoningEffort: (input.reasoningEffort ?? process.env.SKS_SLOT_REASONING) || null,
+        currentTask: (input.currentTask ?? process.env.SKS_SLOT_TASK) || null,
+        role: (input.role ?? process.env.SKS_SLOT_ROLE) || null
+    };
+    const detail = await renderInputFromArtifactDirRaw(input);
+    if (!detail) {
+        return {
+            slotId: input.slotId,
+            generationIndex: input.generationIndex,
+            role: envDefaults.role,
+            backend: input.backend || null,
+            provider: envDefaults.provider,
+            model: envDefaults.model,
+            serviceTier: envDefaults.serviceTier,
+            reasoningEffort: envDefaults.reasoningEffort,
+            currentTask: envDefaults.currentTask || 'waiting for worker intake',
+            status: 'launching',
+            mode: input.mode || 'compact-slots'
+        };
+    }
+    return {
+        ...detail,
+        role: detail.role || envDefaults.role,
+        provider: detail.provider || envDefaults.provider,
+        model: detail.model || envDefaults.model,
+        serviceTier: detail.serviceTier || envDefaults.serviceTier,
+        reasoningEffort: detail.reasoningEffort || envDefaults.reasoningEffort,
+        currentTask: detail.currentTask || envDefaults.currentTask
+    };
+}
+async function renderInputFromArtifactDirRaw(input) {
     const artifactDir = path.resolve(input.artifactDir);
     const result = await readJson(path.join(artifactDir, 'worker-result.json'));
     const intake = await readJson(path.join(artifactDir, 'worker-intake.json'));
@@ -105,7 +187,7 @@ async function renderZellijSlotPaneFromArtifactDir(input) {
     const qaAppHandoff = await readQaAppHandoffNearArtifactDir(artifactDir);
     if (!result && !intake && !backendReport && !processReport && !paneReport && !codexProof && !localProof && !heartbeatMtime && !eventRows.length)
         return null;
-    return renderZellijSlotPane({
+    return {
         slotId: input.slotId,
         generationIndex: input.generationIndex,
         sessionId: result?.session_id || intake?.agent?.session_id || backendReport?.session_id || null,
@@ -164,7 +246,7 @@ async function renderZellijSlotPaneFromArtifactDir(input) {
         qaAppHandoffPending: ['pending', 'blocked_for_desktop_review'].includes(String(qaAppHandoff?.status || '')),
         qaAppHandoffArtifact: qaAppHandoff?.artifact_path || null,
         mode: input.mode || 'compact-slots'
-    });
+    };
 }
 async function readQaAppHandoffNearArtifactDir(artifactDir) {
     let current = path.resolve(artifactDir);
@@ -226,78 +308,25 @@ export function buildZellijSlotPaneCommand(input) {
         ...(input.role ? ['--role', input.role] : []),
         ...(input.watch ? ['--watch'] : [])
     ];
-    return [input.nodePath || process.execPath, ...args].map(shellQuote).join(' ');
-}
-async function tryRenderTelemetrySlotPane(input) {
-    const snapshot = await readZellijSlotTelemetrySnapshot(path.resolve(input.artifactRoot), input.missionId).catch(() => null);
-    if (!snapshot || !Object.keys(snapshot.slots || {}).length)
-        return null;
-    const slot = findTelemetrySlot(snapshot, input.slotId, input.generationIndex);
-    if (!slot)
-        return null;
-    const staleRows = staleTelemetryRows(telemetryStatus(snapshot).telemetry_age_ms);
-    const fallbackRows = artifactFallbackRows(input.artifactRender);
-    // Always surface the live artifact rows (current file, tool events, stdout
-    // tail). Telemetry freshness only tells us the worker is alive — the user
-    // still needs to see WHAT the worker is doing right now.
-    const liveRows = fallbackRows;
-    if (slot.status === 'failed') {
-        return [
-            `${slot.slot_id} gen-${slot.generation_index} · FAILED`,
-            ...staleRows,
-            ...liveRows,
-            `blocker: ${trimInline(slot.blockers[0] || 'worker_failed', 78)}`,
-            `artifact: ${trimInline(slot.artifact_paths[slot.artifact_paths.length - 1] || '-', 78)}`
-        ].join('\n');
-    }
-    if (slot.status === 'completed' || slot.status === 'drained') {
-        return [
-            `${slot.slot_id} gen-${slot.generation_index} · done`,
-            ...staleRows,
-            ...liveRows,
-            `artifacts ${slot.artifact_paths.length} · ${slot.latest_event_type === 'verification_passed' ? 'verify passed' : 'verify queued'}`,
-            'closing in 3s'
-        ].join('\n');
-    }
-    const backend = [slot.backend, slot.service_tier, slot.worktree_id].filter((value) => value && value !== 'unknown').join(' · ') || 'worker';
-    const heartbeat = slot.latest_ts ? `${Math.max(0, Math.round((Date.now() - Date.parse(slot.latest_ts)) / 1000))}s` : '?';
-    return [
-        `${slot.slot_id} gen-${slot.generation_index} · ${trimInline(slot.role || 'worker', 28)}`,
-        ...staleRows,
-        ...liveRows,
-        trimInline(backend, 78),
-        `${slot.status}: ${trimInline(slot.task_title || 'worker task', 68)}`,
-        `${formatTelemetryProgress(slot.progress, slot.started_at || slot.latest_ts)} · latest ${slot.latest_event_type} ${heartbeat}`,
-        `${slot.latest_event_type === 'patch_candidate' ? 'patch candidate' : 'patch'}: ${slot.latest_event_type === 'patch_candidate' ? 'queued' : trimInline(slot.current_file || '-', 42)}`
-    ].join('\n');
-}
-function artifactFallbackRows(text) {
-    if (!text)
-        return [];
-    return String(text)
-        .split(/\r?\n/)
-        .map((line) => line.replace(/^\|\s?/, '').replace(/\s?\|$/, '').trim())
-        .filter((line) => /^(heartbeat|doing|files|event|out|err):\s+/i.test(line))
-        .filter((line) => !/unknown|waiting for worker intake|no changed file yet/i.test(line))
-        .slice(-12)
-        .map((line) => `live: ${trimInline(line, 72)}`);
+    const env = {
+        SKS_SLOT_PROVIDER: String(input.provider || ''),
+        SKS_SLOT_MODEL: String(input.model || ''),
+        SKS_SLOT_TIER: String(input.serviceTier || ''),
+        SKS_SLOT_REASONING: String(input.reasoningEffort || ''),
+        SKS_SLOT_TASK: String(input.currentTask || '').slice(0, 200),
+        SKS_SLOT_ROLE: String(input.role || '')
+    };
+    const envPrefix = Object.entries(env)
+        .filter(([, value]) => value)
+        .map(([key, value]) => `${key}=${shellQuote(value)}`);
+    return [...envPrefix, input.nodePath || process.execPath, ...args].map((part, index) => index < envPrefix.length ? part : shellQuote(part)).join(' ');
 }
 function findTelemetrySlot(snapshot, slotId, generationIndex) {
+    if (!snapshot)
+        return null;
     const generation = Math.max(1, Math.floor(Number(generationIndex) || 1));
     return Object.values(snapshot.slots || {}).find((row) => row.slot_id === slotId && Number(row.generation_index) === generation) || null;
 }
-function formatTelemetryProgress(progress, startedAt) {
-    if (!progress || (progress.total === 0 && progress.done > 0))
-        return `elapsed ${formatElapsedSince(startedAt)}`;
-    return `progress ${progress.done}/${progress.total}${progress.label ? ` ${trimInline(progress.label, 24)}` : ''}`;
-}
-function formatElapsedSince(startedAt) {
-    const start = Date.parse(String(startedAt || ''));
-    const seconds = Number.isFinite(start) ? Math.max(0, Math.floor((Date.now() - start) / 1000)) : 0;
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return `${String(mins).padStart(2, '0')}:${String(secs).padStart(2, '0')}`;
-}
 function telemetryStatus(snapshot) {
     const parsed = snapshot?.updated_at ? Date.parse(snapshot.updated_at) : NaN;
     const telemetryAgeMs = Number.isFinite(parsed) ? Math.max(0, Date.now() - parsed) : Number.MAX_SAFE_INTEGER;
@@ -309,15 +338,6 @@ function telemetryStatus(snapshot) {
         telemetry_age_ms: telemetryAgeMs
     };
 }
-function staleTelemetryRows(ageMs) {
-    if (!Number.isFinite(ageMs))
-        return ['telemetry stale; worker may still be running'];
-    if (ageMs > 60000)
-        return ['telemetry stale; worker may still be running'];
-    if (ageMs > 15000)
-        return [`telemetry stale ${(ageMs / 1000).toFixed(1)}s`];
-    return [];
-}
 async function readJson(file) {
     try {
         return JSON.parse(await fs.promises.readFile(file, 'utf8'));
@@ -463,14 +483,6 @@ function firstDefined(...values) {
     }
     return null;
 }
-function firstNonEmptyList(...values) {
-    for (const value of values) {
-        const normalized = normalizeList(value || []);
-        if (normalized.length)
-            return normalized;
-    }
-    return [];
-}
 function normalizeList(values) {
     return [...new Set((Array.isArray(values) ? values : [values]).map((value) => String(value || '').trim()).filter(Boolean))];
 }
@@ -478,31 +490,28 @@ function trimInline(value, max) {
     const text = String(value || '').replace(/\s+/g, ' ').trim();
     if (text.length <= max)
         return text;
-    return text.slice(0, Math.max(1, max - 3)) + '...';
-}
-function formatFastMode(value, serviceTier) {
-    const text = String(value ?? '').trim().toLowerCase();
-    if (value === true || text === 'true' || text === '1' || text === 'on' || text === 'fast')
-        return 'on';
-    if (value === false || text === 'false' || text === '0' || text === 'off' || text === 'standard')
-        return 'off';
-    const tier = String(serviceTier || '').trim().toLowerCase();
-    if (tier === 'fast' || tier === 'priority')
-        return 'on';
-    if (tier === 'standard' || tier === 'default')
-        return 'off';
-    return 'unknown';
-}
-function frameSlotPane(title, rows) {
-    const width = Math.min(96, Math.max(44, title.length + 6, ...rows.map((row) => row.length + 4)));
-    const line = '+' + '-'.repeat(width - 2) + '+';
-    const label = ` ${trimInline(title, width - 4)} `;
-    const titleLine = '|' + label.padEnd(width - 2, ' ') + '|';
+    return text.slice(0, Math.max(1, max - 1)) + '…';
+}
+function formatHeartbeat(value) {
+    if (value == null || !Number.isFinite(value))
+        return 'unknown';
+    if (value < 1000)
+        return 'now';
+    return `${Math.max(1, Math.round(value / 1000))}s`;
+}
+function frameSlotPane(title, rows, theme) {
+    const width = theme.width;
+    const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+    const inner = width - 2;
+    const visibleTitle = strip(title);
+    const top = `┌─ ${title} ${'─'.repeat(Math.max(0, inner - visibleTitle.length - 4))}┐`;
     const body = rows.map((row) => {
-        const text = ` ${trimInline(row, width - 4)} `;
-        return '|' + text.padEnd(width - 2, ' ') + '|';
+        const visible = strip(row);
+        const clipped = visible.length > inner - 2 ? trimInline(row, inner - 2) : row;
+        const pad = Math.max(0, inner - strip(clipped).length - 1);
+        return `│ ${clipped}${' '.repeat(pad)}│`;
     });
-    return [line, titleLine, line, ...body, line].join('\n');
+    return [paint(theme, ANSI_CODES.gray, top), ...body, paint(theme, ANSI_CODES.gray, `└${'─'.repeat(inner)}┘`)].join('\n');
 }
 function shellQuote(value) {
     return `'${String(value).replace(/'/g, `'\\''`)}'`;

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

@@ -186,6 +186,7 @@ function normalizeTelemetryEvent(event) {
         ...(event.task_id ? { task_id: String(event.task_id) } : {}),
         ...(event.task_title ? { task_title: String(event.task_title) } : {}),
         current_file: event.current_file == null ? null : String(event.current_file),
+        ...(event.spawned_at ? { spawned_at: String(event.spawned_at) } : {}),
         ...(event.progress ? (() => {
             const progress = normalizeProgress(event.progress);
             return progress ? { progress } : {};
@@ -220,6 +221,7 @@ function mergeSlotTelemetry(previous, event) {
         latest_event_type: stale ? previous.latest_event_type : event.event_type,
         latest_ts: stale ? previous.latest_ts : event.ts,
         started_at: previous?.started_at || event.ts,
+        spawned_at: event.spawned_at || previous?.spawned_at || event.ts,
         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 || [])]),

package/dist/core/zellij/zellij-theme.js

@@ -0,0 +1,67 @@
+const ANSI = {
+    reset: '\x1b[0m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+    gray: '\x1b[90m'
+};
+export function resolveZellijTheme() {
+    const noColor = process.env.NO_COLOR === '1' || process.env.SKS_ZELLIJ_COLOR === '0';
+    return {
+        color: !noColor && process.stdout.isTTY !== false,
+        width: Math.min(Math.max(Number(process.stdout.columns) || 100, 60), 140),
+        statusIcon: {
+            running: '●',
+            verifying: '◍',
+            queued: '◌',
+            launching: '◌',
+            done: '✔',
+            completed: '✔',
+            failed: '✖',
+            blocked: '■',
+            timed_out: '⏱',
+            headless: '·',
+            drained: '✔'
+        },
+        statusColor: {
+            running: ANSI.green,
+            verifying: ANSI.cyan,
+            queued: ANSI.gray,
+            launching: ANSI.gray,
+            done: ANSI.green,
+            completed: ANSI.green,
+            failed: ANSI.red,
+            blocked: ANSI.yellow,
+            timed_out: ANSI.red,
+            headless: ANSI.gray,
+            drained: ANSI.green
+        }
+    };
+}
+export function paint(theme, code, text) {
+    return theme.color && code ? `${code}${text}${ANSI.reset}` : text;
+}
+export function statusBadge(theme, status) {
+    const s = String(status || 'queued').toLowerCase();
+    const icon = theme.statusIcon[s] || '●';
+    return paint(theme, theme.statusColor[s] || '', `${icon} ${s}`);
+}
+export function progressBar(theme, done, total, width = 10) {
+    if (!Number.isFinite(total) || total <= 0)
+        return '';
+    const filled = Math.max(0, Math.min(width, Math.round((done / total) * width)));
+    return `${paint(theme, ANSI.green, '▉'.repeat(filled))}${paint(theme, ANSI.gray, '▁'.repeat(width - filled))} ${done}/${total}`;
+}
+export function elapsed(sinceIso) {
+    const t = Date.parse(String(sinceIso || ''));
+    if (!Number.isFinite(t))
+        return '';
+    const s = Math.max(0, Math.floor((Date.now() - t) / 1000));
+    return `${String(Math.floor(s / 60)).padStart(2, '0')}:${String(s % 60).padStart(2, '0')}`;
+}
+export const ANSI_CODES = ANSI;
+//# sourceMappingURL=zellij-theme.js.map

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

@@ -1,3 +1,14 @@
+export function resolveZellijUiConfig(args = [], env = process.env) {
+    return {
+        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),
+        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)
+    };
+}
 export function resolveZellijUiMode(args = [], env = process.env) {
     return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
 }
@@ -30,4 +41,9 @@ function resolveExplicitZellijUiMode(args = [], env = process.env) {
 export function zellijUiModeCreatesDashboard(mode) {
     return mode === 'dashboard-plus-slots';
 }
+function boundedInt(value, fallback, min, max) {
+    const parsed = Math.floor(Number(value ?? fallback));
+    const n = Number.isFinite(parsed) ? parsed : fallback;
+    return Math.max(min, Math.min(n, max));
+}
 //# sourceMappingURL=zellij-ui-mode.js.map