sneakoscope 7.0.2 → 7.0.3

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

@@ -31,11 +31,6 @@ export async function launchZellijLayout(opts = {}) {
     const layout = await writeZellijLayout(root, layoutInput);
     const capability = reusableZellijCapability(opts.zellijCapability, opts.requireZellij === true)
         || await checkZellijCapability({ root, require: opts.requireZellij === true });
-    // Configure the clipboard pipeline so selections inside the session reach the OS
-    // clipboard (Zellij's default OSC-52 copy is dropped by Terminal.app etc.). The
-    // copy option flags are appended AFTER `--default-layout <path>` so the launch
-    // command prefix ['zellij','attach','--create-background',session,'options','--default-layout',...]
-    // is preserved (required by the zellij launch-command-truth gate + E2E assertions).
     const clipboard = await writeZellijClipboardConfig(root, missionId);
     const createCommand = ['attach', '--create-background', sessionName, 'options', '--default-layout', layout.layout_path, ...clipboard.optionFlags];
     const attachCommand = ['attach', sessionName];
@@ -53,11 +48,6 @@ export async function launchZellijLayout(opts = {}) {
             ...(opts.recoveryAllowUnverified === true ? { allowUnverified: true } : {})
         })
         : codexLbToolOutputRecoveryNotChecked(false);
-    // Reset a stale same-named session before recreating it so the launch starts
-    // main-only. `attach --create-background` is idempotent and otherwise reuses an
-    // existing session, causing each run to pile another right-split SLOTS column
-    // onto leftover panes from prior missions. Skipped on dry-run, when zellij is
-    // unavailable, or when the user opts out with SKS_ZELLIJ_KEEP_SESSION=1.
     const resetSession = opts.freshSession === true
         && willCreateSession
         && codexLaunchRecovery.ok
@@ -199,17 +189,6 @@ export async function launchMadZellijUi(args = [], opts = {}) {
         launchOpts.session = resolvedSession;
     return launchZellijLayout(launchOpts);
 }
