sneakoscope 6.0.3 → 6.1.2

package/dist/core/commands/image-ux-review-command.js

@@ -72,33 +72,14 @@ async function runImageUxReview(root, command, args = []) {
     const shouldGenerateCallouts = flag(args, '--generate-callouts') || flag(args, '--fix');
     if (missionId)
         return rebuildExistingMission(root, command, [missionId, ...args], { fixRequested: flag(args, '--fix') });
-    const fromChromeExtension = flag(args, '--from-chrome-extension') || Boolean(readOption(args, '--from-chrome-extension', null));
-    const fromComputerUse = flag(args, '--from-computer-use') || Boolean(readOption(args, '--from-computer-use', null));
-    const chromePreflight = fromChromeExtension ? await codexChromeExtensionStatus() : null;
-    if (chromePreflight && !chromePreflight.ok) {
-        const result = {
-            schema: 'sks.image-ux-review-run.v1',
-            ok: false,
-            status: 'blocked',
-            blocker: 'codex_chrome_extension_setup_required',
-            chrome_extension: chromePreflight,
-            guidance: [
-                'Install/enable the Codex Chrome Extension first, then tell SKS installation is complete before resuming web UX review.'
-            ]
-        };
+    const sourcePreflight = await imageUxReviewSourcePreflight(args);
+    const { fromChromeExtension, fromComputerUse, chromePreflight } = sourcePreflight;
+    if (sourcePreflight.result) {
+        const result = sourcePreflight.result;
         process.exitCode = 1;
         if (flag(args, '--json'))
             return printJson(result);
-        console.error('UX Review blocked: install/enable the Codex Chrome Extension first, then tell SKS installation is complete before resuming.');
-        console.error(chromePreflight.docs_url);
-        return result;
-    }
-    if (fromComputerUse && !flag(args, '--native') && !flag(args, '--non-web')) {
-        const result = { schema: 'sks.image-ux-review-run.v1', ok: false, status: 'blocked', blocker: 'web_ux_review_requires_codex_chrome_extension_not_computer_use' };
-        process.exitCode = 1;
-        if (flag(args, '--json'))
-            return printJson(result);
-        console.error('UX Review blocked: web/browser UX review requires Codex Chrome Extension, not Computer Use. Use --from-chrome-extension after setup, or provide a screenshot with --image.');
+        printImageUxReviewSourcePreflightBlock(result);
         return result;
     }
     if (!imagePath && !fromChromeExtension && !fromComputerUse) {
@@ -219,6 +200,56 @@ async function runImageUxReview(root, command, args = []) {
     console.log(`Image UX review: ${result.ok ? 'ok' : 'blocked'} ${id}`);
     return result;
 }
+/**
+ * Read-only source validation shared with the active-route dispatcher. A
+ * blocked result is terminal and guarantees that the run cannot create a
+ * mission or write route evidence.
+ */
+export async function imageUxReviewSourcePreflight(args = []) {
+    const fromChromeExtension = flag(args, '--from-chrome-extension') || Boolean(readOption(args, '--from-chrome-extension', null));
+    const fromComputerUse = flag(args, '--from-computer-use') || Boolean(readOption(args, '--from-computer-use', null));
+    const chromePreflight = fromChromeExtension ? await codexChromeExtensionStatus() : null;
+    if (chromePreflight && !chromePreflight.ok) {
+        return {
+            fromChromeExtension,
+            fromComputerUse,
+            chromePreflight,
+            result: {
+                schema: 'sks.image-ux-review-run.v1',
+                ok: false,
+                status: 'blocked',
+                blocker: 'codex_chrome_extension_setup_required',
+                chrome_extension: chromePreflight,
+                guidance: [
+                    'Install/enable the Codex Chrome Extension first, then tell SKS installation is complete before resuming web UX review.'
+                ]
+            }
+        };
+    }
+    if (fromComputerUse && !flag(args, '--native') && !flag(args, '--non-web')) {
+        return {
+            fromChromeExtension,
+            fromComputerUse,
+            chromePreflight,
+            result: {
+                schema: 'sks.image-ux-review-run.v1',
+                ok: false,
+                status: 'blocked',
+                blocker: 'web_ux_review_requires_codex_chrome_extension_not_computer_use'
+            }
+        };
+    }
+    return { fromChromeExtension, fromComputerUse, chromePreflight, result: null };
+}
+function printImageUxReviewSourcePreflightBlock(result) {
+    if (result.blocker === 'codex_chrome_extension_setup_required') {
+        console.error('UX Review blocked: install/enable the Codex Chrome Extension first, then tell SKS installation is complete before resuming.');
+        if (result.chrome_extension?.docs_url)
+            console.error(result.chrome_extension.docs_url);
+        return;
+    }
+    console.error('UX Review blocked: web/browser UX review requires Codex Chrome Extension, not Computer Use. Use --from-chrome-extension after setup, or provide a screenshot with --image.');
+}
 async function calloutsImageUxReview(root, command, args = []) {
     const imagePath = readOption(args, '--image', null) || readOption(args, '--screenshot', null);
     if (!imagePath) {

package/dist/core/commands/mad-sks-command.js

@@ -23,10 +23,12 @@ import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-c
 import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
 import { resolveCodexNativeInvocationPlan } from '../codex-native/codex-native-invocation-router.js';
 import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
+import { SKS_ZELLIJ_HOST_MISSION_ENV } from '../zellij/zellij-official-subagent-telemetry.js';
 import { buildMadGlmLaunchArtifact, buildMadGlmLaunchProfileNoWrite, resolveMadGlmLaunchKey, writeMadGlmCodexWrapper } from '../providers/glm/glm-mad-launch.js';
 import { GLM_MAD_MODE } from '../providers/glm/glm-52-settings.js';
 import { assertNonGlmMadRoute } from '../routes/model-mode-router.js';
 import { evaluateGate } from '../stop-gate/gate-evaluator.js';
+import { CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_FLAG, codexLbToolOutputRecoveryOverrideAcknowledged } from '../codex-lb/codex-lb-tool-output-recovery.js';
 const MAD_SKS_DEFAULT_TTL_MS = 10 * 60 * 1000;
 export async function madHighCommand(args = [], deps = {}) {
     const rawArgsForHelp = (args || []).map((arg) => String(arg));
@@ -188,7 +190,16 @@ export async function madHighCommand(args = [], deps = {}) {
     // readability + repair checks still run. SKS_LAUNCH_FULL_CODEX_PROBE=1 restores the
     // old behavior.
     const allowMadRepair = rawArgs.includes('--repair-config') || rawArgs.includes('--fix') || rawArgs.includes('--yes-repair');
-    const launchPreflightOpts = { fix: allowMadRepair, launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1', profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' };
+    const allowUnverifiedToolOutputRecovery = codexLbToolOutputRecoveryOverrideAcknowledged({ args: rawArgs });
+    const launchPreflightOpts = {
+        fix: allowMadRepair,
+        launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1',
+        profile: profile.profile_name,
+        sandbox: 'danger-full-access',
+        serviceTier: 'fast',
+        skipCodexLbToolOutputRecovery: glmMadLaunch,
+        allowUnverifiedToolOutputRecovery
+    };
     let launchPreflight = await runCodexLaunchPreflight(launchRoot, launchPreflightOpts);
     // Fresh-project bootstrap: when the ONLY blocker is that the managed Codex config does
     // not exist yet (`.codex/config.toml` absent), regenerate it — exactly what the blocker
@@ -224,141 +235,162 @@ export async function madHighCommand(args = [], deps = {}) {
         return launchPreflight;
     }
     const madLaunch = await activateMadZellijPermissionState(process.cwd(), args);
-    const glmRuntime = glmMadLaunch ? await prepareMadGlmLaunchRuntime(madLaunch, { ...deps, glmArgs: deps?.glmArgs || rawArgs }) : null;
-    if (glmMadLaunch && !glmRuntime?.ok) {
-        process.exitCode = 1;
-        return glmRuntime;
-    }
-    if (madDbGrant.requested) {
-        const grantReport = {
-            schema: 'sks.mad-sks-launch-grants.v2',
-            generated_at: nowIso(),
-            mission_id: madLaunch.mission_id,
-            mad_sks_active: true,
-            mad_db_active: false,
-            mad_db_default_grant: false,
-            mad_db_grant_source: madDbGrant.source,
-            mad_db_requires_first_class_route: true,
-            mad_db_cli: 'sks mad-db run|exec|apply-migration',
-            mad_db_capability_file: null,
-            standalone_mad_db_enable_still_requires_ack: true
-        };
-        await writeJsonAtomic(path.join(madLaunch.dir, 'mad-sks-launch-grants.json'), grantReport);
-        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_db.first_class_route_required', grant_source: madDbGrant.source, cli: grantReport.mad_db_cli });
-    }
-    const updateNotice = {
-        schema: 'sks.update-notice.v1',
-        checked_at: nowIso(),
-        package_name: deps.packageName || 'sneakoscope',
-        current_version: deps.packageVersion || PACKAGE_VERSION,
-        latest_version: null,
-        update_available: false,
-        source: 'deferred_background',
-        cache_ttl_ms: 0,
-        message: 'SKS update notice refresh deferred until after MAD UI launch.'
-    };
-    void checkSksUpdateNotice({
-        packageName: deps.packageName || 'sneakoscope',
-        currentVersion: deps.packageVersion || PACKAGE_VERSION,
-        missionDir: madLaunch.dir
-    }).then((notice) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_refreshed_background', non_blocking: true, update_available: notice.update_available === true, source: notice.source })).catch((err) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_background_failed', error: err?.message || String(err) }));
-    await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_checked', non_blocking: true, update_available: updateNotice.update_available === true, source: updateNotice.source });
-    console.log(`SKS MAD ready: ${glmRuntime?.profile?.profile_name || madHighProfileName()} | gate ${madLaunch.mission_id}`);
-    if (glmRuntime?.profile)
-        console.log(`GLM MAD launch active: ${glmRuntime.profile.model} via OpenRouter; GPT fallback blocked.`);
-    if (madDbGrant.requested)
-        console.log('MAD-DB flag observed; deprecated route now redirects to MAD-SKS SQL-plane: sks mad-sks sql|apply-migration.');
-    if (updateNotice.update_available === true)
-        console.log(`SKS update notice: ${updateNotice.latest_version} available (non-blocking).`);
-    console.log('Scoped high-power maintenance authority active; add explicit --allow-* flags for packages, services, network, browser/Computer Use, generated assets, file permissions, or system/admin scopes. SQL-plane execution is available through MAD-SKS sql-plane and still requires control-plane denial, read-back proof, and read-only restoration.');
-    const launchLb = lb.status === 'present' ? { ...lb, status: 'configured' } : lb;
-    const zellijVisiblePaneSetting = readOption(cleanArgs, '--zellij-visible-panes', process.env.SKS_ZELLIJ_VISIBLE_PANES || process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || '8');
-    const zellijViewportSetting = readOption(cleanArgs, '--zellij-viewports', process.env.SKS_ZELLIJ_VIEWPORTS || '4');
-    const zellijRefreshMsSetting = readOption(cleanArgs, '--zellij-refresh-ms', process.env.SKS_ZELLIJ_REFRESH_MS || '1000');
-    const madSksEnv = {
-        SKS_PROTECTED_CORE_POLICY: madLaunch.gate.protected_core_policy,
-        SKS_MAD_SKS_TARGET_ROOT: madLaunch.gate.cwd,
-        SKS_MAD_SKS_PROTECTED_CORE_DIGEST: madLaunch.gate.protected_core_digest,
-        SKS_ZELLIJ_VISIBLE_PANES: String(zellijVisiblePaneSetting),
-        SKS_ZELLIJ_VIEWPORTS: String(Math.max(0, Math.min(Number(zellijViewportSetting || 4), 6))),
-        SKS_ZELLIJ_REFRESH_MS: String(zellijRefreshMsSetting),
-    };
-    const explicitWorkspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', null));
-    const launchProfile = glmRuntime?.profile || profile;
-    const launchOpts = glmRuntime
-        ? buildGlmMadLaunchOpts(cleanArgs, {
-            codexArgs: launchProfile.launch_args,
-            conciseBlockers: true,
-            madSksEnv,
-            launchEnv: madSksEnv,
-            codexBin: glmRuntime.wrapper.wrapper_path,
-            explicitWorkspace
-        })
-        : codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: launchProfile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv });
-    // Only the auto-derived stable `sks-mad-<cwd>` name accumulates panes across
-    // runs; when the user names a session explicitly (or codex-lb already minted a
-    // fresh unique session) respect it and skip the reset.
-    const autoDerivedMadSession = !explicitWorkspace && !launchOpts.session;
-    const workspace = explicitWorkspace || launchOpts.session || `sks-mad-${sanitizeZellijSessionName(process.cwd())}`;
-    const launch = headlessZellij
-        ? await writeMadHeadlessZellijFallback(madLaunch, workspace)
-        : await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), slotCount: 0, freshSession: autoDerivedMadSession, requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
-    const afterLaunchUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-launch-${uiSnapshotId}`).catch(() => null) : null;
-    const launchUiDiff = beforeUi && afterLaunchUi ? diffCodexAppUiSnapshots(beforeUi, afterLaunchUi) : null;
-    if (launchUiDiff) {
-        await writeJsonAtomic(path.join(madLaunch.dir, 'codex-app-ui-diff.json'), launchUiDiff);
-        if (!launchUiDiff.ok) {
-            console.error('SKS MAD launch changed Codex App UI state. Run `sks doctor --fix`.');
+    const launchLifecycleTasks = [...(madLaunch.lifecycle_tasks || [])];
+    try {
+        const glmRuntime = glmMadLaunch ? await prepareMadGlmLaunchRuntime(madLaunch, { ...deps, glmArgs: deps?.glmArgs || rawArgs }) : null;
+        if (glmMadLaunch && !glmRuntime?.ok) {
             process.exitCode = 1;
-            return launchUiDiff;
+            return glmRuntime;
         }
-    }
-    if (!launch.ok) {
-        console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
-        return launch;
-    }
-    await writeJsonAtomic(path.join(madLaunch.dir, 'zellij-initial-ui.json'), {
-        schema: 'sks.zellij-initial-ui.v1',
-        ok: true,
-        mission_id: madLaunch.mission_id,
-        session_name: launch.session_name || null,
-        live_panes: !headlessZellij,
-        initial_panes: 'orchestrator-monitor-viewports',
-        dashboard_created: true,
-        worker_panes_created: 0,
-        viewport_panes_created: Number(madSksEnv.SKS_ZELLIJ_VIEWPORTS),
-        ui_architecture: 'monitor_plus_viewports',
-        right_column_mode: 'monitor-plus-viewports'
-    });
-    const madNativeSwarmPromise = startMadNativeSwarm(madLaunch.root, madLaunch, args, launchProfile, {
-        env: {
-            ...madSksEnv,
-            ...(launch.session_name ? { SKS_ZELLIJ_SESSION_NAME: launch.session_name } : {})
-        },
-        glmLaunch: glmRuntime ? { provider: glmRuntime.profile.provider, model: glmRuntime.profile.model } : null,
-        zellijSessionName: launch.session_name || null,
-        workerPlacement: headlessZellij ? 'process' : shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
-        zellijVisiblePaneCap: Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || zellijVisiblePaneSetting || 8)
-    }).catch((err) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.native_swarm_background_failed', error: err?.message || String(err) }));
-    void madNativeSwarmPromise;
-    // The launcher only creates a detached background session. In an interactive
-    // terminal, immediately attach so the session actually opens for the user
-    // instead of leaving them to copy/paste the attach command by hand.
-    if (!headlessZellij && shouldAutoAttachZellij(args)) {
-        console.log(`Opening Zellij session: ${launch.session_name} (detach with Ctrl+q, re-attach later with: ${launch.attach_command_with_env})`);
-        const attached = attachZellijSessionInteractive(launch.session_name, { cwd: process.cwd(), configPath: launch.clipboard_config_path });
-        if (!attached.ok) {
-            console.log(`Could not open the Zellij session automatically${attached.error ? ` (${attached.error})` : ''}.`);
-            if (launch.attach_command_with_env)
-                console.log(`Attach with: ${launch.attach_command_with_env}`);
+        if (madDbGrant.requested) {
+            const grantReport = {
+                schema: 'sks.mad-sks-launch-grants.v2',
+                generated_at: nowIso(),
+                mission_id: madLaunch.mission_id,
+                mad_sks_active: true,
+                mad_db_active: false,
+                mad_db_default_grant: false,
+                mad_db_grant_source: madDbGrant.source,
+                mad_db_requires_first_class_route: true,
+                mad_db_cli: 'sks mad-db run|exec|apply-migration',
+                mad_db_capability_file: null,
+                standalone_mad_db_enable_still_requires_ack: true
+            };
+            await writeJsonAtomic(path.join(madLaunch.dir, 'mad-sks-launch-grants.json'), grantReport);
+            await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_db.first_class_route_required', grant_source: madDbGrant.source, cli: grantReport.mad_db_cli });
+        }
+        const updateNotice = {
+            schema: 'sks.update-notice.v1',
+            checked_at: nowIso(),
+            package_name: deps.packageName || 'sneakoscope',
+            current_version: deps.packageVersion || PACKAGE_VERSION,
+            latest_version: null,
+            update_available: false,
+            source: 'deferred_background',
+            cache_ttl_ms: 0,
+            message: 'SKS update notice refresh deferred until after MAD UI launch.'
+        };
+        const updateNoticePromise = checkSksUpdateNotice({
+            packageName: deps.packageName || 'sneakoscope',
+            currentVersion: deps.packageVersion || PACKAGE_VERSION,
+            missionDir: madLaunch.dir
+        }).then((notice) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_refreshed_background', non_blocking: true, update_available: notice.update_available === true, source: notice.source })).catch((err) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_background_failed', error: err?.message || String(err) }));
+        launchLifecycleTasks.push(updateNoticePromise);
+        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_checked', non_blocking: true, update_available: updateNotice.update_available === true, source: updateNotice.source });
+        console.log(`SKS MAD ready: ${glmRuntime?.profile?.profile_name || madHighProfileName()} | gate ${madLaunch.mission_id}`);
+        if (glmRuntime?.profile)
+            console.log(`GLM MAD launch active: ${glmRuntime.profile.model} via OpenRouter; GPT fallback blocked.`);
+        if (madDbGrant.requested)
+            console.log('MAD-DB flag observed; deprecated route now redirects to MAD-SKS SQL-plane: sks mad-sks sql|apply-migration.');
+        if (updateNotice.update_available === true)
+            console.log(`SKS update notice: ${updateNotice.latest_version} available (non-blocking).`);
+        console.log('Scoped high-power maintenance authority active; add explicit --allow-* flags for packages, services, network, browser/Computer Use, generated assets, file permissions, or system/admin scopes. SQL-plane execution is available through MAD-SKS sql-plane and still requires control-plane denial, read-back proof, and read-only restoration.');
+        const launchLb = lb.status === 'present' ? { ...lb, status: 'configured' } : lb;
+        const zellijVisiblePaneSetting = readOption(cleanArgs, '--zellij-visible-panes', process.env.SKS_ZELLIJ_VISIBLE_PANES || process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || '8');
+        const zellijViewportSetting = readOption(cleanArgs, '--zellij-viewports', process.env.SKS_ZELLIJ_VIEWPORTS || '1');
+        const zellijRefreshMsSetting = readOption(cleanArgs, '--zellij-refresh-ms', process.env.SKS_ZELLIJ_REFRESH_MS || '1000');
+        const madSksEnv = {
+            SKS_PROTECTED_CORE_POLICY: madLaunch.gate.protected_core_policy,
+            SKS_MAD_SKS_TARGET_ROOT: madLaunch.gate.cwd,
+            SKS_MAD_SKS_PROTECTED_CORE_DIGEST: madLaunch.gate.protected_core_digest,
+            [SKS_ZELLIJ_HOST_MISSION_ENV]: madLaunch.mission_id,
+            SKS_ZELLIJ_VISIBLE_PANES: String(zellijVisiblePaneSetting),
+            SKS_ZELLIJ_VIEWPORTS: String(Math.max(0, Math.min(Number(zellijViewportSetting || 1), 3))),
+            SKS_ZELLIJ_REFRESH_MS: String(zellijRefreshMsSetting),
+        };
+        const explicitWorkspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', null));
+        const launchProfile = glmRuntime?.profile || profile;
+        const launchOpts = glmRuntime
+            ? buildGlmMadLaunchOpts(cleanArgs, {
+                codexArgs: launchProfile.launch_args,
+                conciseBlockers: true,
+                madSksEnv,
+                launchEnv: madSksEnv,
+                recoveryAllowUnverified: allowUnverifiedToolOutputRecovery,
+                codexBin: glmRuntime.wrapper.wrapper_path,
+                explicitWorkspace
+            })
+            : codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: launchProfile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv, recoveryAllowUnverified: allowUnverifiedToolOutputRecovery });
+        // Only the auto-derived stable `sks-mad-<cwd>` name accumulates panes across
+        // runs; when the user names a session explicitly (or codex-lb already minted a
+        // fresh unique session) respect it and skip the reset.
+        const autoDerivedMadSession = !explicitWorkspace && !launchOpts.session;
+        const workspace = explicitWorkspace || launchOpts.session || `sks-mad-${sanitizeZellijSessionName(process.cwd())}`;
+        const launch = headlessZellij
+            ? await writeMadHeadlessZellijFallback(madLaunch, workspace)
+            : await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), slotCount: 0, freshSession: autoDerivedMadSession, requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
+        const afterLaunchUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-launch-${uiSnapshotId}`).catch(() => null) : null;
+        const launchUiDiff = beforeUi && afterLaunchUi ? diffCodexAppUiSnapshots(beforeUi, afterLaunchUi) : null;
+        if (launchUiDiff) {
+            await writeJsonAtomic(path.join(madLaunch.dir, 'codex-app-ui-diff.json'), launchUiDiff);
+            if (!launchUiDiff.ok) {
+                console.error('SKS MAD launch changed Codex App UI state. Run `sks doctor --fix`.');
+                process.exitCode = 1;
+                return launchUiDiff;
+            }
+        }
+        if (!launch.ok) {
+            console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
+            return launch;
+        }
+        await writeJsonAtomic(path.join(madLaunch.dir, 'zellij-initial-ui.json'), {
+            schema: 'sks.zellij-initial-ui.v1',
+            ok: true,
+            mission_id: madLaunch.mission_id,
+            session_name: launch.session_name || null,
+            live_panes: !headlessZellij,
+            initial_panes: 'orchestrator-monitor-viewports',
+            dashboard_created: true,
+            worker_panes_created: 0,
+            viewport_panes_created: Number(madSksEnv.SKS_ZELLIJ_VIEWPORTS),
+            ui_architecture: 'monitor_plus_viewports',
+            right_column_mode: 'monitor-plus-viewports'
+        });
+        const madNativeSwarmPromise = startMadNativeSwarm(madLaunch.root, madLaunch, args, launchProfile, {
+            env: {
+                ...madSksEnv,
+                ...(launch.session_name ? { SKS_ZELLIJ_SESSION_NAME: launch.session_name } : {})
+            },
+            glmLaunch: glmRuntime ? { provider: glmRuntime.profile.provider, model: glmRuntime.profile.model } : null,
+            zellijSessionName: launch.session_name || null,
+            workerPlacement: headlessZellij ? 'process' : shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
+            zellijVisiblePaneCap: Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || zellijVisiblePaneSetting || 8)
+        }).catch((err) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.native_swarm_background_failed', error: err?.message || String(err) }));
+        launchLifecycleTasks.push(madNativeSwarmPromise);
+        // The launcher only creates a detached background session. In an interactive
+        // terminal, immediately attach so the session actually opens for the user
+        // instead of leaving them to copy/paste the attach command by hand.
+        if (!headlessZellij && shouldAutoAttachZellij(args)) {
+            console.log(`Opening Zellij session: ${launch.session_name} (detach with Ctrl+q, re-attach later with: ${launch.attach_command_with_env})`);
+            const attached = attachZellijSessionInteractive(launch.session_name, { cwd: process.cwd(), configPath: launch.clipboard_config_path });
+            if (!attached.ok) {
+                console.log(`Could not open the Zellij session automatically${attached.error ? ` (${attached.error})` : ''}.`);
+                if (launch.attach_command_with_env)
+                    console.log(`Attach with: ${launch.attach_command_with_env}`);
+            }
+            return launch;
         }
+        if (launch.attach_command_with_env)
+            console.log(`Attach with: ${launch.attach_command_with_env}`);
+        if (headlessZellij)
+            console.log('MAD launch running headless: live_panes=false.');
         return launch;
     }
