sneakoscope 6.0.3 → 6.1.2

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';
@@ -25,9 +27,36 @@ import { isUpdateMigrationReceiptCurrent, projectUpdateMigrationReceiptPath, wri
 import { inspectSksMenuBarStatus, installSksMenuBar } from '../core/codex-app/sks-menubar.js';
 import { sweepSksTempDirs } from '../core/retention.js';
 import { detectImagegenCapability } from '../core/imagegen/imagegen-capability.js';
-export async function run(_command, args = []) {
+import { CURRENT_CODEX_RELEASE_MANIFEST } from '../core/codex-compat/codex-release-manifest.js';
+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');
@@ -35,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 || '');
@@ -358,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',
@@ -754,49 +950,78 @@ 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'] }))
         : null;
     const shouldProbeNativeCapabilityRepairs = doctorFix || deepDiagnostics || nativeCapabilityDiagnosticsRequested;
     const imagegen = await detectImagegenCapability({ codexBin: codexBin || undefined }).catch((err) => ({ ok: false, error: err.message, auth_readiness: null, core_ready: false, blockers: ['imagegen_detection_exception'] }));
-    const imagegenRepair = imagegen.core_ready === true
-        ? {
+    const imagegenRepair = shouldProbeNativeCapabilityRepairs
+        ? await (await import('../core/doctor/imagegen-repair.js')).repairCodexImagegen({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
             schema: 'sks.doctor-imagegen-repair.v1',
-            ok: true,
-            attempted: false,
+            ok: false,
+            attempted: true,
             apply: doctorFix,
-            recovered: true,
-            before: imagegen,
-            after: imagegen,
-            steps: [],
-            blockers: [],
-            manual_actions: [],
-            communication_test: { level: 'flag_level', ok: true, checked: 'codex features list --json (feature-flag/plugin metadata only)', real_generation_round_trip_performed: false, blocker: null }
-        }
-        : shouldProbeNativeCapabilityRepairs
-            ? await (await import('../core/doctor/imagegen-repair.js')).repairCodexImagegen({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
+            recovered: false,
+            capability_ready: false,
+            route_ready: false,
+            real_generation_verified: false,
+            blockers: [err?.message || String(err)],
+            manual_actions: ['Run `sks doctor --fix --json` after enabling Codex App image_generation.']
+        }))
+        : imagegen.core_ready === true
+            ? {
                 schema: 'sks.doctor-imagegen-repair.v1',
                 ok: false,
-                attempted: true,
+                attempted: false,
                 apply: doctorFix,
                 recovered: false,
-                blockers: [err?.message || String(err)],
-                manual_actions: ['Run `sks doctor --fix --json` after enabling Codex App image_generation.']
-            }))
+                capability_ready: true,
+                configuration_ready: true,
+                route_ready: false,
+                real_generation_verified: false,
+                current_task_tool_manifest_verified: false,
+                requires_new_task: true,
+                before: imagegen,
+                after: imagegen,
+                steps: [],
+                blockers: ['codex_imagegen_current_task_tool_manifest_unverified', 'codex_imagegen_real_output_unverified'],
+                manual_actions: [
+                    'Start a fresh Codex/Work task so $imagegen is present in its tool manifest.',
+                    'Invoke $imagegen with gpt-image-2 and bind the selected raster output path to route evidence.'
+                ],
+                communication_test: {
+                    level: 'flag_level',
+                    ok: false,
+                    checked: 'codex features list (feature-flag/plugin metadata only)',
+                    real_generation_round_trip_performed: false,
+                    blocker: 'codex_imagegen_real_output_unverified'
+                }
+            }
             : deferredNativeRepair('sks.doctor-imagegen-repair.v1', doctorFix, [
                 'Run `sks doctor --fix --repair-native-capabilities --json` after enabling Codex App image_generation.'
             ]);