-/**
- * Attach the current terminal to an existing Zellij session in the foreground.
- *
- * `launchZellijLayout` only ever *creates* a detached background session, which
- * is correct for proof/automation but means an interactive launch (e.g.
- * `sks --mad`) never actually opens anything. This helper performs the
- * follow-up foreground attach, inheriting stdio so the session takes over the
- * user's terminal until they detach. It is a no-op-style failure (never throws)
- * when Zellij is missing or attach fails, so callers can fall back to printing a
- * manual attach hint.
- */
 export function attachZellijSessionInteractive(sessionName, opts = {}) {
     if (!sessionName)
         return { ok: false, status: null, signal: null, error: 'missing_session_name' };
@@ -217,11 +196,6 @@ export function attachZellijSessionInteractive(sessionName, opts = {}) {
     const env = { ...process.env };
     if (meta.zellij_socket_dir && !env.ZELLIJ_SOCKET_DIR)
         env.ZELLIJ_SOCKET_DIR = meta.zellij_socket_dir;
-    // Steer the foreground attach at our generated clipboard config so the interactive
-    // session honors copy_command=pbcopy + copy_on_select. The `options` subcommand only
-    // configures the *created* background session, so the attach needs its own config
-    // delivery; ZELLIJ_CONFIG_FILE avoids reordering CLI args. Defer to a user-exported
-    // ZELLIJ_CONFIG_FILE if they already set one.
     if (opts.configPath && !env.ZELLIJ_CONFIG_FILE)
         env.ZELLIJ_CONFIG_FILE = opts.configPath;
     try {

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

@@ -7,8 +7,6 @@ const DEFAULT_TAIL_BYTES = 256 * 1024;
 const DEFAULT_REFRESH_MIN_MS = 2_000;
 const DEFAULT_HEARTBEAT_MS = 5_000;
 const MAX_DISCOVERY_DAY_DIRS = 45;
-// The current release baseline is 0.144.5, but this rollout format has been
-// stable since 0.144.1 and remains readable for compatible older sessions.
 const MIN_SUPPORTED_CODEX_ROLLOUT_VERSION = '0.144.1';
 const rolloutPathCache = new Map();
 export async function readOfficialSubagentRolloutActivity(input) {
@@ -35,9 +33,6 @@ export async function readOfficialSubagentRolloutActivity(input) {
     const activityCutoffMs = Math.max(Number.isFinite(birthMs) ? birthMs : 0, Number.isFinite(startMs) ? startMs : 0);
     const rows = tail.rows.filter((row) => {
         const ts = Date.parse(String(row?.timestamp || ''));
-        // Forked subagent rollouts contain a rewritten copy of the parent history.
-        // Those copied rows share the child session_meta timestamp. Ignore that
-        // fork snapshot and surface only events emitted by the child afterwards.
         return Number.isFinite(ts) && ts > activityCutoffMs;
     });
     if (!rows.length)

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

@@ -93,11 +93,6 @@ export async function recordOfficialSubagentParentOutcomesTelemetry(input) {
         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) {

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

@@ -4,15 +4,8 @@ import { checkZellijCapability } from './zellij-capability.js';
 import { runZellij } from './zellij-command.js';
 import { ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS } from './zellij-lane-renderer.js';
 export const ZELLIJ_SCREEN_PROOF_SCHEMA = 'sks.zellij-screen-proof.v1';
-// Canonical scrapeable subset (a strict subset of ZELLIJ_LANE_SECTIONS).
 const REQUIRED_LANE_TEXT = ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS;
 export const ZELLIJ_HEARTBEAT_TIMEOUT_BLOCKER = 'zellij_lane_heartbeat_timeout';
-/**
- * Poll for the lane renderer heartbeat file and return a decisive result. A
- * timeout is turned into the `zellij_lane_heartbeat_timeout` blocker so callers
- * (real-session launch gate) can fail directly instead of waiting silently.
- * Pure enough to be exercised hermetically without a real Zellij session.
- */
 export async function waitForLaneHeartbeat(file, opts = {}) {
     const timeoutMs = Math.max(0, Number(opts.timeoutMs ?? 5000));
     const intervalMs = Math.max(25, Number(opts.intervalMs ?? 250));

package/dist/core/zellij/zellij-slot-column-anchor.js

@@ -83,7 +83,6 @@ function renderTelemetryAnchor(snapshot, updateNotice = null, sqlPlaneCapability
     const update = updateNotice?.update_available && updateNotice?.latest_version ? ` · update ${trimInline(String(updateNotice.latest_version), 18)} available` : '';
     const sqlPlane = isMadSksSqlPlaneActive(sqlPlaneCapability) ? ' · MAD-SKS SQL-PLANE ACTIVE' : '';
     const qaHandoff = ['pending', 'blocked_for_desktop_review'].includes(String(appHandoff?.status || '')) ? ' · QA /app handoff pending' : '';
-    // Compact SKS branding header: package version + mission id so the SLOTS column self-identifies.
     const brand = `SKS v${readPackageVersion()} · mission ${trimInline(String(snapshot.mission_id || '-'), 28)}`;
     if (staleSeconds != null && staleSeconds > 60) {
         return [brand, `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${sqlPlane}${qaHandoff}`].join('\n');

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

@@ -288,10 +288,6 @@ export async function renderZellijSlotPaneStatusFromArtifacts(input) {
         telemetry_age_ms: status.telemetry_age_ms
     };
 }
-// Root-cause-3 fix: the watch loop never exited, so completed/failed panes lingered forever and
-// kept re-reporting staleness. Resolve whether this slot has reached a terminal state (status is
-// completed/failed/drained in telemetry) AND its worker-result.json exists, so the pane command
-// can render one final frame and exit instead of looping indefinitely.
 export async function resolveZellijSlotPaneExit(input) {
     const resultExists = Boolean(await readJson(path.join(path.resolve(input.artifactDir), 'worker-result.json')));
     if (!resultExists)
@@ -343,9 +339,6 @@ 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;
     return {
-        // Root-cause-3 fix: with a 1000ms+jitter flush throttle the old 3000ms threshold flapped
-        // constantly. Raise to 15000ms so brief gaps between flushes don't read as "stale", and only
-        // claim the worker may be gone after 60000ms of true silence.
         telemetry_stale: telemetryAgeMs > 15000,
         telemetry_age_ms: telemetryAgeMs
     };
@@ -456,8 +449,6 @@ function formatArtifactEvent(row) {
     if (!row)
         return '';
     const status = trimInline(row.lane_status || row.status || row.event || row.event_type || row.type || row.sdk_event_type || 'event', 18);
-    // Prefer the latest LLM message text (message_tail/message) so the live pane shows what the
-    // model is actually saying, falling back to tool/file/blocker context when no message exists.
     const detail = firstText([
         row.message_tail,
         row.message,

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

@@ -50,10 +50,6 @@ export async function readZellijSlotTelemetrySnapshotNoRebuild(root, missionId)
     const stat = await statTelemetryFile(snapshotPath);
     const recorded = telemetrySnapshotDiskStat.get(snapshotPath);
     const diskChanged = Boolean(stat) && (!recorded || recorded.mtimeMs !== stat.mtimeMs || recorded.size !== stat.size);
-    // CRITICAL: never serve a process-local cache forever. Long-lived reader
-    // processes (zellij slot pane renderers in --watch mode) must observe
-    // snapshot flushes performed by the orchestrator and worker processes,
-    // otherwise the pane renders the same frame for the entire mission.
     if (!diskChanged && cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
         return cached;
     const existing = await readJson(snapshotPath, null);
@@ -63,11 +59,6 @@ export async function readZellijSlotTelemetrySnapshotNoRebuild(root, missionId)
         return cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? cached : null;
     }
     const disk = existing;
-    // Merge with any locally cached (possibly not-yet-flushed) slot state so a
-    // writer process does not lose its pending events when another process
-    // flushed the snapshot file in the meantime. The DISK updated_at stays
-    // authoritative on the read path: it reflects the last real flush, which is
-    // what stale-telemetry detection must measure.
     const merged = cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? mergeTelemetrySnapshots(disk, cached, { updatedAt: 'base' }) : disk;
     telemetrySnapshotCache.set(snapshotPath, merged);
     return merged;
@@ -334,9 +325,6 @@ async function writeTelemetrySnapshotFast(file, snapshot) {
         const flushCount = Number(telemetrySnapshotFlushCounts.get(file) || 0) + 1;
         telemetrySnapshotFlushCounts.set(file, flushCount);
         telemetrySnapshotLastFlushMs.set(file, Date.now());
-        // Multiple processes (orchestrator + worker children) flush this file.
-        // Serialize the read/merge/write critical section so a slower writer
-        // cannot overwrite a newer slot observed by a different process.
         const disk = await readJson(file, null);
         const merged = disk?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? mergeTelemetrySnapshots(disk, snapshot) : snapshot;
         const next = { ...merged, flush_count: Math.max(flushCount, Number(merged.flush_count || 0)) };

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

@@ -13,13 +13,6 @@ export function resolveZellijUiMode(args = [], env = process.env) {
     return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
 }
 export function resolveZellijWorkerPaneUiMode(args = [], env = process.env) {
-    // Default worker panes to the live slot renderer (compact-slots). In
-    // 'full-debug' the pane runs the worker process itself, but the worker is
-    // invoked with --json and the codex SDK streams events to JSONL files — so
-    // the pane stays blank until the worker exits. The slot renderer re-reads
-    // heartbeat/event/stdout artifacts every second and actually shows what each
-    // parallel worker is doing in real time. 'full-debug' remains available via
-    // --zellij-full-debug or SKS_ZELLIJ_UI_MODE=full-debug.
     return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
 }
 function resolveExplicitZellijUiMode(args = [], env = process.env) {

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

@@ -28,13 +28,6 @@ export function zellijUpgradeCommandHint(missing = false) {
         return 'cargo install --locked zellij   # or your distro package manager';
     return 'See https://zellij.dev/documentation/installation';
 }
-/**
- * Resolve the latest STABLE zellij version. GitHub's /releases/latest endpoint
- * already excludes prereleases and drafts. Results are cached on disk
- * (default TTL 6h, override with SKS_ZELLIJ_UPDATE_TTL_MS) so command launches
- * stay fast and offline-safe. SKS_ZELLIJ_LATEST_VERSION pins the value for
- * tests and air-gapped environments.
- */
 export async function fetchLatestZellijVersion(input = {}) {
     const env = input.env || process.env;
     const pinned = stripVersionPrefix(String(env.SKS_ZELLIJ_LATEST_VERSION || '').trim());
@@ -48,8 +41,6 @@ export async function fetchLatestZellijVersion(input = {}) {
     }
     try {
         const tag = await githubLatestTag(input.timeoutMs || normalizePositiveInt(env.SKS_ZELLIJ_UPDATE_TIMEOUT_MS, 2500));
-        // GitHub release tags carry a leading "v" (v0.44.3); \b-based version
-        // parsing cannot start inside "v0", so strip the prefix first.
         const version = parseZellijVersionText(stripVersionPrefix(tag));
         if (!version)
             throw new Error(`zellij_latest_tag_unparsed:${tag}`);
@@ -111,11 +102,6 @@ export async function checkZellijUpdateNotice(input = {}) {
     }
     return persistNotice(input.missionDir, notice);
 }
-/**
- * Upgrade zellij to the latest stable release. Only Homebrew automation is
- * attempted (macOS / Linuxbrew); everything else returns manual_required with
- * the exact operator command, mirroring how the Codex CLI update flow behaves.
- */
 export async function upgradeZellijToLatest(input = {}) {
     const before = await checkZellijCapability({ require: false, writeReport: false, env: input.env || process.env }).catch(() => null);
     const beforeVersion = before?.version || null;
@@ -133,11 +119,6 @@ export async function upgradeZellijToLatest(input = {}) {
         };
     }
     const upgradeArgs = missing ? ['install', 'zellij'] : ['upgrade', 'zellij'];
-    // Package installs go through the mutation guard with an explicit
-    // zellij_install scope contract (same path ensureZellijCliTool uses), so the
-    // mutation ledger records the install and safety gates can audit it. The
-    // upgrade only runs after the operator confirmed the [Y/n] prompt or passed
-    // --yes / `sks zellij update --yes`.
     const guardRoot = globalSksRoot();
     const guardCommand = `brew ${upgradeArgs.join(' ')}`;
     const contract = createRequestedScopeContract({
@@ -155,8 +136,6 @@ export async function upgradeZellijToLatest(input = {}) {
         maxOutputBytes: 256 * 1024
     }).catch((err) => ({ code: 1, stdout: '', stderr: String(err?.message || err) }));
     if (run.code !== 0 && !missing && /No such keg|No available formula|not installed/i.test(`${run.stderr}\n${run.stdout}`)) {
-        // zellij exists on PATH but was not installed through Homebrew (e.g. cargo
-        // or a manual binary). Installing the brew formula gives a managed copy.
         run = await guardedPackageInstall(guardCtx, 'zellij', {
             confirmed: true,
             command: 'brew',
@@ -195,14 +174,6 @@ export async function upgradeZellijToLatest(input = {}) {
         error: null
     };
 }
-/**
- * Launch-time prompt, mirroring maybePromptCodexUpdateForLaunch: check the
- * installed zellij version against the latest stable release and offer an
- * upgrade before opening the live session. Never blocks the launch.
- *
- * Skips: --json, --skip-cli-tools, --skip-zellij-update, SKS_SKIP_ZELLIJ_UPDATE=1.
- * Auto-approves: --yes / -y.
- */
 export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     const env = opts.env || process.env;
     const list = (args || []).map((arg) => String(arg));

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

@@ -15,11 +15,6 @@ export function buildWorkerPaneName(slotId, generationIndex) {
     return `${slotId}/gen-${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
 }
 export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier, backend, status, worktree, taskTitle) {
-    // When a task label is available, the pane title is JUST the label + status:
-    // users identify panes by what they are doing, not by slot ids. Slot/gen,
-    // backend, provider, and worktree details stay inside the pane body and the
-    // SLOTS anchor rows. The verbose format remains the fallback for callers
-    // that have no task context.
     const task = shortWorkerTaskLabel(taskTitle);
     if (task)
         return `${task} · ${workerBackendTag(backend, context?.provider)} · ${status || 'launching'}`;
@@ -28,9 +23,6 @@ export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTi
     const wt = worktree ? ` · WT:${worktree.id} · branch:${worktree.branch}` : '';
     return `${base}${wt} · ${backend || 'codex-sdk'} · ${providerPaneLabel(normalized)} · ${status || 'launching'}`;
 }
-// Local-LLM workers must be visually distinguishable from GPT/codex workers:
-// only trivial long-running edits belong on local models, while web research
-// and code review must run on GPT. The tag makes a misrouted task obvious.
 export function workerBackendTag(backend, provider) {
     const text = `${String(backend || '')} ${String(provider || '')}`.toLowerCase();
     if (/ollama|local/.test(text))
@@ -39,8 +31,6 @@ export function workerBackendTag(backend, provider) {
         return 'fixture';
     return 'GPT';
 }
-// Lead the pane title with a 1-3 word task label so users can tell WHAT each
-// slot is doing at a glance instead of an anonymous "slot-002/gen-1".
 export function shortWorkerTaskLabel(value, maxChars = 24) {
     const text = String(value || '').replace(/\s+/g, ' ').trim();
     if (!text)
@@ -233,15 +223,7 @@ export async function openWorkerPane(input) {
         return record;
     }
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null, input.taskTitle || null);
-    // CRITICAL: serialize anchor + worker pane creation per session. Workers
-    // launch concurrently, and without this lock every worker raced past the
-    // "does the SLOTS anchor exist yet?" check and created its OWN anchor with
-    // --direction right — splitting the screen into N side-by-side columns
-    // (observed in agent-zellij-pane-launch-ledger: terminal_1..terminal_5 all
-    // recorded as separate slot_column_anchor_pane_id values in one mission).
     return withZellijPaneCreationLock(input, async () => {
-        // Re-read the right-column state now that we hold the lock: a previously
-        // serialized worker may have created the anchor and/or its own pane.
         const freshState = rightColumn
             ? await readRightColumnState(root, input.missionId, input.projectRoot).catch(() => null)
             : null;
@@ -259,18 +241,10 @@ export async function openWorkerPane(input) {
         let columnCreationDirectionRequested = null;
         let columnCreationDirectionApplied = null;
         if (rightColumn && !freshFocusCandidate) {
-            // Single right-column invariant: if this zellij session was reused (stable
-            // per-cwd name) and already carries a SLOTS anchor from a prior mission, adopt
-            // it and stack workers underneath instead of splitting ANOTHER `--direction
-            // right` column — repeated right-splits are exactly what fragments the screen
-            // into side-by-side columns. A fresh column is only split when none exists yet.
             const adoptedAnchorPaneId = createSession.ok
                 ? await findExistingSlotsAnchorPaneId(input.sessionName, cwd).catch(() => null)
                 : null;
             if (adoptedAnchorPaneId) {
-                // Adopted an existing column: no creation was requested, so leave the
-                // column-creation direction fields null (avoids a false
-                // `zellij_worker_slot_column_anchor_not_created` blocker).
                 slotColumnAnchorPaneId = adoptedAnchorPaneId;
                 await recordSlotColumnAnchorInRightColumn({
                     root,
@@ -314,11 +288,6 @@ export async function openWorkerPane(input) {
         const focus = focusPaneId
             ? await focusZellijPaneById(input.sessionName, focusPaneId, cwd)
             : null;
-        // Vertical stack policy: the first worker splits DOWN from the SLOTS anchor;
-        // every following worker joins a zellij stacked-pane group with the previous
-        // worker (`new-pane --stacked`, zellij >= 0.43) so the right column stays a
-        // clean vertical stack instead of fragmenting the screen. Opt out with
-        // SKS_ZELLIJ_WORKER_STACKED=0.
         const stackIntent = process.env.SKS_ZELLIJ_WORKER_STACKED !== '0'
             && Boolean(lastVisibleWorkerPaneId)
             && focus?.ok === true;
@@ -651,9 +620,6 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
         blockers: paneId == null ? ['zellij_worker_pane_id_not_reconciled'] : []
     };
 }
-// Look up an already-open SLOTS anchor pane in a (possibly reused) session so a
-// new mission can stack its workers under the existing right column instead of
-// splitting another one. Returns the live pane id (terminal_<n>) or null.
 async function findExistingSlotsAnchorPaneId(sessionName, cwd) {
     const listed = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], {
         cwd,
@@ -775,11 +741,6 @@ async function focusZellijPaneById(sessionName, paneId, cwd) {
         last = focus;
         if (focus.ok)
             return focus;
-        // zellij exits non-zero with "Pane Terminal(N) is already focused" when the
-        // target pane already holds focus (common: new-pane auto-focuses the pane
-        // it created, so the previous worker pane is usually still focused). That
-        // is a success for our purposes — without this, stacked placement would
-        // silently fall back to a plain down-split on every consecutive worker.
         if (/already focused/i.test(`${focus.stdout_tail || ''} ${focus.stderr_tail || ''}`)) {
             return { ...focus, ok: true, blockers: [], warnings: [...focus.warnings, 'zellij_pane_already_focused'] };
         }