sneakoscope 3.1.3 → 3.1.4

package/dist/core/zellij/zellij-self-heal.js

@@ -0,0 +1,353 @@
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { guardContextForRoute, guardedPackageInstall } from '../safety/mutation-guard.js';
+import { mutationLedgerPath } from '../safety/mutation-ledger.js';
+import { checkZellijCapability, ZELLIJ_MIN_VERSION } from './zellij-capability.js';
+import { compareVersionLike } from './zellij-command.js';
+import { askHomebrewInstallAllowed, HOMEBREW_INSTALL_COMMAND, resolveHomebrewInstallPolicy } from './homebrew-policy.js';
+export async function repairZellijForSks(input) {
+    const root = path.resolve(input.root || process.cwd());
+    const env = input.env || process.env;
+    const autoApproved = input.autoApprove === true;
+    const beforeReport = await capabilitySnapshot(root, env, 'before');
+    const before = compactCapability(beforeReport);
+    const latest = await latestZellijVersion(env);
+    const brew = await findBrew(env);
+    const stale = Boolean(before.version && latest && compareVersionLike(latest, before.version) > 0);
+    const needsRepair = before.status === 'missing' || before.status === 'too_old' || stale;
+    const mutationArtifact = mutationLedgerPath(root);
+    if (!needsRepair) {
+        return persistSelfHeal(root, input.missionDir, {
+            schema: 'sks.zellij-self-heal.v1',
+            ok: true,
+            requested_by: input.requestedBy,
+            fix_requested: input.fixRequested === true,
+            auto_approved: autoApproved,
+            install_homebrew_allowed: false,
+            before,
+            latest_version: latest,
+            strategy: 'none-current',
+            command: null,
+            after: before,
+            mutation_guard_artifact: null,
+            homebrew: { present: brew.present, bin: brew.bin, install_attempted: false, install_allowed: false },
+            blockers: [],
+            warnings: beforeReport.warnings || []
+        });
+    }
+    if (input.fixRequested !== true) {
+        return manualResult(root, input, env, before, latest, brew, 'fix_not_requested');
+    }
+    if (!autoApproved && input.interactive !== true) {
+        return input.allowHeadlessFallback === true
+            ? headlessResult(root, input, before, latest, brew, 'noninteractive_without_auto_approval')
+            : manualResult(root, input, env, before, latest, brew, 'noninteractive_without_auto_approval');
+    }
+    if (!autoApproved && input.interactive === true) {
+        const accepted = await askZellijRepairAllowed(before.status === 'missing'
+            ? 'Zellij is missing. Install it with Homebrew now? [Y/n] '
+            : `Zellij ${before.version || 'unknown'} needs repair. Upgrade with Homebrew now? [Y/n] `);
+        if (!accepted)
+            return manualResult(root, input, env, before, latest, brew, 'operator_declined_zellij_repair');
+    }
+    let brewBin = brew.bin;
+    let homebrewInstallAttempted = false;
+    let homebrewInstallAllowed = false;
+    if (!brew.present) {
+        const interactiveAccepted = input.interactive === true && !autoApproved
+            ? await askHomebrewInstallAllowed()
+            : false;
+        const policy = resolveHomebrewInstallPolicy({
+            env,
+            installHomebrew: input.installHomebrew === true,
+            autoApprove: autoApproved,
+            interactiveAccepted
+        });
+        homebrewInstallAllowed = policy.allowed;
+        if (!policy.allowed) {
+            return input.allowHeadlessFallback === true
+                ? headlessResult(root, input, before, latest, brew, policy.blockers[0] || 'homebrew_missing')
+                : manualResult(root, input, env, before, latest, brew, policy.blockers[0] || 'homebrew_missing');
+        }
+        homebrewInstallAttempted = true;
+        const homebrewRun = await runHomebrewInstall(root, env);
+        if (homebrewRun.code !== 0) {
+            return persistSelfHeal(root, input.missionDir, {
+                schema: 'sks.zellij-self-heal.v1',
+                ok: false,
+                requested_by: input.requestedBy,
+                fix_requested: true,
+                auto_approved: autoApproved,
+                install_homebrew_allowed: true,
+                before,
+                latest_version: latest,
+                strategy: 'failed',
+                command: HOMEBREW_INSTALL_COMMAND,
+                after: before,
+                mutation_guard_artifact: mutationArtifact,
+                homebrew: { present: false, bin: null, install_attempted: true, install_allowed: true },
+                blockers: [`homebrew_install_failed:${tail(homebrewRun.stderr || homebrewRun.stdout || 'unknown')}`],
+                warnings: []
+            });
+        }
+        const afterBrew = await findBrew(env);
+        brewBin = afterBrew.bin || brew.bin || 'brew';
+    }
+    if (!brewBin) {
+        return manualResult(root, input, env, before, latest, brew, 'homebrew_missing');
+    }
+    const install = before.status === 'missing';
+    const brewArgs = install ? ['install', 'zellij'] : ['upgrade', 'zellij'];
+    const strategy = !brew.present && homebrewInstallAttempted ? 'brew-install-homebrew-then-zellij'
+        : install ? 'brew-install-zellij'
+            : 'brew-upgrade-zellij';
+    const command = `brew ${brewArgs.join(' ')}`;
+    const run = await runZellijBrew(root, env, brewBin, brewArgs, command);
+    if (run.code !== 0 && /already installed|already up-to-date/i.test(`${run.stdout}\n${run.stderr}`)) {
+        const after = await capabilitySnapshot(root, env, 'after-noop');
+        return persistSelfHeal(root, input.missionDir, {
+            schema: 'sks.zellij-self-heal.v1',
+            ok: true,
+            requested_by: input.requestedBy,
+            fix_requested: true,
+            auto_approved: autoApproved,
+            install_homebrew_allowed: homebrewInstallAllowed,
+            before,
+            latest_version: latest,
+            strategy: 'none-current',
+            command,
+            after: compactCapability(after, latest || before.version),
+            mutation_guard_artifact: mutationArtifact,
+            homebrew: { present: true, bin: brewBin, install_attempted: homebrewInstallAttempted, install_allowed: homebrewInstallAllowed },
+            blockers: [],
+            warnings: ['brew_reported_already_current']
+        });
+    }
+    if (run.code !== 0) {
+        return persistSelfHeal(root, input.missionDir, {
+            schema: 'sks.zellij-self-heal.v1',
+            ok: false,
+            requested_by: input.requestedBy,
+            fix_requested: true,
+            auto_approved: autoApproved,
+            install_homebrew_allowed: homebrewInstallAllowed,
+            before,
+            latest_version: latest,
+            strategy: 'failed',
+            command,
+            after: before,
+            mutation_guard_artifact: mutationArtifact,
+            homebrew: { present: true, bin: brewBin, install_attempted: homebrewInstallAttempted, install_allowed: homebrewInstallAllowed },
+            blockers: [`zellij_brew_repair_failed:${tail(run.stderr || run.stdout || 'unknown')}`],
+            warnings: []
+        });
+    }
+    const afterReport = await capabilitySnapshot(root, env, 'after', latest || env.SKS_ZELLIJ_SELF_HEAL_AFTER_VERSION || '0.44.0');
+    const after = compactCapability(afterReport, latest || before.version || '0.44.0');
+    const ok = after.status === 'ok';
+    return persistSelfHeal(root, input.missionDir, {
+        schema: 'sks.zellij-self-heal.v1',
+        ok,
+        requested_by: input.requestedBy,
+        fix_requested: true,
+        auto_approved: autoApproved,
+        install_homebrew_allowed: homebrewInstallAllowed,
+        before,
+        latest_version: latest,
+        strategy,
+        command,
+        after,
+        mutation_guard_artifact: mutationArtifact,
+        homebrew: { present: true, bin: brewBin, install_attempted: homebrewInstallAttempted, install_allowed: homebrewInstallAllowed },
+        blockers: ok ? [] : ['zellij_repair_completed_but_capability_not_ok'],
+        warnings: []
+    });
+}
+async function capabilitySnapshot(root, env, phase, fallbackVersion) {
+    const fakeStatus = phase === 'before' ? env.SKS_ZELLIJ_SELF_HEAL_BEFORE_STATUS : env.SKS_ZELLIJ_SELF_HEAL_AFTER_STATUS;
+    if (fakeStatus) {
+        const version = phase === 'before'
+            ? (env.SKS_ZELLIJ_SELF_HEAL_BEFORE_VERSION || (fakeStatus === 'missing' ? null : '0.40.0'))
+            : (env.SKS_ZELLIJ_SELF_HEAL_AFTER_VERSION || fallbackVersion || '0.44.0');
+        return fakeCapability(String(fakeStatus), version);
+    }
+    return checkZellijCapability({ root, require: false, writeReport: false, env }).catch((err) => ({
+        schema: 'sks.zellij-capability.v1',
+        generated_at: nowIso(),
+        ok: false,
+        status: 'blocked',
+        integration_optional: true,
+        require_zellij: false,
+        min_version: ZELLIJ_MIN_VERSION,
+        version: null,
+        bin: null,
+        command: ['zellij', '--version'],
+        docs_evidence: [],
+        blockers: [`zellij_capability_check_failed:${tail(err?.message || String(err))}`],
+        warnings: [],
+        operator_actions: ['Resolve the Zellij capability check failure, then rerun `sks doctor --fix --yes`.']
+    }));
+}
+function fakeCapability(status, version) {
+    const normalized = status === 'ok' || status === 'missing' || status === 'too_old' || status === 'blocked' ? status : 'blocked';
+    return {
+        schema: 'sks.zellij-capability.v1',
+        generated_at: nowIso(),
+        ok: normalized === 'ok',
+        status: normalized,
+        integration_optional: true,
+        require_zellij: false,
+        min_version: ZELLIJ_MIN_VERSION,
+        version,
+        bin: 'zellij',
+        command: ['zellij', '--version'],
+        docs_evidence: [],
+        blockers: normalized === 'ok' ? [] : [`zellij_${normalized}`],
+        warnings: normalized === 'ok' ? [] : [`zellij_${normalized}_fixture`],
+        operator_actions: normalized === 'ok' ? [] : ['Install Zellij. On macOS: `brew install zellij`.']
+    };
+}
+function compactCapability(report, fallbackVersion) {
+    return {
+        status: report.status,
+        version: report.version || fallbackVersion || null,
+        bin: report.status === 'missing' ? null : report.bin || 'zellij'
+    };
+}
+async function latestZellijVersion(env) {
+    if (env.SKS_ZELLIJ_LATEST_VERSION)
+        return String(env.SKS_ZELLIJ_LATEST_VERSION).replace(/^v(?=\d)/, '');
+    const mod = await import('./zellij-update.js').catch(() => null);
+    if (!mod?.fetchLatestZellijVersion)
+        return null;
+    const result = await mod.fetchLatestZellijVersion({ env, timeoutMs: 1500 }).catch(() => null);
+    return result?.version || null;
+}
+async function findBrew(env) {
+    if (env.SKS_ZELLIJ_SELF_HEAL_BREW_PRESENT === '0')
+        return { present: false, bin: null };
+    if (env.SKS_FAKE_BREW_BIN)
+        return { present: true, bin: String(env.SKS_FAKE_BREW_BIN) };
+    for (const dir of String(env.PATH || process.env.PATH || '').split(path.delimiter).filter(Boolean)) {
+        const candidate = path.join(dir, process.platform === 'win32' ? 'brew.cmd' : 'brew');
+        try {
+            await fs.access(candidate);
+            return { present: true, bin: candidate };
+        }
+        catch { }
+    }
+    if (env.SKS_ZELLIJ_SELF_HEAL_BREW_PRESENT === '1')
+        return { present: true, bin: 'brew' };
+    return { present: false, bin: null };
+}
+async function runZellijBrew(root, env, brewBin, args, command) {
+    if (env.SKS_ZELLIJ_SELF_HEAL_FAKE_RUN === '1') {
+        await appendFakeBrewLog(env, args);
+        return { code: Number(env.SKS_ZELLIJ_SELF_HEAL_FAKE_RUN_CODE || 0), stdout: 'fake brew ok', stderr: '' };
+    }
+    const contract = createRequestedScopeContract({
+        route: 'zellij-self-heal',
+        userRequest: command,
+        projectRoot: root,
+        overrides: { package_install: true, zellij_install: true }
+    });
+    return guardedPackageInstall(guardContextForRoute(root, contract, command), 'zellij', {
+        confirmed: true,
+        command: brewBin,
+        args,
+        env,
+        timeoutMs: 180000,
+        maxOutputBytes: 256 * 1024
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+}
+async function runHomebrewInstall(root, env) {
+    if (env.SKS_ZELLIJ_SELF_HEAL_FAKE_RUN === '1') {
+        await appendFakeBrewLog(env, ['install-homebrew']);
+        return { code: Number(env.SKS_ZELLIJ_SELF_HEAL_FAKE_HOMEBREW_CODE || 0), stdout: 'fake homebrew install ok', stderr: '' };
+    }
+    const contract = createRequestedScopeContract({
+        route: 'zellij-self-heal',
+        userRequest: HOMEBREW_INSTALL_COMMAND,
+        projectRoot: root,
+        overrides: { package_install: true, zellij_install: true }
+    });
+    return guardedPackageInstall(guardContextForRoute(root, contract, HOMEBREW_INSTALL_COMMAND), 'homebrew', {
+        confirmed: true,
+        command: '/bin/bash',
+        args: ['-c', 'curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh | /bin/bash'],
+        env,
+        timeoutMs: 600000,
+        maxOutputBytes: 256 * 1024
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+}
+async function appendFakeBrewLog(env, args) {
+    if (!env.SKS_FAKE_BREW_LOG)
+        return;
+    await ensureDir(path.dirname(env.SKS_FAKE_BREW_LOG));
+    await fs.appendFile(env.SKS_FAKE_BREW_LOG, `${args.join(' ')}\n`, 'utf8');
+}
+async function manualResult(root, input, env, before, latest, brew, reason) {
+    const command = brew.present ? 'sks doctor --fix --yes' : 'sks doctor --fix --install-homebrew --yes';
+    return persistSelfHeal(root, input.missionDir, {
+        schema: 'sks.zellij-self-heal.v1',
+        ok: false,
+        requested_by: input.requestedBy,
+        fix_requested: input.fixRequested === true,
+        auto_approved: input.autoApprove === true,
+        install_homebrew_allowed: false,
+        before,
+        latest_version: latest,
+        strategy: 'manual-required',
+        command,
+        after: before,
+        mutation_guard_artifact: null,
+        homebrew: { present: brew.present, bin: brew.bin, install_attempted: false, install_allowed: false },
+        blockers: [reason],
+        warnings: []
+    });
+}
+async function headlessResult(root, input, before, latest, brew, reason) {
+    return persistSelfHeal(root, input.missionDir, {
+        schema: 'sks.zellij-self-heal.v1',
+        ok: true,
+        requested_by: input.requestedBy,
+        fix_requested: input.fixRequested === true,
+        auto_approved: input.autoApprove === true,
+        install_homebrew_allowed: false,
+        before,
+        latest_version: latest,
+        strategy: 'headless-fallback',
+        command: 'sks --mad --headless',
+        after: before,
+        mutation_guard_artifact: null,
+        homebrew: { present: brew.present, bin: brew.bin, install_attempted: false, install_allowed: false },
+        blockers: [],
+        warnings: [reason, 'live_panes=false']
+    });
+}
+async function persistSelfHeal(root, missionDir, result) {
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'zellij-self-heal.json'), result).catch(() => undefined);
+    if (missionDir)
+        await writeJsonAtomic(path.join(missionDir, 'zellij-self-heal.json'), result).catch(() => undefined);
+    return result;
+}
+async function askZellijRepairAllowed(question) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        return false;
+    const rl = (await import('node:readline')).createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => rl.question(question, resolve));
+        const trimmed = String(answer || '').trim();
+        return trimmed === '' || /^(y|yes|예|네|응)$/i.test(trimmed);
+    }
+    finally {
+        rl.close();
+    }
+}
+function tail(value, limit = 1000) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(-limit);
+}
+//# sourceMappingURL=zellij-self-heal.js.map

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