@@ -843,12 +1068,23 @@ async function runDoctor(args = [], root, doctorFix) {
         : null;
     const nativeCapabilityReadinessStatus = (repair) => repair?.skipped === true
         ? (repair.status || 'deferred')
-        : (repair?.recovered === true || repair?.ok === true ? 'ok' : repair?.attempted ? 'blocked' : 'not-needed');
+        : repair?.route_ready === true
+            ? 'ok'
+            : repair?.capability_ready === true
+                ? 'available-unverified'
+                : (repair?.recovered === true || repair?.ok === true ? 'ok' : repair?.attempted ? 'blocked' : 'not-needed');
     const nativeCapabilityReadiness = {
         schema: 'sks.native-capability-readiness.v1',
         generated_at: nowIso(),
         apply: doctorFix,
-        imagegen: { status: nativeCapabilityReadinessStatus(imagegenRepair), communication_test: imagegenRepair?.communication_test || null, blockers: imagegenRepair?.blockers || [] },
+        imagegen: {
+            status: nativeCapabilityReadinessStatus(imagegenRepair),
+            capability_ready: imagegenRepair?.capability_ready === true,
+            route_ready: imagegenRepair?.route_ready === true,
+            generated_output_verified: imagegenRepair?.real_generation_verified === true,
+            communication_test: imagegenRepair?.communication_test || null,
+            blockers: imagegenRepair?.blockers || []
+        },
         computer_use: { status: nativeCapabilityReadinessStatus(computerUseRepair), blockers: computerUseRepair?.blockers || [], next_actions: computerUseRepair?.next_actions || [] },
         browser_use: { status: nativeCapabilityReadinessStatus(browserUseRepair), blockers: browserUseRepair?.blockers || [], next_actions: browserUseRepair?.next_actions || [] }
     };
@@ -1026,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,
@@ -1034,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,
@@ -1069,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,
@@ -1080,7 +1323,11 @@ async function runDoctor(args = [], root, doctorFix) {
             error: sksTempSweep.error || null
         },
         imagegen: {
-            ok: imagegen.auth_readiness?.available_paths?.length > 0,
+            ok: imagegenRepair?.route_ready === true,
+            capability_ready: imagegen.codex_app?.available === true,
+            route_ready: imagegenRepair?.route_ready === true,
+            generated_output_verified: imagegenRepair?.real_generation_verified === true,
+            auth_ready: imagegen.auth_readiness?.headless_auto_available === true,
             auth_readiness: imagegen.auth_readiness || null,
             codex_app_builtin_available: imagegen.codex_app?.available === true
         },
@@ -1117,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 || ''}`);
@@ -1252,7 +1501,7 @@ async function runDoctor(args = [], root, doctorFix) {
                 console.log(`  - ${action}`);
         }
     }
-    console.log(`Image Gen repair: ${imagegenRepair.recovered ? 'ok' : imagegenRepair.attempted ? 'blocked' : 'not-needed'}`);
+    console.log(`Image Gen repair: ${nativeCapabilityReadiness.imagegen.status}`);
     for (const action of imagegenRepair.manual_actions || [])
         console.log(`  - ${action}`);
     console.log(`Computer Use repair: ${computerUseRepair.recovered ? 'ok' : computerUseRepair.attempted ? 'blocked' : 'not-needed'}`);
@@ -1272,7 +1521,7 @@ async function runDoctor(args = [], root, doctorFix) {
     }
     const codex0138 = codex0138Capability.report || {};
     console.log('Codex current compatibility:');
-    console.log(`  target: rust-v0.142.0`);
+    console.log(`  target: ${CURRENT_CODEX_RELEASE_MANIFEST.targetTag}`);
     console.log(`  runtime: ${codex.version || 'unknown'}`);
     console.log(`  multi-agent mode: ${codexNativeFeatureMatrix.features?.multi_agent_mode?.ok ? 'verified' : 'unverified'}`);
     console.log(`  rollout budget: ${codexNativeFeatureMatrix.features?.rollout_budget?.ok ? 'verified' : 'unverified'}`);
@@ -1294,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'}`);
@@ -1378,9 +1634,9 @@ function buildRuntimeReadiness(zellijReadiness, matrix) {
             ...(zellijStatus === 'headless_available' ? ['MAD can run with --headless; live panes require repair'] : []),
             ...(hookPolicy !== 'approved-only' ? ['hook-derived evidence will not count'] : []),
             ...(agentStrategy !== 'agent_type' ? ['message-role fallback active'] : []),
-            ...(multiAgentMode === 'proactive' ? ['Codex 0.142 multi-agent proactive mode available for Naruto-style routes'] : []),
-            ...(rolloutBudget === 'codex-0142-shared' ? ['Codex 0.142 rollout budget can be recorded in route proof'] : []),
-            ...(researchSource === 'indexed-web-search' ? ['Codex 0.142 indexed web search selected for source-intelligence routes'] : [])
+            ...(multiAgentMode === 'proactive' ? [`Codex ${CURRENT_CODEX_RELEASE_MANIFEST.requiredCliVersion} multi-agent proactive mode available for Naruto-style routes`] : []),
+            ...(rolloutBudget === 'codex-0144-shared' ? [`Codex ${CURRENT_CODEX_RELEASE_MANIFEST.requiredCliVersion} rollout budget can be recorded in route proof`] : []),
+            ...(researchSource === 'indexed-web-search' ? [`Codex ${CURRENT_CODEX_RELEASE_MANIFEST.requiredCliVersion} indexed web search selected for source-intelligence routes`] : [])
         ],
         repair_actions: [...new Set(repairActions)]
     };
@@ -1447,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/versioning.js

@@ -3,6 +3,13 @@ import { bumpProjectVersion, disableVersionGitHook, versioningStatus } from '../
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 export async function run(_command, args = []) {
+    if (flag(args, '--help') || flag(args, '-h')) {
+        const usage = 'Usage: sks versioning status|bump [major|minor|patch]|disable [--json]';
+        if (flag(args, '--json'))
+            return printJson({ ok: true, command: 'versioning', usage, mutated: false });
+        console.log(usage);
+        return;
+    }
     const root = await projectRoot();
     const action = args[0] || 'status';
     const bump = ['major', 'minor', 'patch'].includes(String(args[1] || '')) ? String(args[1]) : null;

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(),