-    if (launch.attach_command_with_env)
-        console.log(`Attach with: ${launch.attach_command_with_env}`);
-    if (headlessZellij)
-        console.log('MAD launch running headless: live_panes=false.');
-    return launch;
+    finally {
+        await settleMadLaunchLifecycle(launchLifecycleTasks, madLaunch.dir);
+    }
+}
+export async function settleMadLaunchLifecycle(tasks, dir) {
+    if (tasks.length === 0)
+        return;
+    const settled = await Promise.allSettled(tasks);
+    await appendJsonlBounded(path.join(dir, 'events.jsonl'), {
+        ts: nowIso(),
+        type: 'mad_sks.launch_lifecycle_settled',
+        task_count: settled.length,
+        fulfilled_count: settled.filter((row) => row.status === 'fulfilled').length,
+        rejected_count: settled.filter((row) => row.status === 'rejected').length
+    }).catch(() => undefined);
 }
 function isMadGlmLaunch(args = [], deps = {}) {
     const list = (args || []).map((arg) => String(arg));
@@ -592,18 +624,26 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
 }
 export function resolveMadNativeSwarmOptions(args = [], profile = {}, opts = {}) {
     const list = (args || []).map((arg) => String(arg));
+    const operatorEnabled = list.includes('--mad-native-swarm')
+        || list.includes('--mad-swarm')
+        || list.includes('--mad-agents')
+        || list.includes('--mad-swarm-agents')
+        || list.includes('--mad-swarm-prompt')
+        || process.env.SKS_MAD_NATIVE_SWARM === '1';
     const operatorDisabled = list.includes('--no-swarm') || list.includes('--no-mad-swarm') || process.env.SKS_MAD_NATIVE_SWARM === '0';
     const glmRequested = list.includes('--glm') || opts.glmLaunch?.provider === 'openrouter';
     const glmNativeSwarmDisabled = glmRequested && process.env.SKS_GLM_MAD_ALLOW_GPT_SWARM !== '1';
-    const disabled = operatorDisabled || glmNativeSwarmDisabled;
-    const agents = clampInt(readOption(list, '--mad-agents', readOption(list, '--mad-swarm-agents', process.env.SKS_MAD_SWARM_AGENTS || opts.agents || 5)), 1, 20);
+    const disabled = !operatorEnabled || operatorDisabled || glmNativeSwarmDisabled;
+    const agents = clampInt(readOption(list, '--mad-agents', readOption(list, '--mad-swarm-agents', process.env.SKS_MAD_SWARM_AGENTS || opts.agents || 1)), 1, 20);
     const workItems = clampInt(readOption(list, '--mad-swarm-work-items', process.env.SKS_MAD_SWARM_WORK_ITEMS || opts.workItems || agents), agents, 100);
     const backend = defaultMadSwarmBackend(list, opts);
     return {
         enabled: !disabled,
         disabled_reason: operatorDisabled
             ? 'operator_disabled_mad_native_swarm'
-            : glmNativeSwarmDisabled ? 'glm_mad_native_swarm_disabled_to_block_gpt_fallback' : null,
+            : !operatorEnabled
+                ? 'official_subagent_runtime_default'
+                : glmNativeSwarmDisabled ? 'glm_mad_native_swarm_disabled_to_block_gpt_fallback' : null,
         agents,
         workItems,
         backend,
@@ -691,7 +731,6 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const has = (scope) => allowedScopes.has(scope);
     const dbWriteAllowed = has('db_write');
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: `${activatedBy} Zellij scoped high-power maintenance session` });
-    void refreshMadNativeLaunchArtifacts(root, id, dir).catch((err) => appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.native_artifact_background_failed', error: err?.message || String(err) }));
     const protectedCore = resolveProtectedCore({ packageRoot: packageRoot(), targetRoot: cwd });
     // The interactive launch 'before' snapshot is only persisted (env + policy json)
     // and is never compared against an 'after' snapshot during the session, so the
@@ -782,7 +821,9 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
         stop_gate: 'mad-sks-gate.json',
         prompt: gate.activated_by
     });
