sneakoscope 6.1.0 → 6.2.0

package/dist/commands/doctor.js

@@ -8,6 +8,8 @@ import { getCodexInfo } from '../core/codex-adapter.js';
 import { rustInfo } from '../core/rust-accelerator.js';
 import { codexAppIntegrationStatus } from '../core/codex-app.js';
 import { codexLbMetrics, readCodexLbCircuit } from '../core/codex-lb-circuit.js';
+import { codexLbStatus } from '../cli/install-helpers.js';
+import { codexLbToolOutputRecoveryOverrideAcknowledged } from '../core/codex-lb/codex-lb-tool-output-recovery.js';
 import { normalizeInstallScope } from '../core/init.js';
 import { inspectCodexConfigReadability } from '../core/codex/codex-config-readability.js';
 import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
@@ -26,9 +28,35 @@ import { inspectSksMenuBarStatus, installSksMenuBar } from '../core/codex-app/sk
 import { sweepSksTempDirs } from '../core/retention.js';
 import { detectImagegenCapability } from '../core/imagegen/imagegen-capability.js';
 import { CURRENT_CODEX_RELEASE_MANIFEST } from '../core/codex-compat/codex-release-manifest.js';
-export async function run(_command, args = []) {
+import { formatHarnessConflictReport, scanHarnessConflicts } from '../core/harness-conflicts.js';
+export async function run(_command, args = [], deps = {}) {
     const root = await projectRoot();
     const doctorFix = flag(args, '--fix');
+    const globalOnly = doctorFix && flag(args, '--global-only');
+    if (doctorFix) {
+        const conflictScan = await scanHarnessConflicts(root);
+        if (conflictScan.hard_block) {
+            const blocked = {
+                schema: 'sks.doctor-status.v3',
+                ok: false,
+                status: 'blocked_harness_conflict',
+                diagnostic_depth: 'fix',
+                root,
+                blockers: conflictScan.hard.map((item) => `${item.name || 'harness'}:${item.path}`),
+                conflicts: conflictScan.conflicts,
+                cleanup_prompt_command: 'sks conflicts prompt',
+                no_fix_writes_performed: true
+            };
+            process.exitCode = 1;
+            if (flag(args, '--json')) {
+                printJson(blocked);
+                return blocked;
+            }
+            console.error(formatHarnessConflictReport(conflictScan, { includePrompt: false }));
+            console.error('Run `sks conflicts prompt` and obtain explicit human approval before cleanup.');
+            return blocked;
+        }
+    }
     const doctorProfile = doctorProfileFromArgs(args, doctorFix);
     if (!flag(args, '--json')) {
         cliUi.banner('doctor');
@@ -36,10 +64,153 @@ export async function run(_command, args = []) {
     }
     if (!doctorFix && flag(args, '--json') && doctorProfile === 'fast')
         return runDoctorJsonFastPath(args, root);
-    if (doctorFix)
-        return withSecretPreservationGuard(root, 'doctor-fix', () => runDoctor(args, root, doctorFix));
+    if (doctorFix) {
+        const guardRoot = globalOnly
+            ? path.resolve(deps.home || process.env.HOME || os.homedir())
+            : root;
+        return withSecretPreservationGuard(guardRoot, 'doctor-fix', async () => (globalOnly
+            ? runDoctorGlobalOnlyFix(args, root, deps)
+            : runDoctor(args, root, doctorFix)));
+    }
     return runDoctor(args, root, doctorFix);
 }
+export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
+    const startedAtMs = Date.now();
+    const home = path.resolve(deps.home || process.env.HOME || os.homedir());
+    const reconcileSkillsImpl = deps.reconcileSkillsImpl
+        || (await import('../core/init/skills.js')).reconcileSkills;
+    const ensureGlobalFastModeImpl = deps.ensureGlobalCodexFastModeDuringInstallImpl
+        || (await import('../cli/install-helpers.js')).ensureGlobalCodexFastModeDuringInstall;
+    const installMenuBarImpl = deps.installSksMenuBarImpl || installSksMenuBar;
+    const codexLbStatusImpl = deps.codexLbStatusImpl || codexLbStatus;
+    const providerStatus = await codexLbStatusImpl({
+        probeToolOutputRecovery: true,
+        allowUnverifiedToolOutputRecovery: codexLbToolOutputRecoveryOverrideAcknowledged({ args })
+    }).catch((err) => ({
+        selected: null,
+        provider_ready: false,
+        recovery_probe_failed: true,
+        tool_output_recovery: {
+            ok: false,
+            status: 'probe_failed',
+            blockers: ['codex_lb_tool_output_recovery_status_probe_failed'],
+            operator_actions: []
+        },
+        error: err?.message || String(err)
+    }));
+    const globalSkills = await reconcileSkillsImpl({
+        targetDir: path.join(home, '.agents', 'skills'),
+        scope: 'global',
+        fix: true
+    }).catch((err) => ({
+        schema: 'sks.skill-reconcile.v1',
+        scope: 'global',
+        target_dir: path.join(home, '.agents', 'skills'),
+        fix: true,
+        error: err?.message || String(err),
+        core_skill_integrity: { ok: false, installed_count: 0, restored_count: 0 }
+    }));
+    const globalFastMode = await ensureGlobalFastModeImpl().catch((err) => ({
+        status: 'failed',
+        error: err?.message || String(err)
+    }));
+    const menuBar = await installMenuBarImpl({
+        home,
+        root: home,
+        apply: true,
+        launch: true,
+        quiet: flag(args, '--json') || flag(args, '--machine-only')
+    }).catch((err) => ({
+        schema: 'sks.codex-app-sks-menubar.v1',
+        ok: false,
+        status: 'blocked',
+        blockers: [err?.message || String(err)],
+        warnings: []
+    }));
+    const recoveryReady = codexLbRecoveryStatusReady(providerStatus, true);
+    const globalSkillsReady = !globalSkills?.error
+        && globalSkills?.core_skill_integrity?.ok !== false;
+    const globalFastModeReady = globalFastMode?.status !== 'failed'
+        && globalFastMode?.ok !== false;
+    const menuBarReady = menuBar?.ok !== false;
+    const blockers = [...new Set([
+            ...(!globalSkillsReady ? [`global_skills_reconcile_failed:${globalSkills?.error || 'core_skill_integrity'}`] : []),
+            ...(!globalFastModeReady ? [`global_fast_mode_repair_failed:${globalFastMode?.error || globalFastMode?.status || 'unknown'}`] : []),
+            ...(!menuBarReady ? (menuBar?.blockers || ['sks_menubar_repair_failed']) : []),
+            ...(!recoveryReady ? (providerStatus?.tool_output_recovery?.blockers || ['codex_lb_tool_output_recovery_unverified']) : [])
+        ].map(String).filter(Boolean))];
+    const ok = blockers.length === 0;
+    return {
+        schema: 'sks.doctor-status.v3',
+        elapsed_ms: Date.now() - startedAtMs,
+        ok,
+        status: ok ? 'global_fix_ok' : 'blocked',
+        diagnostic_depth: 'global-only',
+        global_only: true,
+        install_scope: 'global',
+        root,
+        home,
+        project_root_alias_detected: path.resolve(root) === home,
+        no_project_writes_performed: true,
+        project_phases_skipped: [
+            'project_skills_reconcile',
+            'project_codex_config_repair',
+            'project_context7_mcp_repair',
+            'project_supabase_mcp_repair',
+            'project_hook_trust_repair',
+            'project_command_alias_cleanup',
+            'project_migration_receipt'
+        ],
+        skills: { global: globalSkills, project: { skipped: true, reason: 'global_only_doctor' } },
+        codex_app_fast_mode: globalFastMode,
+        sks_menubar: menuBar,
+        codex_lb: {
+            provider_status: providerStatus,
+            tool_output_recovery: providerStatus?.tool_output_recovery || null,
+            recovery_ok: recoveryReady
+        },
+        blockers,
+        next_actions: [
+            ...(recoveryReady ? [] : (providerStatus?.tool_output_recovery?.operator_actions || [])),
+            'Run `sks doctor --fix --json` from a specific project directory when project-scoped repair is required.'
+        ]
+    };
+}
+async function runDoctorGlobalOnlyFix(args = [], root, deps = {}) {
+    const result = await executeDoctorGlobalOnlyFix(args, root, deps);
+    const reportFile = readOption(args, '--report-file', null);
+    if (reportFile)
+        await writeJsonReportFile(reportFile, result);
+    if (flag(args, '--machine-only') && !flag(args, '--json')) {
+        if (!result.ok)
+            process.exitCode = 1;
+        return result;
+    }
+    if (flag(args, '--json')) {
+        printJson(result);
+    }
+    else {
+        console.log(`SKS Doctor global repair: ${result.ok ? 'ok' : 'blocked'}`);
+        console.log(`Global skills: ${result.skills.global?.error ? 'blocked' : 'reconciled'}`);
+        console.log(`SKS menu bar: ${result.sks_menubar?.status || (result.sks_menubar?.ok ? 'ok' : 'blocked')}`);
+        for (const blocker of result.blockers)
+            console.log(`- blocker: ${blocker}`);
+        for (const action of result.next_actions)
+            console.log(`- ${action}`);
+    }
+    if (!result.ok)
+        process.exitCode = 1;
+    return result;
+}
+function codexLbRecoveryStatusReady(status, probeRequired = false) {
+    if (status == null)
+        return !probeRequired;
+    if (status.recovery_probe_failed === true || status.error)
+        return false;
+    if (status.selected === false)
+        return true;
+    return status.selected === true && status.tool_output_recovery?.ok === true;
+}
 async function runDoctorJsonFastPath(args = [], root) {
     const startedAtMs = Date.now();
     const codexBin = readOption(args, '--codex-bin', process.env.SKS_DOCTOR_CODEX_BIN || '');
@@ -359,7 +530,31 @@ async function runDoctor(args = [], root, doctorFix) {
     const codexApp = deepDiagnostics
         ? await codexAppIntegrationStatus({ codex }).catch((err) => ({ ok: false, error: err.message }))
         : { ok: false, skipped: true, warnings: ['codex_app_optional_diagnostic_skipped'] };
-    const codexLb = codexLbMetrics(await readCodexLbCircuit(root).catch(() => ({})));
+    const codexLbCircuit = codexLbMetrics(await readCodexLbCircuit(root).catch(() => ({})));
+    const codexLbProviderStatus = deepDiagnostics || doctorFix
+        ? await codexLbStatus({
+            probeToolOutputRecovery: true,
+            allowUnverifiedToolOutputRecovery: codexLbToolOutputRecoveryOverrideAcknowledged({ args })
+        }).catch((err) => ({
+            selected: null,
+            provider_ready: false,
+            recovery_probe_failed: true,
+            tool_output_recovery: {
+                ok: false,
+                status: 'probe_failed',
+                blockers: ['codex_lb_tool_output_recovery_status_probe_failed'],
+                operator_actions: []
+            },
+            error: err?.message || String(err)
+        }))
+        : null;
+    const codexLbRecoveryReady = codexLbRecoveryStatusReady(codexLbProviderStatus, deepDiagnostics || doctorFix);
+    const codexLb = {
+        ...codexLbCircuit,
+        provider_status: codexLbProviderStatus,
+        tool_output_recovery: codexLbProviderStatus?.tool_output_recovery || null,
+        recovery_ok: codexLbRecoveryReady
+    };
     const providerContext = deepDiagnostics
         ? await resolveProviderContext({ root, route: '$Doctor', serviceTier: process.env.SKS_SERVICE_TIER || 'fast' }).catch((err) => ({
             schema: 'sks.provider-context.v1',
@@ -755,19 +950,30 @@ async function runDoctor(args = [], root, doctorFix) {
     const zellij = await checkZellijCapability({ root, require: process.env.SKS_REQUIRE_ZELLIJ === '1' });
     const localModel = await readLocalModelConfig().catch(() => null);
     const permissionProfiles = await inventoryCodexPermissionProfiles(root, { writeReport: true });
-    const agentRoleConfigRepair = await repairAgentRoleConfigs({
-        root,
-        apply: doctorFix,
-        reportPath: `${root}/.sneakoscope/reports/agent-role-config-repair.json`
-    }).catch((err) => ({
-        schema: 'sks.agent-role-config-repair.v1',
-        ok: false,
-        apply: doctorFix,
-        missing: [],
-        existing: [],
-        created: [],
-        warnings_suppressed: false,
-        blockers: [err?.message || String(err)]
+    const startupRoleRepair = startupConfigRepair?.role_repair;
+    const agentRoleConfigRepair = doctorFix && startupRoleRepair
+        ? startupRoleRepair
+        : await repairAgentRoleConfigs({
+            root,
+            apply: false,
+            reportPath: `${root}/.sneakoscope/reports/agent-role-config-repair.json`
+        }).catch((err) => ({
+            schema: 'sks.agent-role-config-repair.v1',
+            ok: false,
+            apply: false,
+            missing: [],
+            existing: [],
+            created: [],
+            warnings_suppressed: false,
+            blockers: [err?.message || String(err)]
+        }));
+    const officialSubagentConfig = await (await import('../core/subagents/official-subagent-config.js'))
+        .readOfficialSubagentConfig(root)
+        .catch((err) => ({
+        maxThreads: null,
+        maxDepth: null,
+        blockers: [`official_subagent_config_read_failed:${err?.message || String(err)}`],
+        warnings: []
     }));
     const globalSksInstallCleanup = flag(args, '--fix') && !flag(args, '--local-only')
         ? await (await import('../core/doctor/global-sks-install-cleanup.js')).cleanDuplicateGlobalSksInstalls({ root, fix: true }).catch((err) => ({ schema: 'sks.global-sks-install-cleanup.v1', ok: false, fix: true, error: err?.message || String(err), blockers: ['global_sks_install_cleanup_exception'] }))
@@ -1056,7 +1262,13 @@ async function runDoctor(args = [], root, doctorFix) {
     }
     const zellijReadiness = buildZellijReadiness(root, zellij, ready);
     const runtimeReadiness = buildRuntimeReadiness(zellijReadiness, codexNativeFeatureMatrix);
-    const resultOk = ready.ready && (!sksUpdate || sksUpdate.ok !== false) && commandAliasCleanup.ok !== false && codexStartupRepair.ok !== false;
+    const resultOk = ready.ready
+        && (!sksUpdate || sksUpdate.ok !== false)
+        && commandAliasCleanup.ok !== false
+        && codexStartupRepair.ok !== false
+        && agentRoleConfigRepair.ok !== false
+        && (officialSubagentConfig.blockers || []).length === 0
+        && codexLbRecoveryReady;
     const result = {
         schema: 'sks.doctor-status.v3',
         elapsed_ms: Date.now() - startedAtMs,
@@ -1064,7 +1276,7 @@ async function runDoctor(args = [], root, doctorFix) {
         status: resultOk ? (doctorFix ? 'fix_ok' : deepDiagnostics ? 'full_ok' : 'fast_ok') : 'blocked',
         diagnostic_depth: deepDiagnostics ? 'full' : doctorFix ? 'fix' : 'fast',
         deep_diagnostics_skipped: !deepDiagnostics,
-        deep_ok: deepDiagnostics ? Boolean(ready.ready) : null,
+        deep_ok: deepDiagnostics ? resultOk : null,
         not_counted_as_full_doctor: !deepDiagnostics,
         root,
         arg_warnings: argWarnings,
@@ -1099,6 +1311,7 @@ async function runDoctor(args = [], root, doctorFix) {
         } : null,
         local_model: localModel,
         agent_role_config: agentRoleConfigRepair,
+        official_subagent_config: officialSubagentConfig,
         zellij_readiness: zellijReadiness,
         codex_permission_profiles: permissionProfiles,
         command_aliases: commandAliasCleanup,
@@ -1151,6 +1364,8 @@ async function runDoctor(args = [], root, doctorFix) {
     console.log('SKS Doctor');
     for (const warning of argWarnings)
         console.log(`Argument warning: ${warning}`);
+    for (const warning of officialSubagentConfig.warnings || [])
+        console.log(`Official subagent warning: ${warning}`);
     console.log(`Root:      ${root}`);
     console.log(`Node:      ${result.node.ok ? 'ok' : 'fail'} ${result.node.version}`);
     console.log(`Codex:     ${codex.bin ? 'ok' : 'missing'} ${codex.version || ''}`);
@@ -1328,6 +1543,13 @@ async function runDoctor(args = [], root, doctorFix) {
     if (codex0138Doctor?.fixed?.length)
         console.log(`  doctor --fix repaired: ${codex0138Doctor.fixed.join(', ')}`);
     console.log(`codex-lb:  ${codexLb.ok ? 'ok' : `warning ${codexLb.circuit?.state || 'unknown'}`}`);
+    if (codexLb.tool_output_recovery) {
+        const recovery = codexLb.tool_output_recovery;
+        console.log(`  interrupted tool-output recovery: ${recovery.ok ? 'ready' : 'blocked'} (${recovery.observed_version || recovery.status}; minimum ${recovery.minimum_version})`);
+        if (!recovery.ok)
+            for (const action of recovery.operator_actions || [])
+                console.log(`  action: ${action}`);
+    }
     if (localModel) {
         console.log('Local LLM:');
         console.log(`  enabled: ${localModel.enabled ? 'yes' : 'no'}`);
@@ -1481,7 +1703,7 @@ function unknownDoctorFlags(args = []) {
     const knownBoolean = new Set([
         '--fix', '--yes', '-y', '--machine-only', '--actual-codex', '--require-actual-codex',
         '--full', '--capabilities', '--repair-codex-app-ui', '--repair-zellij', '--install-homebrew',
-        '--repair-native-capabilities', '--repair-codex-native', '--local-only', '--project', '--global',
+        '--repair-native-capabilities', '--repair-codex-native', '--local-only', '--global-only', '--project', '--global',
         '--dry-run', '--json'
     ]);
     const knownValue = new Set(['--profile', '--report-file', '--codex-bin', '--install-scope']);

package/dist/commands/tmux.js

@@ -6,7 +6,11 @@ export async function run(_command, args = []) {
         runtime: 'tmux',
         status: 'removed_runtime',
         replacement: 'zellij',
-        operator_actions: ['Use `sks --mad`, `sks team open-zellij`, or `npm run zellij:capability`.']
+        operator_actions: [
+            'Use `sks --mad` for the supported SKS Zellij launcher.',
+            'Use `sks zellij status` or `npm run zellij:capability` for runtime diagnostics.',
+            'Use `sks naruto status|subagents|proof` for official subagent missions.'
+        ]
     };
     if (json)
         console.log(JSON.stringify(result, null, 2));

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

@@ -1,12 +1,14 @@
 import { readZellijSlotTelemetrySnapshot } from '../core/zellij/zellij-slot-telemetry.js';
 import { renderZellijMonitor } from '../core/zellij/zellij-monitor-renderer.js';
 import { projectRoot } from '../core/fsx.js';
+import { refreshOfficialSubagentZellijActivity } from '../core/zellij/zellij-official-subagent-activity.js';
 export async function run(_cmd = 'zellij-monitor-pane', args = []) {
     const mission = readOption(args, '--mission', 'latest') || 'latest';
     const root = await projectRoot();
     const intervalMs = Math.max(500, Number(readOption(args, '--interval-ms', String(process.env.SKS_ZELLIJ_REFRESH_MS || '1000')) || 1000));
     const once = !flag(args, '--watch');
     for (;;) {
+        await refreshOfficialSubagentZellijActivity({ root, missionId: mission }).catch(() => null);
         const snapshot = await readZellijSlotTelemetrySnapshot(root, mission).catch(() => null);
         const text = renderZellijMonitor({ snapshot, missionId: mission, root });
         process.stdout.write(`\x1b[H${text}\n\x1b[0J`);

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

@@ -4,13 +4,14 @@ import { projectRoot, readJson } from '../core/fsx.js';
 import { readZellijSlotTelemetrySnapshot } from '../core/zellij/zellij-slot-telemetry.js';
 import { bindViewports } from '../core/zellij/zellij-viewport-binder.js';
 import { renderZellijSlotPaneFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
+import { refreshOfficialSubagentZellijActivity } from '../core/zellij/zellij-official-subagent-activity.js';
 import { ANSI_CODES, paint, resolveZellijTheme } from '../core/zellij/zellij-theme.js';
 let previousBindings = [];
 export async function run(_cmd = 'zellij-viewport-pane', args = []) {
     const mission = String(readOption(args, '--mission', 'latest') || 'latest');
     const index = Math.max(1, Number(readOption(args, '--index', '1')) || 1);
     const of = Math.max(index, Number(readOption(args, '--of', '4')) || 4);
-    const intervalMs = Math.max(500, Number(process.env.SKS_ZELLIJ_REFRESH_MS || 1000));
+    const intervalMs = Math.max(500, Number(readOption(args, '--interval-ms', String(process.env.SKS_ZELLIJ_REFRESH_MS || '1000')) || 1000));
     const root = await projectRoot();
     previousBindings = Array.from({ length: of }, () => null);
     const once = !flag(args, '--watch');
@@ -24,6 +25,7 @@ export async function run(_cmd = 'zellij-viewport-pane', args = []) {
 }
 async function renderViewportFrame(root, mission, index, of) {
     const theme = resolveZellijTheme();
+    await refreshOfficialSubagentZellijActivity({ root, missionId: mission }).catch(() => null);
     const snapshot = await readZellijSlotTelemetrySnapshot(root, mission).catch(() => null);
     const missionId = snapshot?.mission_id || mission;
     const pins = await readJson(pinsPath(root, missionId), { pins: [] });

package/dist/commands/zellij.js

@@ -53,7 +53,7 @@ async function zellijStatus(root, args, json) {
         ok: ready || !requireReal,
         status,
         version: capability.version || null,
-        required_for: ['sks --mad', 'sks team open-zellij', 'interactive lane UI'],
+        required_for: ['sks --mad', 'interactive MAD lane UI', 'standalone Zellij diagnostics'],
         blockers: capability.blockers || [],
         warnings: capability.warnings || [],
         install_hint: ready ? null : installHint(),