sneakoscope 7.0.2 → 7.0.3

package/dist/commands/codex-lb.js

@@ -10,6 +10,7 @@ import { buildCodexLbSetupPlan, codexLbPersistenceSummary, renderCodexLbSetupPla
 import { CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_FLAG, codexLbToolOutputRecoveryOverrideAcknowledged } from '../core/codex-lb/codex-lb-tool-output-recovery.js';
 import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
 import { repairCodexAppFastUi } from '../core/codex-app/codex-app-fast-ui-repair.js';
+import { loadCodexLbEnv } from '../core/codex-lb/codex-lb-env.js';
 export async function run(command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'status';
@@ -48,28 +49,52 @@ export async function run(command, args = []) {
     if (action === 'health' || action === 'verify-chain' || action === 'chain') {
         const allowUnverifiedToolOutputRecovery = codexLbToolOutputRecoveryOverrideAcknowledged({ args });
         const status = await codexLbStatus({ probeToolOutputRecovery: true, allowUnverifiedToolOutputRecovery });
-        const blocker = !status.env_key_configured ? 'missing_env_key' : !status.base_url ? 'missing_base_url' : 'not_configured';
-        const result = status.selected && status.tool_output_recovery?.ok !== true
+        const modelSelection = await resolveCodexLbHealthModel(status);
+        const loadedEnv = await loadCodexLbEnv({ home: path.dirname(path.dirname(status.env_path)), envPath: status.env_path });
+        const bindingBlocker = loadedEnv.credential_binding.blockers[0] || null;
+        const providerUrlMismatch = status.provider_configured === true && status.provider_base_url_matches_credential !== true;
+        const blocker = bindingBlocker
+            || (providerUrlMismatch ? 'provider_base_url_mismatch' : null)
+            || (!status.env_key_configured
+                ? 'missing_env_key'
+                : !status.base_url
+                    ? 'missing_base_url'
+                    : !modelSelection.model
+                        ? 'model_unselected'
+                        : 'not_configured');
+        const chain = status.selected && status.tool_output_recovery?.ok !== true
             ? { ok: false, status: 'tool_output_recovery_blocked', codex_lb: status, tool_output_recovery: status.tool_output_recovery }
-            : status.ok
-                ? await checkCodexLbResponseChain(status, { force: true, root, fastMode: flag(args, '--fast') || flag(args, '--priority') })
+            : !bindingBlocker && !providerUrlMismatch && status.env_key_configured && loadedEnv.base_url && loadedEnv.secret_api_key && modelSelection.model
+                ? await checkCodexLbResponseChain(status, {
+                    force: true,
+                    root,
+                    fastMode: flag(args, '--fast') || flag(args, '--priority'),
+                    model: modelSelection.model,
+                    baseUrl: loadedEnv.base_url,
+                    apiKey: loadedEnv.secret_api_key
+                })
                 : { ok: false, status: blocker, codex_lb: status };
+        const result = { ...chain, codex_lb: status, model_selection: modelSelection };
+        if (!result.ok)
+            process.exitCode = 1;
         if (flag(args, '--json'))
             return printJson(result);
         console.log(`codex-lb response chain: ${result.ok ? 'ok' : `failed (${result.status})`}`);
-        if (!result.ok)
-            process.exitCode = 1;
         return;
     }
     if (action === 'fast-check' || action === 'fast' || action === 'verify-fast') {
         const allowUnverifiedToolOutputRecovery = codexLbToolOutputRecoveryOverrideAcknowledged({ args });
         const status = await codexLbStatus({ probeToolOutputRecovery: true, allowUnverifiedToolOutputRecovery });
-        const blocker = !status.env_key_configured ? 'missing_env_key' : !status.base_url ? 'missing_base_url' : !status.provider_contract_ok ? 'provider_contract_drift' : 'not_configured';
+        const loadedEnv = await loadCodexLbEnv({ home: path.dirname(path.dirname(status.env_path)), envPath: status.env_path });
+        const bindingBlocker = loadedEnv.credential_binding.blockers[0] || null;
+        const providerUrlMismatch = status.provider_configured === true && status.provider_base_url_matches_credential !== true;
+        const blocker = bindingBlocker || (providerUrlMismatch ? 'provider_base_url_mismatch' : null)
+            || (!status.env_key_configured ? 'missing_env_key' : !status.base_url ? 'missing_base_url' : !status.provider_contract_ok ? 'provider_contract_drift' : 'not_configured');
         const modelSelection = await resolveCodexLbFastCheckModel(status);
         const chain = status.selected && status.tool_output_recovery?.ok !== true
             ? { ok: false, status: 'tool_output_recovery_blocked', codex_lb: status, tool_output_recovery: status.tool_output_recovery }
-            : status.env_key_configured && status.base_url && modelSelection.model
-                ? await checkCodexLbResponseChain(status, { force: true, cache: false, root, fastMode: true, model: modelSelection.model })
+            : !bindingBlocker && !providerUrlMismatch && status.env_key_configured && loadedEnv.base_url && loadedEnv.secret_api_key && modelSelection.model
+                ? await checkCodexLbResponseChain(status, { force: true, cache: false, root, fastMode: true, model: modelSelection.model, baseUrl: loadedEnv.base_url, apiKey: loadedEnv.secret_api_key })
                 : { ok: false, status: modelSelection.model ? blocker : 'model_unselected', codex_lb: status };
         const evidence = await fastEvidenceFromChain(chain, readOption(args, '--request-log', readOption(args, '--request-log-json', null)));
         const providerReady = status.provider_contract_ok === true;
@@ -199,21 +224,41 @@ export async function run(command, args = []) {
         return;
     }
     if (action === 'use-codex-lb' || action === 'use-lb') {
-        const result = await repairCodexLbAuth({
+        const restartRequired = flag(args, '--restart-app') || flag(args, '--restart');
+        const repairOptions = {
             forceCodexLbApiKeyAuth: true,
             authMode: 'codex-lb',
             forceFastMode: !flag(args, '--no-fast'),
             allowUnverifiedToolOutputRecovery: codexLbToolOutputRecoveryOverrideAcknowledged({ args })
-        });
+        };
+        const result = await repairCodexLbAuth(repairOptions);
         const fastUi = await repairCodexAppFastUiAfterMutation(root, Boolean(result.ok));
         const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok && fastUi.ok));
-        const ok = Boolean(result.ok && fastUi.ok && restart?.ok !== false);
-        const shaped = { ...result, ok, mode: 'codex-lb', codex_app_fast_ui: fastUi, restart_app: restart };
+        const postRestart = await reconcileCodexLbAfterRestart(restart, repairOptions, Boolean(result.ok && fastUi.ok), restartRequired);
+        const finalStatus = postRestart.attempted ? postRestart.stable_status : result.codex_lb;
+        const readiness = codexLbActivationReadiness(finalStatus);
+        const restartRequirement = codexLbRestartPostcondition(restart, restartRequired);
+        const restartPerformed = restartRequirement.performed;
+        const restartSatisfied = restartRequirement.satisfied;
+        const ok = Boolean(result.ok && fastUi.ok && restart?.ok !== false && restartSatisfied && postRestart.ok && readiness.ok);
+        const shaped = {
+            ...result,
+            ok,
+            mode: 'codex-lb',
+            codex_lb: finalStatus,
+            readiness,
+            restart_required: restartRequired,
+            restart_performed: restartPerformed,
+            codex_app_fast_ui: fastUi,
+            restart_app: restart,
+            post_restart: postRestart
+        };
         if (!ok)
             process.exitCode = 1;
         if (flag(args, '--json'))
             return printJson(shaped);
-        console.log(result.ok ? 'Auth mode: codex-lb selected (API key).' : `Switch to codex-lb failed: ${result.status}${result.error ? `: ${result.error}` : ''}`);
+        const failureStatus = !restartSatisfied ? 'restart_not_performed' : postRestart.status || result.status;
+        console.log(ok ? 'Auth mode: codex-lb selected (API key).' : `Switch to codex-lb failed: ${failureStatus}${result.error ? `: ${result.error}` : ''}`);
         if (restart?.status === 'restarted')
             console.log('Codex App restarted for codex-lb auth.');
         if (!ok)
@@ -221,12 +266,22 @@ export async function run(command, args = []) {
         return;
     }
     if (action === 'use-oauth' || action === 'use-chatgpt') {
+        const restartRequired = flag(args, '--restart-app') || flag(args, '--restart');
         const result = await releaseCodexLbAuthHold({ force: flag(args, '--force') });
         const authOk = !['no_backup', 'auth_in_use', 'failed'].includes(result.status);
         const fastUi = await repairCodexAppFastUiAfterMutation(root, authOk);
         const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(authOk && fastUi.ok));
-        const ok = Boolean(authOk && fastUi.ok && restart?.ok !== false);
-        const shaped = { ...result, ok, mode: 'oauth', codex_app_fast_ui: fastUi, restart_app: restart };
+        const restartRequirement = codexLbRestartPostcondition(restart, restartRequired);
+        const ok = Boolean(authOk && fastUi.ok && restart?.ok !== false && restartRequirement.satisfied);
+        const shaped = {
+            ...result,
+            ok,
+            mode: 'oauth',
+            restart_required: restartRequired,
+            restart_performed: restartRequirement.performed,
+            codex_app_fast_ui: fastUi,
+            restart_app: restart
+        };
         if (!ok)
             process.exitCode = 1;
         if (flag(args, '--json'))
@@ -238,7 +293,9 @@ export async function run(command, args = []) {
             process.exitCode = 1;
             return;
         }
-        console.log(`Auth mode: ${['released', 'oauth_restored'].includes(result.status) ? 'ChatGPT OAuth restored' : result.status}.`);
+        console.log(ok
+            ? `Auth mode: ${['released', 'oauth_restored'].includes(result.status) ? 'ChatGPT OAuth restored' : result.status}.`
+            : `Switch to ChatGPT OAuth failed: ${restartRequirement.satisfied ? result.status : 'restart_not_performed'}.`);
         if (restart?.status === 'restarted')
             console.log('Codex App restarted for ChatGPT OAuth.');
         if (['auth_in_use', 'failed'].includes(result.status))
@@ -421,6 +478,95 @@ async function maybeRestartCodexAppForAuthSwitch(args = [], enabled) {
     const shouldRestart = requested || (!flag(args, '--json') && !flag(args, '--no-restart-app') && !flag(args, '--no-restart'));
     return restartCodexApp({ enabled: shouldRestart });
 }
+export function codexLbRestartPostcondition(restart = {}, required = false) {
+    const performed = restart?.status === 'restarted';
+    return {
+        required: Boolean(required),
+        performed,
+        satisfied: !required || performed
+    };
+}
+async function reconcileCodexLbAfterRestart(restart, repairOptions, enabled, restartRequired = false) {
+    if (!enabled || restart?.status !== 'restarted') {
+        const restartRequirement = codexLbRestartPostcondition(restart, restartRequired);
+        return {
+            schema: 'sks.codex-lb-post-restart.v1',
+            ok: Boolean(enabled && restart?.ok !== false && restartRequirement.satisfied),
+            attempted: false,
+            status: restartRequired && !restartRequirement.performed ? 'restart_not_performed' : 'skipped',
+            reason: !enabled ? 'previous_step_failed' : restart?.reason || restart?.status || 'restart_not_performed',
+            attempts: 0,
+            observations: [],
+            selected: null,
+            provider_ready: null,
+            auth_routing_coherent: null,
+            shared_openai_routing_safe: null,
+            reconcile: null,
+            codex_lb: null,
+            repair: null,
+            stable_status: null,
+            readiness: null
+        };
+    }
+    await codexLbRestartSettle(750);
+    const repair = await repairCodexLbAuth(repairOptions);
+    const observations = [];
+    let stableStatus = null;
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        if (attempt > 1)
+            await codexLbRestartSettle(750);
+        stableStatus = await codexLbStatus({
+            probeToolOutputRecovery: false
+        });
+        observations.push({ attempt, readiness: codexLbActivationReadiness(stableStatus) });
+    }
+    const readiness = codexLbActivationReadiness(stableStatus);
+    const finalTwoReady = observations.slice(-2).every((observation) => observation.readiness.ok === true);
+    const regressed = observations.some((observation, index) => index > 0
+        && observations[index - 1].readiness.ok === true
+        && observation.readiness.ok !== true);
+    const stable = finalTwoReady && !regressed;
+    return {
+        schema: 'sks.codex-lb-post-restart.v1',
+        ok: Boolean(repair.ok && readiness.ok && stable),
+        attempted: true,
+        status: repair.ok && readiness.ok && stable ? 'reconciled_stable' : 'reconcile_failed',
+        attempts: observations.length,
+        stable,
+        observations,
+        selected: readiness.selected,
+        provider_ready: readiness.provider_ready,
+        auth_routing_coherent: readiness.auth_routing_coherent,
+        shared_openai_routing_safe: readiness.shared_openai_routing_safe,
+        reconcile: repair,
+        codex_lb: stableStatus,
+        repair,
+        stable_status: stableStatus,
+        readiness
+    };
+}
+function codexLbRestartSettle(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+function codexLbActivationReadiness(status = {}) {
+    const selected = status?.selected === true;
+    const providerReady = status?.provider_ready === true;
+    const authRoutingCoherent = status?.auth_routing_coherent === true;
+    const sharedOpenAiRoutingSafe = status?.shared_openai_routing?.safe === true;
+    return {
+        ok: selected && providerReady && authRoutingCoherent && sharedOpenAiRoutingSafe,
+        selected,
+        provider_ready: providerReady,
+        auth_routing_coherent: authRoutingCoherent,
+        shared_openai_routing_safe: sharedOpenAiRoutingSafe,
+        blockers: [
+            ...(selected ? [] : ['codex_lb_not_selected']),
+            ...(providerReady ? [] : ['codex_lb_provider_not_ready']),
+            ...(authRoutingCoherent ? [] : ['codex_lb_auth_routing_incoherent']),
+            ...(sharedOpenAiRoutingSafe ? [] : ['codex_lb_shared_openai_routing_unsafe'])
+        ]
+    };
+}
 async function repairCodexAppFastUiAfterMutation(root, enabled) {
     if (!enabled) {
         return {
@@ -451,6 +597,12 @@ export function isCodexLbFastChainVerified(chain = {}) {
     return chain.ok === true && chain.skipped !== true;
 }
 export async function resolveCodexLbFastCheckModel(status = {}, env = process.env) {
+    return resolveCodexLbModel(status, env, { requirePriority: true, blockerPrefix: 'codex_lb_fast_check' });
+}
+export async function resolveCodexLbHealthModel(status = {}, env = process.env) {
+    return resolveCodexLbModel(status, env, { requirePriority: false, blockerPrefix: 'codex_lb_health' });
+}
+async function resolveCodexLbModel(status = {}, env = process.env, opts = {}) {
     const explicit = String(env.SKS_CODEX_MODEL || env.CODEX_MODEL || '').trim();
     if (explicit)
         return { model: explicit, source: env.SKS_CODEX_MODEL ? 'SKS_CODEX_MODEL' : 'CODEX_MODEL', blockers: [] };
@@ -461,7 +613,7 @@ export async function resolveCodexLbFastCheckModel(status = {}, env = process.en
         return { model: configured, source: 'global_config', blockers: [] };
     const configuredCatalogPath = topLevelTomlString(config, 'model_catalog_json');
     if (!configuredCatalogPath)
-        return { model: null, source: null, blockers: ['codex_lb_fast_check_model_unselected'] };
+        return { model: null, source: null, blockers: [`${opts.blockerPrefix}_model_unselected`] };
     const home = String(env.HOME || '').trim();
     const expandedCatalogPath = configuredCatalogPath.startsWith('~/') && home
         ? path.join(home, configuredCatalogPath.slice(2))
@@ -471,13 +623,13 @@ export async function resolveCodexLbFastCheckModel(status = {}, env = process.en
         : path.resolve(path.dirname(configPath), expandedCatalogPath);
     try {
         const payload = JSON.parse(await readText(catalogPath, ''));
-        const model = selectPriorityCapableCatalogModel(payload);
+        const model = selectCatalogModel(payload, opts.requirePriority === true);
         return model
             ? { model, source: 'model_catalog_json', blockers: [] }
-            : { model: null, source: 'model_catalog_json', blockers: ['codex_lb_fast_check_priority_model_unavailable'] };
+            : { model: null, source: 'model_catalog_json', blockers: [`${opts.blockerPrefix}_${opts.requirePriority === true ? 'priority_' : ''}model_unavailable`] };
     }
     catch {
-        return { model: null, source: 'model_catalog_json', blockers: ['codex_lb_fast_check_catalog_invalid'] };
+        return { model: null, source: 'model_catalog_json', blockers: [`${opts.blockerPrefix}_catalog_invalid`] };
     }
 }
 function topLevelTomlString(text, key) {
@@ -485,12 +637,14 @@ function topLevelTomlString(text, key) {
     const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     return (topLevel.match(new RegExp(`(?:^|\\n)\\s*${escaped}\\s*=\\s*"([^"]+)"`))?.[1] || '').trim();
 }
-function selectPriorityCapableCatalogModel(payload = {}) {
+function selectCatalogModel(payload = {}, requirePriority = false) {
     const models = Array.isArray(payload?.models) ? payload.models : Array.isArray(payload?.data) ? payload.data : [];
     return models
         .filter((row) => {
         if (!row || typeof row !== 'object' || row.supported_in_api !== true || typeof row.slug !== 'string' || !row.slug.trim())
             return false;
+        if (!requirePriority)
+            return true;
         const serviceTiers = Array.isArray(row.service_tiers) ? row.service_tiers : [];
         const speedTiers = Array.isArray(row.additional_speed_tiers) ? row.additional_speed_tiers : [];
         return serviceTiers.some((tier) => normalizeTier(typeof tier === 'string' ? tier : tier?.id) === 'priority')

package/dist/commands/codex.js

@@ -6,7 +6,7 @@ import { codexSchemaSnapshotReport } from '../core/codex-compat/codex-schema-sna
 import { detectCodex0141Capability } from '../core/codex-control/codex-0141-capability.js';
 import { detectCodex0144Capability } from '../core/codex-control/codex-0144-capability.js';
 import { CURRENT_CODEX_RELEASE_MANIFEST } from '../core/codex-compat/codex-release-manifest.js';
-import { inspectCodexCliUpdate, updateCodexCliNow } from '../core/codex/codex-cli-update.js';
+import { codexCliUpdateConsoleLines, inspectCodexCliUpdate, updateCodexCliNow } from '../core/codex/codex-cli-update.js';
 export async function run(_command, args = []) {
     const action = args[0] || 'compatibility';
     if (action === 'compatibility' || action === 'compat') {
@@ -54,13 +54,8 @@ export async function run(_command, args = []) {
                 process.exitCode = 1;
             return;
         }
-        console.log(`Codex CLI update: ${result.status}${result.after_version ? ` (${result.before_version || 'unknown'} -> ${result.after_version})` : ''}`);
-        if (result.raw_output)
-            console.log(result.raw_output);
-        for (const blocker of result.blockers)
-            console.log(`- blocker: ${blocker}`);
-        for (const actionLine of result.guidance)
-            console.log(`- ${actionLine}`);
+        for (const line of codexCliUpdateConsoleLines(result))
+            console.log(line);
         if (!result.ok)
             process.exitCode = 1;
         return;

package/dist/commands/doctor.js

@@ -23,6 +23,7 @@ import { writeMcpPluginInventoryArtifacts } from '../core/mcp/mcp-plugin-invento
 import { buildCodexAppHarnessMatrix } from '../core/codex-app/codex-app-harness-matrix.js';
 import { buildCodexNativeFeatureMatrix } from '../core/codex-native/codex-native-feature-broker.js';
 import { withSecretPreservationGuard } from '../core/config/config-migration-journal.js';
+import { reconcileDoctorSkills } from '../core/doctor/doctor-skill-reconcile.js';
 import { isUpdateMigrationReceiptCurrent, projectUpdateMigrationReceiptPath, writeProjectUpdateMigrationReceipt } from '../core/update/update-migration-state.js';
 import { inspectSksMenuBarStatus, installSksMenuBar } from '../core/codex-app/sks-menubar.js';
 import { sweepSksTempDirs } from '../core/retention.js';
@@ -140,6 +141,7 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
     }));
     const recoveryReady = codexLbRecoveryStatusReady(providerStatus, true);
     const globalSkillsReady = !globalSkills?.error
+        && globalSkills?.ok !== false
         && globalSkills?.core_skill_integrity?.ok !== false;
     const globalFastModeReady = globalFastMode?.status !== 'failed'
         && globalFastMode?.ok !== false;
@@ -445,20 +447,7 @@ async function runDoctor(args = [], root, doctorFix) {
                 : await (await import('../cli/install-helpers.js')).ensureGlobalCodexFastModeDuringInstall().catch((err) => ({ status: 'failed', error: err?.message || String(err) }))
         };
     }
-    const skillsReconcile = doctorFix
-        ? {
-            global: await (await import('../core/init/skills.js')).reconcileSkills({
-                targetDir: path.join(process.env.HOME || os.homedir(), '.agents', 'skills'),
-                scope: 'global',
-                fix: true
-            }).catch((err) => ({ ok: false, error: err?.message || String(err) })),
-            project: await (await import('../core/init/skills.js')).reconcileSkills({
-                targetDir: path.join(root, '.agents', 'skills'),
-                scope: 'project',
-                fix: true
-            }).catch((err) => ({ ok: false, error: err?.message || String(err) }))
-        }
-        : { skipped: true, reason: 'doctor_without_fix' };
+    const skillsReconcile = await reconcileDoctorSkills(root, doctorFix);
     const commandAliasCleanup = await runDoctorCommandAliasCleanup({
         root,
         fix: doctorFix
@@ -1203,6 +1192,7 @@ async function runDoctor(args = [], root, doctorFix) {
         doctor_dirty_plan: doctorDirtyPlan,
         doctor_fix_postcheck: doctorFixPostcheck,
         doctor_native_capability: doctorNativeCapabilityRepair,
+        skills: skillsReconcile,
         local_model: localModel,
         agent_role_config: agentRoleConfigRepair,
         repair: configRepair,

package/dist/commands/perf.js

@@ -1,5 +1,6 @@
 import { performance } from 'node:perf_hooks';
 import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 import { PACKAGE_VERSION, projectRoot } from '../core/fsx.js';
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
@@ -61,7 +62,7 @@ export async function run(_command, args = []) {
     return perfCommand(action, args.slice(1));
 }
 export function runColdStart({ root = process.cwd(), iterations = DEFAULT_COLD_START_ITERATIONS, tier = 'source-local' } = {}) {
-    const script = new URL('../bin/sks.js', import.meta.url).pathname;
+    const script = coldStartCliEntrypoint();
     const measuredIterations = resolveColdStartIterations(iterations);
     const budgets = (COLD_START_TIERS[tier] || COLD_START_TIERS['source-local']);
     const commands = COLD_START_COMMANDS.map((spec) => measureCommand(root, script, { ...spec, budget_p95_ms: budgets[spec.cmd] }, measuredIterations));
@@ -76,6 +77,9 @@ export function runColdStart({ root = process.cwd(), iterations = DEFAULT_COLD_S
         ok: commands.every((row) => row.ok)
     };
 }
+export function coldStartCliEntrypoint(moduleUrl = import.meta.url) {
+    return fileURLToPath(new URL('../bin/sks.js', moduleUrl));
+}
 export function resolveColdStartIterations(value = DEFAULT_COLD_START_ITERATIONS) {
     const parsed = Number(value ?? DEFAULT_COLD_START_ITERATIONS);
     if (!Number.isFinite(parsed) || parsed <= 0)

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

@@ -7,8 +7,6 @@ export async function run(_command = 'zellij-slot-column-anchor', args = []) {
     const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000') || 1000));
     for (;;) {
         const text = await renderZellijSlotColumnAnchorFromArtifacts({ artifactRoot, missionId, mode });
-        // Cursor-home + clear-to-end redraw; `\x1Bc` (RIS) resets the pane's
-        // scrollback/modes every tick and intermittently breaks scrolling.
         process.stdout.write('\x1b[H' + text + '\n\x1b[0J');
         if (!watch)
             break;

package/dist/commands/zellij-slot-pane.js

@@ -53,9 +53,6 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
         process.stdout.write(redrawFrame(text));
         if (!watch)
             break;
-        // Root-cause-3 fix: exit the pane once the worker has reached a terminal state and written its
-        // result, so the pane closes (or shows the final exited frame) instead of looping forever and
-        // perpetually re-reporting telemetry staleness.
         const shouldExit = await resolveZellijSlotPaneExit({ artifactDir, artifactRoot, missionId, slotId, generationIndex }).catch(() => false);
         if (shouldExit) {
             await new Promise((resolve) => setTimeout(resolve, 5000));
@@ -75,10 +72,6 @@ function readOption(args, name, fallback) {
     const index = args.indexOf(name);
     return index >= 0 && args[index + 1] ? String(args[index + 1]) : fallback;
 }
-// Redraw in place with cursor-home + clear-to-end instead of `\x1Bc` (RIS).
-// RIS performs a full terminal reset every tick, which wipes the Zellij pane's
-// scrollback and resets scroll position/modes — the cause of intermittent
-// "scrolling stops working" while a watch pane is refreshing.
 function redrawFrame(text) {
     return '\x1b[H' + text + '\n\x1b[0J';
 }

package/dist/commands/zellij.js

@@ -315,8 +315,6 @@ async function zellijDispatch(root, args, json) {
         process.exitCode = 1;
 }
 async function zellijRepair(root, args, json) {
-    // Explain-only by default: SKS never auto-installs Zellij (no Homebrew/cargo
-    // side-effects from this command). It surfaces the exact operator steps.
     const capability = await checkZellijCapability({ root, require: false });
     const status = capability.status || 'unknown';
     const autoInstall = false;