-    return { mission_id: id, dir, gate, root };
+    const nativeArtifactsPromise = refreshMadNativeLaunchArtifacts(root, id, dir)
+        .catch((err) => appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.native_artifact_background_failed', error: err?.message || String(err) }));
+    return { mission_id: id, dir, gate, root, lifecycle_tasks: [nativeArtifactsPromise] };
 }
 async function refreshMadNativeLaunchArtifacts(root, missionId, dir) {
     await writeCodex0138CapabilityArtifacts(root, { missionId }).catch(() => null);
@@ -832,6 +873,8 @@ function baseMadLaunchOnlyFlags() {
         '--confirm-destructive-delete',
         '--no-swarm',
         '--no-mad-swarm',
+        '--mad-native-swarm',
+        '--mad-swarm',
         '--mad-agents',
         '--mad-swarm-agents',
         '--mad-swarm-work-items',
@@ -844,7 +887,8 @@ function baseMadLaunchOnlyFlags() {
         '-y',
         '--dry-run',
         '--plan-only',
-        '--ack'
+        '--ack',
+        CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_FLAG
     ]);
 }
 function glmMadLaunchOnlyFlags() {
@@ -873,6 +917,7 @@ function madLaunchValueFlags(includeGlmFlags = false) {
         '--mad-swarm-backend',
         '--mad-swarm-prompt',
         '--zellij-visible-panes',
+        '--zellij-viewports',
         '--zellij-refresh-ms',
         '--ack'
     ]);