@@ -80,7 +80,7 @@ export async function checkZellijUpdateNotice(input = {}) {
             message: 'Zellij update notice disabled by environment.'
         });
     }
-    const capability = await checkZellijCapability({ require: false, writeReport: false }).catch(() => null);
+    const capability = await checkZellijCapability({ require: false, writeReport: false, env }).catch(() => null);
     const current = capability?.version || null;
     const missing = capability?.status === 'missing' || !capability;
     const fetchInput = { env };
@@ -117,7 +117,7 @@ export async function checkZellijUpdateNotice(input = {}) {
  * the exact operator command, mirroring how the Codex CLI update flow behaves.
  */
 export async function upgradeZellijToLatest(input = {}) {
-    const before = await checkZellijCapability({ require: false, writeReport: false }).catch(() => null);
+    const before = await checkZellijCapability({ require: false, writeReport: false, env: input.env || process.env }).catch(() => null);
     const beforeVersion = before?.version || null;
     const missing = before?.status === 'missing' || !before;
     const latest = await fetchLatestZellijVersion({ env: input.env || process.env });
@@ -185,7 +185,7 @@ export async function upgradeZellijToLatest(input = {}) {
             error: `${run.stderr || run.stdout || 'brew upgrade failed'}`.trim().slice(-1000)
         };
     }
-    const after = await checkZellijCapability({ require: false, writeReport: false }).catch(() => null);
+    const after = await checkZellijCapability({ require: false, writeReport: false, env: input.env || process.env }).catch(() => null);
     return {
         status: missing ? 'installed' : 'upgraded',
         before_version: beforeVersion,
@@ -222,9 +222,34 @@ export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
     if (!notice)
         return { status: 'skipped', current: null, latest: null, command: null };
     if (notice.zellij_missing) {
-        // Zellij is an optional integration; installation is owned by
-        // `sks deps check --yes` / `sks zellij update --yes`. Just surface the hint.
-        console.log(`Zellij not found (optional live panes disabled). Install with: ${notice.upgrade_command}`);
+        if (opts.selfHealOnMissing === true) {
+            const { repairZellijForSks } = await import('./zellij-self-heal.js');
+            const repaired = await repairZellijForSks({
+                root: opts.root || process.cwd(),
+                requestedBy: opts.label === 'MAD launch' ? 'sks --mad' : 'sks zellij update',
+                fixRequested: true,
+                autoApprove: opts.autoApprove === true || list.includes('--yes') || list.includes('-y'),
+                interactive: mode === 'interactive-prompt',
+                installHomebrew: opts.installHomebrew === true || list.includes('--install-homebrew'),
+                allowHeadlessFallback: opts.allowHeadlessFallback === true,
+                missionDir: opts.missionDir || null,
+                env
+            });
+            if (repaired.strategy === 'headless-fallback')
+                console.log('Zellij repair: headless fallback selected (live_panes=false).');
+            else if (repaired.ok && repaired.command)
+                console.log(`Zellij repair: ${repaired.strategy} via ${repaired.command}`);
+            else if (!repaired.ok)
+                console.log(`Zellij repair required. Run: ${repaired.command || notice.upgrade_command}`);
+            return {
+                status: repaired.ok ? (repaired.strategy === 'headless-fallback' ? 'missing' : 'installed') : 'manual_required',
+                current: repaired.after.version || repaired.before.version,
+                latest: repaired.latest_version,
+                command: repaired.command,
+                error: repaired.blockers[0] || null
+            };
+        }
+        console.log(`Zellij missing, required for sks --mad. Repairable with: sks doctor --fix --yes`);
         return { status: 'missing', current: null, latest: notice.latest_version, command: notice.upgrade_command };
     }
     if (!notice.update_available) {

package/dist/scripts/sks-3-1-4-directive-check-lib.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+export async function runDirective314Gate(id) {
+    if (id.startsWith('zellij:'))
+        return zellijGate(id);
+    if (id.startsWith('doctor:zellij'))
+        return doctorZellijGate(id);
+    if (id.startsWith('mad:zellij'))
+        return madZellijGate(id);
+    if (id === 'lazycodex:analysis')
+        return lazycodexAnalysisGate(id);
+    if (id.startsWith('codex-app:') || id === 'doctor:codex-app-harness')
+        return codexAppGate(id);
+    if (id.startsWith('loop:'))
+        return loopGate(id);
+    if (id === 'lazycodex:interop-policy' || id === 'lazycodex:pattern-adoption-blackbox')
+        return lazycodexInteropGate(id);
+    throw new Error(`unknown_gate:${id}`);
+}
+async function zellijGate(id) {
+    const rootDir = await tempRoot(`sks-${id.replace(/[:/]/g, '-')}-`);
+    const selfHeal = await importDist('core/zellij/zellij-self-heal.js');
+    const policy = await importDist('core/zellij/homebrew-policy.js');
+    if (id === 'zellij:homebrew-policy') {
+        assertGate(policy.resolveHomebrewInstallPolicy({ env: {} }).allowed === false, 'Homebrew install must not be silent by default');
+        assertGate(policy.resolveHomebrewInstallPolicy({ installHomebrew: true }).allowed === false, 'Homebrew install flag alone must still require --yes or interactive/env approval');
+        assertGate(policy.resolveHomebrewInstallPolicy({ installHomebrew: true, autoApprove: true }).allowed === true, 'Homebrew install should be allowed with explicit flag+yes');
+        assertGate(policy.homebrewMissingDoctorMessage().includes('sks doctor --fix --install-homebrew --yes'), 'Homebrew policy must expose one-shot doctor command');
+        return emitGate(id, { fixtures: 3 });
+    }
+    if (id === 'zellij:update-missing-self-heal') {
+        const update = await importDist('core/zellij/zellij-update.js');
+        const result = await update.maybePromptZellijUpdateForLaunch(['--yes'], {
+            label: 'MAD launch',
+            root: rootDir,
+            selfHealOnMissing: true,
+            autoApprove: true,
+            env: fakeZellijEnv('missing', { brew: true })
+        });
+        assertGate(result.status === 'installed', 'missing update path must self-heal when requested', result);
+        return emitGate(id, { status: result.status });
+    }
+    const result = await selfHeal.repairZellijForSks({
+        root: rootDir,
+        requestedBy: 'doctor --fix',
+        fixRequested: true,
+        autoApprove: true,
+        installHomebrew: false,
+        env: fakeZellijEnv('missing', { brew: true })
+    });
+    assertGate(result.ok === true, 'zellij self-heal must succeed with fake brew present', result);
+    assertGate(result.strategy === 'brew-install-zellij', 'missing zellij must select brew-install-zellij', result);
+    assertGate(fs.existsSync(path.join(rootDir, '.sneakoscope', 'reports', 'zellij-self-heal.json')), 'self-heal artifact missing');
+    emitGate(id, { strategy: result.strategy });
+}
+async function doctorZellijGate(id) {
+    const rootDir = await tempRoot(`sks-${id.replace(/[:/]/g, '-')}-`);
+    const mod = await importDist('core/doctor/doctor-zellij-repair.js');
+    const env = fakeZellijEnv(id.includes('upgrade') ? 'too_old' : 'missing', { brew: !id.includes('no-homebrew') });
+    const previous = swapEnv(env);
+    try {
+        const result = await mod.runDoctorZellijRepair({ root: rootDir, args: ['--fix', '--yes'], doctorFix: true });
+        if (id.includes('no-homebrew')) {
+            assertGate(result.strategy === 'manual-required', 'no-homebrew doctor repair must be manual-required', result);
+            assertGate(String(result.command).includes('--install-homebrew'), 'manual no-homebrew path must show install-homebrew command', result);
+        }
+        else if (id.includes('upgrade')) {
+            assertGate(result.strategy === 'brew-upgrade-zellij', 'stale zellij must upgrade', result);
+        }
+        else {
+            assertGate(result.strategy === 'brew-install-zellij', 'missing zellij must install', result);
+        }
+        if (id === 'doctor:zellij-fix-output') {
+            const line = mod.doctorZellijRepairConsoleLine(result);
+            assertGate(!/optional live panes disabled/i.test(line), 'doctor repair output must not use optional/blocking wording', { line });
+        }
+        emitGate(id, { strategy: result.strategy });
+    }
+    finally {
+        restoreEnv(previous);
+    }
+}
+async function madZellijGate(id) {
+    const source = fs.readFileSync(path.join(root, 'src/core/commands/mad-sks-command.ts'), 'utf8');
+    assertGate(source.includes("requestedBy: 'sks --mad'"), 'MAD must request zellij self-heal as sks --mad');
+    assertGate(source.includes('--headless') && source.includes('live_panes: false'), 'MAD must support headless live_panes=false');
+    assertGate(!/optional live panes disabled/.test(source), 'MAD source must not print optional live panes disabled');
+    if (id === 'mad:zellij-no-contradictory-output') {
+        const update = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-update.ts'), 'utf8');
+        assertGate(!/Zellij not found \(optional live panes disabled\)/.test(update), 'Zellij missing output must not be contradictory optional wording');
+    }
+    emitGate(id, { source_checked: true });
+}
+async function lazycodexAnalysisGate(id) {
+    const mod = await importDist('core/codex-app/lazycodex-analysis.js');
+    const report = await mod.writeLazyCodexPatternAnalysis(root);
+    assertGate(report.patterns.length >= 14, 'LazyCodex analysis must include required patterns', report);
+    const docs = mod.renderLazyCodexAnalysisMarkdown(report);
+    await fsp.writeFile(path.join(root, 'docs', 'lazycodex-analysis.md'), `${docs}\n`, 'utf8');
+    emitGate(id, { patterns: report.patterns.length });
+}
+async function codexAppGate(id) {
+    const rootDir = await tempRoot(`sks-${id.replace(/[:/]/g, '-')}-`);
+    const previous = swapEnv({
+        SKS_CODEX_0138_FAKE: '1',
+        SKS_CODEX_0139_FAKE: '1',
+        SKS_CODEX_PLUGIN_JSON_FAKE: '1',
+        SKS_CODEX_AGENT_TYPE_SUPPORTED: id.includes('blackbox') ? '1' : ''
+    });
+    try {
+        if (id === 'codex-app:harness-matrix' || id === 'doctor:codex-app-harness' || id === 'codex-app:harness-blackbox') {
+            const mod = await importDist('core/codex-app/codex-app-harness-matrix.js');
+            const matrix = await mod.buildCodexAppHarnessMatrix({ root: rootDir });
+            assertGate(matrix.schema === 'sks.codex-app-harness-matrix.v1', 'harness matrix schema mismatch', matrix);
+            assertGate(matrix.app_features.plugin_json === true, 'fixture should expose plugin_json', matrix);
+            if (id === 'doctor:codex-app-harness') {
+                const doctor = fs.readFileSync(path.join(root, 'src/commands/doctor.ts'), 'utf8');
+                assertGate(doctor.includes('Codex App Harness:'), 'doctor output must include Codex App Harness section');
+                assertGate(doctor.includes('codex_app_harness_matrix'), 'doctor JSON must include codex_app_harness_matrix');
+            }
+            return emitGate(id, { ok: matrix.ok, warnings: matrix.warnings.length });
+        }
+        if (id === 'codex-app:skill-sync' || id === 'codex-app:skill-agent-blackbox') {
+            const mod = await importDist('core/codex-app/codex-skill-sync.js');
+            const skillsRoot = path.join(rootDir, 'skills');
+            await fsp.mkdir(path.join(skillsRoot, 'ulw-loop'), { recursive: true });
+            const report = await mod.syncCodexSksSkills({ root: rootDir, skillsRoot, apply: true });
+            assertGate(report.interop.clobbered_lazycodex === false && report.lazycodex_reserved_present.includes('ulw-loop'), 'skill sync must preserve LazyCodex skills', report);
+            return emitGate(id, { desired: report.desired_skills.length });
+        }
+        if (id === 'codex-app:agent-role-sync') {
+            const mod = await importDist('core/codex-app/codex-agent-role-sync.js');
+            const report = await mod.syncCodexAgentRoles({ root: rootDir, codexHome: path.join(rootDir, 'codex-home'), apply: true, agentTypeSupported: true });
+            assertGate(report.fallback === 'agent_type', 'agent role sync should use agent_type when supported', report);
+            return emitGate(id, { roles: report.directive_roles.length });
+        }
+        if (id === 'codex-app:init-deep') {
+            const mod = await importDist('core/codex-app/codex-init-deep.js');
+            await fsp.mkdir(path.join(rootDir, 'src/core/zellij'), { recursive: true });
+            await fsp.writeFile(path.join(rootDir, 'src/core/zellij/a.ts'), 'export {}\n');
+            const report = await mod.runCodexInitDeep({ root: rootDir, apply: true });
+            assertGate(report.root_agents_preserved === true, 'init-deep must preserve user AGENTS.md', report);
+            return emitGate(id, { guidance: report.directory_guidance.length });
+        }
+        if (id === 'codex-app:hook-lifecycle') {
+            const mod = await importDist('core/codex-app/codex-hook-lifecycle.js');
+            const report = await mod.buildCodexHookLifecycle({ root: rootDir });
+            assertGate(report.approval_state === 'unknown', 'hook lifecycle must report unknown approval when not detectable', report);
+            return emitGate(id, { lifecycle: Object.keys(report.lifecycle).length });
+        }
+        if (id === 'codex-app:execution-profile') {
+            const mod = await importDist('core/codex-app/codex-app-execution-profile.js');
+            const profile = await mod.resolveCodexAppExecutionProfile({ root: rootDir });
+            assertGate(['codex-app-native', 'codex-cli-headless', 'sks-loop-headless', 'degraded-no-app'].includes(profile.mode), 'execution profile mode invalid', profile);
+            return emitGate(id, { mode: profile.mode });
+        }
+    }
+    finally {
+        restoreEnv(previous);
+    }
+}
+async function loopGate(id) {
+    const rootDir = await tempRoot(`sks-${id.replace(/[:/]/g, '-')}-`);
+    if (id === 'loop:planner-project-memory') {
+        const init = await importDist('core/codex-app/codex-init-deep.js');
+        const planner = await importDist('core/loops/loop-planner.js');
+        await fsp.mkdir(path.join(rootDir, 'src/core/loops'), { recursive: true });
+        await fsp.writeFile(path.join(rootDir, 'src/core/loops/a.ts'), 'export {}\n');
+        await init.runCodexInitDeep({ root: rootDir, apply: true });
+        const plan = await planner.planLoopsFromRequest({ root: rootDir, missionId: 'M-loop-memory', request: 'update loop planner project memory', sourceCommand: 'loop' });
+        assertGate(plan.project_memory?.injected === true, 'loop planner must consume init-deep memory hints', plan);
+        return emitGate(id, { injected: true });
+    }
+    const planDir = path.join(rootDir, '.sneakoscope', 'missions', 'M-loop-cont', 'loops');
+    await fsp.mkdir(planDir, { recursive: true });
+    await fsp.writeFile(path.join(rootDir, '.sneakoscope', 'missions', 'M-loop-cont', 'loops', 'loop-plan.json'), JSON.stringify({ graph: { nodes: [{ loop_id: 'loop-a' }] } }));
+    const mod = await importDist('core/loops/loop-continuation-enforcer.js');
+    const report = await mod.evaluateLoopContinuation({ root: rootDir, missionId: 'M-loop-cont' });
+    assertGate(report.should_continue === true, 'loop continuation should request resume when proof missing', report);
+    emitGate(id, { should_continue: report.should_continue });
+}
+async function lazycodexInteropGate(id) {
+    const rootDir = await tempRoot(`sks-${id.replace(/[:/]/g, '-')}-`);
+    const previous = swapEnv({ SKS_CODEX_PLUGIN_JSON_FAKE: '1' });
+    try {
+        const mod = await importDist('core/codex-app/lazycodex-interop-policy.js');
+        const skillsRoot = path.join(rootDir, '.codex', 'skills');
+        await fsp.mkdir(path.join(skillsRoot, 'start-work'), { recursive: true });
+        const report = await mod.buildLazyCodexInteropPolicy({ root: rootDir, codexHome: path.join(rootDir, '.codex') });
+        assertGate(report.policy.clobber_lazycodex_skills === false, 'interop policy must not clobber LazyCodex skills', report);
+        emitGate(id, { detected: report.lazycodex_detected, collisions: report.detection.collisions.length });
+    }
+    finally {
+        restoreEnv(previous);
+    }
+}
+function fakeZellijEnv(status, opts = {}) {
+    return {
+        ...process.env,
+        SKS_ZELLIJ_CAPABILITY_FAKE_STATUS: status,
+        SKS_ZELLIJ_CAPABILITY_FAKE_VERSION: status === 'too_old' ? '0.40.0' : '0.44.0',
+        SKS_ZELLIJ_SELF_HEAL_BEFORE_STATUS: status,
+        SKS_ZELLIJ_SELF_HEAL_BEFORE_VERSION: status === 'too_old' ? '0.40.0' : '',
+        SKS_ZELLIJ_SELF_HEAL_AFTER_STATUS: 'ok',
+        SKS_ZELLIJ_SELF_HEAL_AFTER_VERSION: '0.44.3',
+        SKS_ZELLIJ_LATEST_VERSION: '0.44.3',
+        SKS_ZELLIJ_SELF_HEAL_FAKE_RUN: '1',
+        SKS_ZELLIJ_SELF_HEAL_BREW_PRESENT: opts.brew ? '1' : '0'
+    };
+}
+async function tempRoot(prefix) {
+    const dir = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+    await fsp.mkdir(path.join(dir, '.sneakoscope', 'reports'), { recursive: true });
+    return dir;
+}
+function swapEnv(next) {
+    const previous = {};
+    for (const [key, value] of Object.entries(next)) {
+        previous[key] = process.env[key];
+        if (value === '')
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+    return previous;
+}
+function restoreEnv(previous) {
+    for (const [key, value] of Object.entries(previous)) {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+}
+//# sourceMappingURL=sks-3-1-4-directive-check-lib.js.map