sneakoscope 3.1.3 → 3.1.5

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

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

@@ -0,0 +1,347 @@
+#!/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 { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const CORE_NO_TS_NOCHECK_DIRS = [
+    'src/core/zellij',
+    'src/core/doctor',
+    'src/core/codex-app',
+    'src/core/loops',
+    'src/core/naruto'
+];
+const TARGET_TYPED_FILES = [
+    'src/core/zellij/zellij-self-heal.ts',
+    'src/core/zellij/homebrew-policy.ts',
+    'src/core/doctor/doctor-zellij-repair.ts',
+    'src/core/codex-app/codex-app-harness-matrix.ts',
+    'src/core/codex-app/lazycodex-analysis.ts',
+    'src/core/codex-app/codex-skill-sync.ts',
+    'src/core/codex-app/codex-agent-role-sync.ts',
+    'src/core/codex-app/codex-init-deep.ts',
+    'src/core/codex-app/codex-hook-lifecycle.ts',
+    'src/core/codex-app/codex-app-execution-profile.ts',
+    'src/core/codex-app/lazycodex-interop-policy.ts',
+    'src/core/loops/loop-continuation-enforcer.ts'
+];
+export async function runDirective315Gate(id) {
+    if (id === 'lint:no-ts-nocheck-core')
+        return noTsNoCheckCore(id);
+    if (id === 'codex-app:type-safety')
+        return codexAppTypeSafety(id);
+    if (id === 'type-surface:codex-app')
+        return typeSurfaceCodexApp(id);
+    if (id.startsWith('zellij:'))
+        return zellijGate(id);
+    if (id.startsWith('codex-app:hook-approval'))
+        return hookApprovalGate(id);
+    if (id.startsWith('codex-app:agent-type'))
+        return agentTypeGate(id);
+    if (id.startsWith('lazycodex:'))
+        return lazycodexGate(id);
+    if (id.includes('init-deep') || id.includes('planner-project-memory-deep'))
+        return initDeepGate(id);
+    if (id.includes('execution-profile-routing'))
+        return executionProfileRoutingGate(id);
+    if (id === 'codex-app:skill-rich-content')
+        return richContentGate(id);
+    if (id === 'codex-app:agent-role-rich-content')
+        return richContentGate(id);
+    throw new Error(`unknown_gate:${id}`);
+}
+function noTsNoCheckCore(id) {
+    const offenders = [];
+    for (const dir of CORE_NO_TS_NOCHECK_DIRS) {
+        for (const file of walkTs(path.join(root, dir))) {
+            const text = fs.readFileSync(file, 'utf8');
+            if (/^\s*\/\/\s*@ts-nocheck\b/m.test(text))
+                offenders.push(path.relative(root, file));
+        }
+    }
+    assertGate(offenders.length === 0, 'core @ts-nocheck offenders found', { offenders });
+    emitGate(id, { scanned_dirs: CORE_NO_TS_NOCHECK_DIRS.length });
+}
+function codexAppTypeSafety(id) {
+    const required = [
+        'src/core/codex-app/codex-app-types.ts',
+        'src/core/zellij/zellij-self-heal-types.ts',
+        'src/core/codex-app/codex-hook-approval-probe.ts',
+        'src/core/codex-app/codex-agent-type-probe.ts',
+        'src/core/codex-app/lazycodex-live-analyzer.ts'
+    ];
+    for (const file of [...required, ...TARGET_TYPED_FILES])
+        assertGate(fs.existsSync(path.join(root, file)), `missing ${file}`);
+    for (const file of TARGET_TYPED_FILES) {
+        const text = fs.readFileSync(path.join(root, file), 'utf8');
+        assertGate(!/^\s*\/\/\s*@ts-nocheck\b/m.test(text), `target file still has @ts-nocheck: ${file}`);
+    }
+    const matrix = fs.readFileSync(path.join(root, 'src/core/codex-app/codex-app-harness-matrix.ts'), 'utf8');
+    assertGate(!/hookApprovalKnown\s*=\s*false/.test(matrix), 'harness matrix must not hardcode hook approval unknown');
+    assertGate(!/SKS_CODEX_AGENT_TYPE_SUPPORTED\s*===\s*['"]1['"]/.test(matrix), 'harness matrix must not use env-only agent_type support');
+    emitGate(id, { target_files: TARGET_TYPED_FILES.length });
+}
+async function typeSurfaceCodexApp(id) {
+    const types = await importDist('core/codex-app/codex-app-types.js');
+    const zellijTypes = await importDist('core/zellij/zellij-self-heal-types.js');
+    const agentProbe = await importDist('core/codex-app/codex-agent-type-probe.js');
+    const sampleMatrix = {
+        schema: 'sks.codex-app-harness-matrix.v1',
+        generated_at: new Date().toISOString(),
+        ok: true,
+        codex_cli: { available: true, version: 'codex test' },
+        app_features: {
+            plugin_json: true,
+            marketplace_add: true,
+            marketplace_upgrade: true,
+            startup_review_detectable: true,
+            hook_approval_state_detectable: true,
+            hook_approval_state: 'approved',
+            skill_picker_ready: true,
+            agent_type_supported: true,
+            mcp_inventory_ready: true,
+            app_handoff_ready: true,
+            image_path_exposure_ready: true
+        },
+        sks_integrations: {
+            dollar_skills_synced: true,
+            agent_roles_synced: true,
+            hooks_synced: true,
+            init_deep_available: true,
+            loop_mesh_app_profile_available: true
+        },
+        probes: {},
+        blockers: [],
+        warnings: []
+    };
+    assertGate(types.isCodexAppHarnessMatrix(sampleMatrix) === true, 'CodexAppHarnessMatrix guard rejected valid sample');
+    const normalized = zellijTypes.normalizeZellijSelfHealResult({ schema: 'sks.zellij-self-heal.v1', ok: true, requested_by: 'setup', strategy: 'none-current', before: {}, after: {}, blockers: [], warnings: [] });
+    assertGate(normalized.dry_run === false && Array.isArray(normalized.planned_mutations), 'zellij self-heal normalizer must backfill new fields', normalized);
+    const payload = agentProbe.agentRolePayloadFor('sks-checker', { supported: true, schema: 'sks.codex-agent-type-probe.v1' });
+    assertGate(payload.strategy === 'agent_type' && payload.agent_type === 'sks-checker', 'agent role payload must select agent_type when supported', payload);
+    emitGate(id, { guards: 3 });
+}
+async function zellijGate(id) {
+    const rootDir = await tempRoot(id);
+    const selfHeal = await importDist('core/zellij/zellij-self-heal.js');
+    if (id === 'zellij:self-heal-status-contract') {
+        const update = await importDist('core/zellij/zellij-update.js');
+        const result = await update.maybePromptZellijUpdateForLaunch(['--yes'], {
+            label: 'MAD launch',
+            root: rootDir,
+            selfHealOnMissing: true,
+            allowHeadlessFallback: true,
+            env: fakeZellijEnv('missing', { brew: false })
+        });
+        assertGate(result.status === 'headless_fallback', 'missing zellij with headless fallback must return headless_fallback', result);
+        return emitGate(id, { status: result.status });
+    }
+    const result = await selfHeal.repairZellijForSks({
+        root: rootDir,
+        requestedBy: 'doctor --fix',
+        fixRequested: true,
+        autoApprove: true,
+        dryRun: id.includes('dry-run') || id.includes('typed-blackbox'),
+        installHomebrew: false,
+        env: fakeZellijEnv('missing', { brew: true })
+    });
+    assertGate(result.dry_run === true, 'dry-run zellij result must set dry_run', result);
+    assertGate(result.planned_mutations.length >= 1, 'dry-run zellij result must include planned mutations', result);
+    assertGate(result.mutation_guard_artifact?.endsWith('#planned'), 'dry-run zellij mutation artifact must be planned-only', result);
+    emitGate(id, { planned: result.planned_mutations.length });
+}
+async function hookApprovalGate(id) {
+    const rootDir = await tempRoot(id);
+    const previous = swapEnv({ SKS_CODEX_HOOK_APPROVAL_FIXTURE: id.includes('blackbox') ? 'modified' : 'approved' });
+    try {
+        const probe = await importDist('core/codex-app/codex-hook-approval-probe.js');
+        const report = await probe.probeCodexHookApprovalState(rootDir);
+        if (id.includes('blackbox')) {
+            assertGate(report.approval_state === 'modified_requires_reapproval' && report.ok === false, 'modified hook approval must require reapproval', report);
+        }
+        else {
+            assertGate(report.approval_state === 'approved' && report.detectable === true, 'fixture approved hook state must be detectable', report);
+        }
+        if (id === 'codex-app:hook-approval-matrix') {
+            const matrixMod = await importDist('core/codex-app/codex-app-harness-matrix.js');
+            const matrix = await matrixMod.buildCodexAppHarnessMatrix({ root: rootDir });
+            assertGate(matrix.app_features.hook_approval_state === report.approval_state, 'matrix must embed hook approval probe state', matrix);
+            assertGate(matrix.probes.hook_approval.schema === 'sks.codex-hook-approval-probe.v1', 'matrix must embed hook approval probe');
+        }
+        emitGate(id, { state: report.approval_state });
+    }
+    finally {
+        restoreEnv(previous);
+    }
+}
+async function agentTypeGate(id) {
+    const rootDir = await tempRoot(id);
+    const schema = JSON.stringify([{ name: 'spawn_agent', parameters: { properties: { agent_type: { type: 'string' } } } }]);
+    const previous = swapEnv({ SKS_CODEX_TOOL_SCHEMA_JSON: schema });
+    try {
+        const probeMod = await importDist('core/codex-app/codex-agent-type-probe.js');
+        const probe = await probeMod.probeCodexAgentTypeSupport(rootDir);
+        assertGate(probe.supported === true && probe.source === 'codex-tool-schema', 'agent_type probe must detect schema support', probe);
+        if (id.includes('routing') || id.includes('blackbox')) {
+            const roleMod = await importDist('core/codex-app/codex-agent-role-sync.js');
+            const report = await roleMod.syncCodexAgentRoles({ root: rootDir, codexHome: path.join(rootDir, 'codex-home'), apply: true });
+            assertGate(report.fallback === 'agent_type', 'agent role sync must route to agent_type when probe supports it', report);
+        }
+        emitGate(id, { supported: probe.supported });
+    }
+    finally {
+        restoreEnv(previous);
+    }
+}
+async function lazycodexGate(id) {
+    const rootDir = await tempRoot(id);
+    const sourceDir = path.join(rootDir, 'lazycodex-source');
+    await fsp.mkdir(sourceDir, { recursive: true });
+    await fsp.writeFile(path.join(sourceDir, 'README.md'), [
+        '# LazyCodex fixture',
+        'npx lazycodex-ai install aliases npx --yes',
+        'codex plugin marketplace add omo@sisyphuslabs',
+        'hook approval requires startup review and trust.',
+        '$ulw-plan and $ulw-loop continue work.',
+        '$init-deep writes hierarchical AGENTS.md.',
+        'spawn_agent supports agent_type with message-role fallback.'
+    ].join('\n'));
+    const liveMod = await importDist('core/codex-app/lazycodex-live-analyzer.js');
+    const live = await liveMod.analyzeLazyCodexLiveSource({ root: rootDir, sourceDir, writeReport: id.includes('blackbox') });
+    assertGate(live.evidence.length >= 5, 'live LazyCodex analysis must collect hashed evidence', live);
+    if (id === 'lazycodex:analysis-with-evidence') {
+        const analysisMod = await importDist('core/codex-app/lazycodex-analysis.js');
+        const report = analysisMod.buildLazyCodexPatternAnalysis(live);
+        assertGate(report.patterns.some((row) => row.confidence === 'high' && row.live_evidence.length), 'static analysis must merge live evidence', report);
+    }
+    if (id.includes('blackbox')) {
+        assertGate(fs.existsSync(path.join(rootDir, '.sneakoscope', 'reports', 'lazycodex-live-analysis.json')), 'live analysis report missing');
+    }
+    emitGate(id, { evidence: live.evidence.length });
+}
+async function initDeepGate(id) {
+    const rootDir = await tempRoot(id);
+    await fsp.mkdir(path.join(rootDir, 'src/core/zellij'), { recursive: true });
+    for (let i = 0; i < 18; i += 1)
+        await fsp.writeFile(path.join(rootDir, 'src/core/zellij', `f${i}.ts`), 'export {}\n');
+    await fsp.writeFile(path.join(rootDir, 'src/core/zellij', 'AGENTS.md'), '# User local guidance\nKeep me.\n');
+    const init = await importDist('core/codex-app/codex-init-deep.js');
+    const report = await init.runCodexInitDeep({ root: rootDir, apply: true, directoryLocal: true });
+    const agents = fs.readFileSync(path.join(rootDir, 'src/core/zellij', 'AGENTS.md'), 'utf8');
+    assertGate(/BEGIN SKS INIT-DEEP MANAGED SECTION/.test(agents), 'directory AGENTS.md managed block missing', { agents });
+    assertGate(agents.includes('Keep me.'), 'directory AGENTS.md must preserve user content', { agents });
+    assertGate(report.directory_local_agents.backup_paths.length >= 1, 'directory AGENTS.md backup missing', report);
+    if (id === 'loop:planner-project-memory-deep') {
+        const planner = await importDist('core/loops/loop-planner.js');
+        const plan = await planner.planLoopsFromRequest({ root: rootDir, missionId: 'M-memory-deep', request: 'change zellij self heal and loop planner', sourceCommand: 'loop' });
+        assertGate(plan.graph.nodes.some((node) => Array.isArray(node.memory_hints) && node.memory_hints.length), 'loop nodes must consume deep memory hints', plan);
+    }
+    emitGate(id, { managed_agents: report.directory_local_agents.created.length + report.directory_local_agents.updated.length });
+}
+async function executionProfileRoutingGate(id) {
+    const rootDir = await tempRoot(id);
+    const previous = swapEnv({ SKS_CODEX_HOOK_APPROVAL_FIXTURE: 'approved', SKS_CODEX_AGENT_TYPE_FIXTURE: 'supported' });
+    try {
+        const profileMod = await importDist('core/codex-app/codex-app-execution-profile.js');
+        const profile = await profileMod.resolveCodexAppExecutionProfile({ root: rootDir });
+        assertGate(profile.agent_role_strategy === 'agent_type', 'execution profile must consume agent_type probe fixture', profile);
+        if (id === 'qa-loop:execution-profile-routing' || id === 'pipeline:execution-profile-routing-blackbox') {
+            const qa = await importDist('core/qa-loop.js');
+            const dir = path.join(rootDir, '.sneakoscope', 'missions', 'M-qa');
+            await fsp.mkdir(dir, { recursive: true });
+            await qa.writeQaLoopArtifacts(dir, { id: 'M-qa', prompt: 'QA no UI' }, { sealed_hash: 'sealed', answers: { QA_SCOPE: 'api_e2e_only', TARGET_ENVIRONMENT: 'local_dev_server', DESTRUCTIVE_DEPLOYED_TESTS_ALLOWED: 'never' } });
+            const gate = JSON.parse(fs.readFileSync(path.join(dir, 'qa-gate.json'), 'utf8'));
+            assertGate(gate.codex_app_execution_profile?.agent_role_strategy === 'agent_type', 'QA gate must consume execution profile', gate);
+        }
+        if (id === 'research:execution-profile-routing' || id === 'pipeline:execution-profile-routing-blackbox') {
+            const research = await importDist('core/research.js');
+            const dir = path.join(rootDir, '.sneakoscope', 'missions', 'M-research');
+            await fsp.mkdir(dir, { recursive: true });
+            const plan = await research.writeResearchPlan(dir, 'research execution profile routing', { root: rootDir, missionId: 'M-research' });
+            assertGate(plan.codex_app_execution_profile?.agent_role_strategy === 'agent_type', 'Research plan must consume execution profile', plan);
+            assertGate(plan.web_research_policy.source_tool_routing, 'Research plan must include source tool routing', plan);
+        }
+        if (id === 'loop:execution-profile-routing' || id === 'pipeline:execution-profile-routing-blackbox') {
+            const source = fs.readFileSync(path.join(root, 'src/core/loops/loop-worker-runtime.ts'), 'utf8');
+            assertGate(source.includes('codex_app_execution_profile') && source.includes('SKS_CODEX_APP_EXECUTION_PROFILE'), 'Loop worker runtime must persist execution profile routing');
+        }
+        emitGate(id, { mode: profile.mode, strategy: profile.agent_role_strategy });
+    }
+    finally {
+        restoreEnv(previous);
+    }
+}
+async function richContentGate(id) {
+    const rootDir = await tempRoot(id);
+    if (id === 'codex-app:skill-rich-content') {
+        const mod = await importDist('core/codex-app/codex-skill-sync.js');
+        const skillsRoot = path.join(rootDir, 'skills');
+        const report = await mod.syncCodexSksSkills({ root: rootDir, skillsRoot, apply: true });
+        const skill = fs.readFileSync(path.join(skillsRoot, 'loop', 'SKILL.md'), 'utf8');
+        assertGate(/Purpose:|Evidence:|Fallback:/.test(skill), 'managed skill must include rich route content', { skill, report });
+        return emitGate(id, { skills: report.created.length });
+    }
+    const previous = swapEnv({ SKS_CODEX_AGENT_TYPE_FIXTURE: 'supported' });
+    try {
+        const mod = await importDist('core/codex-app/codex-agent-role-sync.js');
+        const codexHome = path.join(rootDir, 'codex-home');
+        const report = await mod.syncCodexAgentRoles({ root: rootDir, codexHome, apply: true });
+        const role = fs.readFileSync(path.join(codexHome, 'agents', 'sks-checker.toml'), 'utf8');
+        assertGate(role.includes('SKS managed 3.1.5 directive role') && role.includes('Execution role strategy'), 'managed agent role must include rich 3.1.5 content', { role, report });
+        emitGate(id, { roles: report.created.length });
+    }
+    finally {
+        restoreEnv(previous);
+    }
+}
+function* walkTs(dir) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            yield* walkTs(full);
+        else if (entry.isFile() && full.endsWith('.ts'))
+            yield full;
+    }
+}
+async function tempRoot(id) {
+    const dir = await fsp.mkdtemp(path.join(os.tmpdir(), `sks-315-${id.replace(/[^a-z0-9]+/gi, '-')}-`));
+    await fsp.mkdir(path.join(dir, '.sneakoscope', 'reports'), { recursive: true });
+    return dir;
+}
+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'
+    };
+}
+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-5-directive-check-lib.js.map