sneakoscope 3.1.3 → 3.1.4

package/dist/core/codex-app/lazycodex-analysis.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export function buildLazyCodexPatternAnalysis() {
+    return {
+        schema: 'sks.lazycodex-pattern-analysis.v1',
+        source_repo: 'code-yeongyu/lazycodex',
+        analyzed_at: nowIso(),
+        patterns: [
+            pattern('npx-no-global-install', 'npx no-global install alias', ['Directive: npx lazycodex-ai install aliases npx --yes --package oh-my-openagent omo install --platform=codex.'], 'adapt', 'Keep optional tooling no-global by default and record repair transactions.', ['src/cli/install-helpers.ts', 'src/core/zellij/zellij-self-heal.ts']),
+            pattern('codex-marketplace-plugin', 'Codex marketplace plugin add/upgrade', ['Directive: codex plugin marketplace add and codex plugin add omo@sisyphuslabs.'], 'adapt', 'Track marketplace/plugin inventory without assuming hooks are approved.', ['src/core/codex-app/codex-app-harness-matrix.ts']),
+            pattern('startup-review-hooks', 'Startup review hook approval', ['Directive: hooks require Codex startup review approval and re-approval after modifications.'], 'adopt', 'Separate installed hook files from approval state; unknown remains unknown.', ['src/core/codex-app/codex-hook-lifecycle.ts']),
+            pattern('background-bootstrap', 'Background bootstrap and restart notice', ['Directive: first approved session performs background bootstrap and upgrade may require restart.'], 'adapt', 'Report bootstrap proof as warning/blocker instead of silently assuming completion.', ['src/core/codex-app/codex-app-harness-matrix.ts']),
+            pattern('doctor-health-report', 'Doctor health report for plugin cache/hooks/MCP/agents/config', ['Directive: LazyCodex doctor reports plugin cache, hooks, MCP servers, agents, config state.'], 'adopt', 'Add Codex App Harness section to SKS doctor.', ['src/commands/doctor.ts']),
+            pattern('dollar-skill-picker', '$ skill picker and $command invocation', ['Directive: Codex composer $ browses installed skills.'], 'adapt', 'Keep SKS route skills synced without clobbering user or LazyCodex skills.', ['src/core/codex-app/codex-skill-sync.ts']),
+            pattern('init-deep-agents', '$init-deep hierarchical AGENTS.md', ['Directive: init-deep creates hierarchical AGENTS.md context.'], 'adapt', 'Generate SKS memory under .sneakoscope/context by default and preserve user AGENTS.md.', ['src/core/codex-app/codex-init-deep.ts']),
+            pattern('plan-start-loop', '$ulw-plan, $start-work, $ulw-loop command pillars', ['Directive: separate planning, durable work, and evidence loop.'], 'adapt', 'Map onto sks loop plan/run/proof without replacing existing Loop Mesh.', ['src/core/commands/loop-command.ts']),
+            pattern('specialist-skills', 'Specialist skills', ['Directive: specialist skills include review-work, LSP, AST-grep, programming, frontend UI/UX.'], 'watch', 'Keep checker profile selection explicit and evidence-backed.', ['src/core/loops/loop-gate-selector.ts']),
+            pattern('native-agent-type', 'Native spawn_agent agent_type with message fallback', ['Directive: LazyCodex probes agent_type and falls back to role in message.'], 'adopt', 'Expose native agent_type capability in execution profile.', ['src/core/codex-app/codex-agent-role-sync.ts', 'src/core/codex-app/codex-app-execution-profile.ts']),
+            pattern('multi-model-routing', 'Multi-model routing', ['Directive: LazyCodex/OmO route multiple models.'], 'watch', 'SKS keeps provider/profile policy separate from harness matrix.', ['src/core/provider/provider-context.ts']),
+            pattern('hook-continuation', 'Hook lifecycle and continuation enforcer', ['Directive: UserPromptSubmit, PreToolUse, PostToolUse, Stop, Notification map to pipeline actions.'], 'adopt', 'Map lifecycle and add Loop continuation proof adapter.', ['src/core/codex-app/codex-hook-lifecycle.ts', 'src/core/loops/loop-continuation-enforcer.ts']),
+            pattern('skill-mcp-slashcommand', 'Skill MCP and slashcommand tool', ['Directive: OmO exposes skill MCP and slashcommand tools.'], 'adapt', 'Report MCP candidates and SKS route skill availability without assuming external plugin behavior.', ['src/core/codex-app/codex-app-harness-matrix.ts']),
+            pattern('lsp-ast-grep', 'LSP/AST-grep optional tooling', ['Directive: LSP/AST-grep are optional-but-first-class loop gates/tools.'], 'watch', 'Use as future specialist gates; do not add unrequested fallback tooling now.', ['src/core/loops/loop-gate-selector.ts'])
+        ],
+        blockers: []
+    };
+}
+export async function writeLazyCodexPatternAnalysis(root) {
+    const report = buildLazyCodexPatternAnalysis();
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-analysis.json'), report);
+    return report;
+}
+export function renderLazyCodexAnalysisMarkdown(report) {
+    const rows = report.patterns.map((p) => `| ${p.id} | ${p.sks_adoption} | ${p.rationale.replace(/\|/g, '\\|')} |`).join('\n');
+    return [
+        '# LazyCodex / OmO Pattern Analysis',
+        '',
+        `Source repo: \`${report.source_repo}\``,
+        `Analyzed at: \`${report.analyzed_at}\``,
+        '',
+        '| Pattern | Adoption | Rationale |',
+        '|---|---|---|',
+        rows,
+        '',
+        'This artifact is deterministic and based on the SKS 3.1.4 directive plus current SKS repository surfaces. Live LazyCodex runtime behavior remains a separate verification concern.'
+    ].join('\n');
+}
+function pattern(id, title, evidence, sks_adoption, rationale, target_modules) {
+    return { id, title, evidence, sks_adoption, rationale, target_modules };
+}
+//# sourceMappingURL=lazycodex-analysis.js.map

package/dist/core/codex-app/lazycodex-interop-policy.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
+export async function buildLazyCodexInteropPolicy(input) {
+    const root = path.resolve(input.root);
+    const inventory = input.inventory || await buildCodexPluginInventory().catch((err) => ({ plugins: [], blockers: [err?.message || String(err)] }));
+    const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    const skillNames = await discoverSkillNames([path.join(root, '.agents', 'skills'), path.join(codexHome, 'skills')]);
+    const pluginIds = (inventory.plugins || []).map((plugin) => `${plugin.id || ''} ${plugin.name || ''}`.toLowerCase());
+    const lazycodexInstalled = pluginIds.some((id) => id.includes('omo') || id.includes('lazycodex'))
+        || ['ulw-loop', 'ulw-plan', 'start-work'].some((name) => skillNames.includes(name));
+    const collisions = ['ulw-loop', 'ulw-plan', 'start-work'].filter((name) => skillNames.includes(name));
+    const report = {
+        schema: 'sks.lazycodex-interop-policy.v1',
+        generated_at: nowIso(),
+        ok: true,
+        mode: input.mode || 'coexist',
+        lazycodex_detected: lazycodexInstalled,
+        detection: {
+            plugin_inventory_ids: pluginIds,
+            skill_names: skillNames,
+            collisions
+        },
+        policy: {
+            clobber_lazycodex_skills: false,
+            clobber_user_skills: false,
+            default_mode: 'coexist',
+            explicit_handoff_required: true
+        },
+        actions: collisions.map((name) => `preserve_existing_skill:${name}`),
+        blockers: []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-interop-policy.json'), report).catch(() => undefined);
+    return report;
+}
+async function discoverSkillNames(roots) {
+    const names = new Set();
+    for (const root of roots) {
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries)
+            if (entry.isDirectory())
+                names.add(entry.name);
+    }
+    return [...names].sort();
+}
+//# sourceMappingURL=lazycodex-interop-policy.js.map

package/dist/core/commands/loop-command.js

@@ -11,6 +11,7 @@ import { runLoopNode, runLoopPlan } from '../loops/loop-runtime.js';
 import { scheduleLoopGraph } from '../loops/loop-scheduler.js';
 import { writeLoopKillRequest } from '../loops/loop-runtime-control.js';
 import { flag, promptOf, readFlagValue } from './command-utils.js';
+import { runCodexInitDeep } from '../codex-app/codex-init-deep.js';
 export async function loopCommand(subcommand = 'help', args = []) {
     const action = subcommand || 'help';
     if (action === 'plan')
@@ -27,6 +28,8 @@ export async function loopCommand(subcommand = 'help', args = []) {
         return loopResume(args);
     if (action === 'graph')
         return loopGraph(args);
+    if (action === 'init-deep')
+        return loopInitDeep(args);
     console.log(`SKS Loop
 
 Usage:
@@ -37,8 +40,16 @@ Usage:
   sks loop kill <loop-id|all>
   sks loop resume latest [--rerun-completed]
   sks loop graph latest
+  sks loop init-deep [--json]
 `);
 }
+async function loopInitDeep(args) {
+    const root = await sksRoot();
+    const result = await runCodexInitDeep({ root, apply: !flag(args, '--check-only') && !flag(args, '--dry-run') });
+    if (flag(args, '--json'))
+        return printJson(result);
+    console.log(`Loop init-deep: ${result.ok ? 'ok' : 'blocked'} ${result.generated_path || ''}`);
+}
 async function loopPlan(args) {
     const root = await sksRoot();
     const request = promptOf(args);

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

@@ -22,6 +22,7 @@ import { checkSksUpdateNotice } from '../update/update-notice.js';
 import { createMadDbCapability, MAD_DB_ACK } from '../mad-db/mad-db-capability.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
+import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
@@ -32,19 +33,52 @@ export async function madHighCommand(args = [], deps = {}) {
         return console.log(JSON.stringify(profile, null, 2));
     }
     const update = { status: 'notice_only', non_blocking: true };
+    const rawArgs = (args || []).map((arg) => String(arg));
+    const headlessZellij = rawArgs.includes('--headless') || process.env.SKS_MAD_ALLOW_HEADLESS === '1';
+    const skipZellijRepair = rawArgs.includes('--skip-zellij-repair') || rawArgs.includes('--no-auto-install-zellij');
+    const launchRoot = process.cwd();
+    if (!(await exists(path.join(launchRoot, '.sneakoscope'))))
+        await initProject(launchRoot, {});
     const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
     if (codexUpdate.status === 'failed' || codexUpdate.status === 'updated_not_reflected') {
         console.error(`Codex CLI update failed: ${codexUpdate.error || 'updated version was not visible on PATH'}`);
         process.exitCode = 1;
         return;
     }
-    // Zellij is checked the same way Codex is, but it stays NON-blocking: a
-    // failed or skipped zellij upgrade never prevents the MAD launch.
-    const zellijUpdate = deps.maybePromptZellijUpdateForLaunch ? await deps.maybePromptZellijUpdateForLaunch(args, { label: 'MAD launch' }).catch(() => ({ status: 'error' })) : { status: 'skipped' };
-    void zellijUpdate;
-    const depStatus = deps.ensureMadLaunchDependencies ? await deps.ensureMadLaunchDependencies(args) : { ready: true, actions: [] };
+    const zellijUpdate = skipZellijRepair
+        ? { status: 'skipped', command: 'sks doctor --fix --yes' }
+        : deps.maybePromptZellijUpdateForLaunch
+            ? await deps.maybePromptZellijUpdateForLaunch(args, {
+                label: 'MAD launch',
+                root: launchRoot,
+                selfHealOnMissing: true,
+                autoApprove: rawArgs.includes('--yes') || rawArgs.includes('-y'),
+                installHomebrew: rawArgs.includes('--install-homebrew'),
+                allowHeadlessFallback: headlessZellij
+            }).catch(() => ({ status: 'error', command: 'sks doctor --fix --yes' }))
+            : await repairZellijForSks({
+                root: launchRoot,
+                requestedBy: 'sks --mad',
+                fixRequested: true,
+                autoApprove: rawArgs.includes('--yes') || rawArgs.includes('-y'),
+                interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY && process.env.SKS_NO_QUESTION !== '1'),
+                installHomebrew: rawArgs.includes('--install-homebrew'),
+                allowHeadlessFallback: headlessZellij
+            });
+    const zellijRepairBlocked = !headlessZellij && (zellijUpdate.status === 'manual_required'
+        || zellijUpdate.strategy === 'manual-required'
+        || zellijUpdate.ok === false);
+    if (zellijRepairBlocked) {
+        console.error('SKS MAD launch blocked by Zellij repair_required.');
+        console.error(`Run: ${zellijUpdate.command || 'sks doctor --fix --yes'}`);
+        process.exitCode = 1;
+        return { ok: false, status: 'repair_required', command: zellijUpdate.command || 'sks doctor --fix --yes', zellij_repair: zellijUpdate };
+    }
+    const depStatus = skipZellijRepair && deps.ensureMadLaunchDependencies
+        ? await deps.ensureMadLaunchDependencies(args)
+        : { ready: true, actions: [] };
     if (!depStatus.ready) {
-        console.error('SKS MAD launch blocked by missing dependencies.');
+        console.error('SKS MAD launch blocked by required Zellij dependency.');
         for (const action of depStatus.actions)
             deps.printDepsInstallAction?.(action);
         process.exitCode = 1;
@@ -56,9 +90,6 @@ export async function madHighCommand(args = [], deps = {}) {
         return;
     }
     const profile = buildMadHighLaunchProfileNoWrite();
-    const launchRoot = process.cwd();
-    if (!(await exists(path.join(launchRoot, '.sneakoscope'))))
-        await initProject(launchRoot, {});
     const uiSnapshotId = Date.now().toString(36);
     const beforeUi = await writeCodexAppUiSnapshot(launchRoot, `mad-before-${uiSnapshotId}`).catch(() => null);
     // launchFast skips the redundant live-`codex exec` config probe (up to ~20s, run
@@ -66,7 +97,6 @@ export async function madHighCommand(args = [], deps = {}) {
     // later when the Zellij session opens. All filesystem/permission/EPERM/symlink/ACL
     // readability + repair checks still run. SKS_LAUNCH_FULL_CODEX_PROBE=1 restores the
     // old behavior.
-    const rawArgs = (args || []).map((arg) => String(arg));
     const madDbRequested = rawArgs.includes('--mad-db');
     const madDbAck = readOption(rawArgs, '--ack', '');
     if (madDbRequested && madDbAck !== MAD_DB_ACK) {
@@ -138,7 +168,9 @@ export async function madHighCommand(args = [], deps = {}) {
     };
     const launchOpts = codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: profile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv });
     const workspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', launchOpts.session || `sks-mad-${sanitizeZellijSessionName(process.cwd())}`));
-    const launch = await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), slotCount: 0, requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
+    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, 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) {
@@ -157,7 +189,8 @@ export async function madHighCommand(args = [], deps = {}) {
         schema: 'sks.zellij-initial-ui.v1',
         ok: true,
         mission_id: madLaunch.mission_id,
-        session_name: launch.session_name,
+        session_name: launch.session_name || null,
+        live_panes: !headlessZellij,
         initial_panes: 'main-only',
         dashboard_created: false,
         worker_panes_created: 0,
@@ -166,16 +199,16 @@ export async function madHighCommand(args = [], deps = {}) {
     const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
         env: {
             ...madSksEnv,
-            SKS_ZELLIJ_SESSION_NAME: launch.session_name
+            ...(launch.session_name ? { SKS_ZELLIJ_SESSION_NAME: launch.session_name } : {})
         },
-        zellijSessionName: launch.session_name,
-        workerPlacement: shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
+        zellijSessionName: launch.session_name || null,
+        workerPlacement: headlessZellij ? 'process' : shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
         zellijVisiblePaneCap: Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 8)
     });
     // 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 (shouldAutoAttachZellij(args)) {
+    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) {
@@ -187,6 +220,8 @@ export async function madHighCommand(args = [], deps = {}) {
     }
     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;
 }
 export async function startMadNativeSwarm(root, madLaunch, args = [], profile = {}, opts = {}) {
@@ -375,6 +410,27 @@ function formatMadZellijAction(launch) {
     const report = launch.report_path ? ` | report: ${launch.report_path}` : '';
     return `${blockers}${detail}${report}`;
 }
+async function writeMadHeadlessZellijFallback(madLaunch, workspace) {
+    const report = {
+        schema: 'sks.zellij-session.v1',
+        generated_at: nowIso(),
+        ok: true,
+        kind: 'mad',
+        status: 'headless-fallback',
+        live_panes: false,
+        mission_id: madLaunch.mission_id,
+        session_name: null,
+        workspace,
+        root: madLaunch.root,
+        cwd: path.resolve(process.cwd()),
+        attach_command_with_env: null,
+        blockers: [],
+        warnings: ['zellij_headless_fallback_live_panes_false']
+    };
+    await writeJsonAtomic(path.join(madLaunch.dir, 'zellij-session.json'), report);
+    await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.zellij_headless_fallback', live_panes: false });
+    return report;
+}
 async function activateMadZellijPermissionState(cwd = process.cwd(), args = []) {
     const root = await sksRoot();
     if (!(await exists(path.join(root, '.sneakoscope'))))
@@ -473,6 +529,9 @@ function madLaunchOnlyFlags() {
         '--attach',
         '--no-attach',
         '--no-auto-install-zellij',
+        '--skip-zellij-repair',
+        '--install-homebrew',
+        '--headless',
         '--allow-system',
         '--allow-db-write',
         '--allow-package-install',
@@ -528,6 +587,8 @@ export function defaultMadSwarmBackend(args = [], opts = {}) {
         return String(opts.backend);
     if (list.includes('--json') || list.includes('--no-attach') || opts.nonInteractive === true)
         return 'codex-sdk';
+    if (list.includes('--headless') || process.env.SKS_MAD_ALLOW_HEADLESS === '1')
+        return 'codex-sdk';
     return 'zellij';
 }
 function stripMadLaunchOnlyArgs(args = []) {

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -65,6 +65,12 @@ export function buildDoctorReadinessMatrix(input = {}) {
         warnings.add('codex_0139_real_probes_not_run');
     for (const warning of normalizeList(input.codex_plugin_app_template_policy?.doctor_warnings))
         warnings.add(warning);
+    const codexAppHarness = input.codex_app_harness_matrix || null;
+    for (const warning of normalizeList(codexAppHarness?.warnings))
+        warnings.add(warning);
+    if (codexAppHarness?.ok === false)
+        for (const blocker of normalizeList(codexAppHarness.blockers))
+            warnings.add(`codex_app_harness:${blocker}`);
     if (input.codex_lb?.ok === false)
         warnings.add(`codex_lb_${input.codex_lb?.circuit?.state || 'blocked'}`);
     const localModel = input.local_model || {};
@@ -124,6 +130,7 @@ export function buildDoctorReadinessMatrix(input = {}) {
         codex_0139_real_probes: codex0139RealProbes,
         codex_plugin_inventory: input.codex_plugin_inventory || null,
         codex_plugin_app_template_policy: input.codex_plugin_app_template_policy || null,
+        codex_app_harness_matrix: codexAppHarness,
         fast_mode_ready: input.fast_mode_ready !== false,
         codex_app_ui: input.codex_app_ui || null,
         hooks_ready: input.hooks_ready !== false,

package/dist/core/doctor/doctor-zellij-repair.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
+export async function runDoctorZellijRepair(input) {
+    const args = (input.args || []).map(String);
+    if (input.doctorFix !== true)
+        return null;
+    return repairZellijForSks({
+        root: input.root,
+        requestedBy: 'doctor --fix',
+        fixRequested: true,
+        autoApprove: args.includes('--yes') || args.includes('-y'),
+        installHomebrew: args.includes('--install-homebrew') || process.env.SKS_ALLOW_HOMEBREW_INSTALL === '1',
+        interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY && process.env.SKS_NO_QUESTION !== '1'),
+        allowHeadlessFallback: false,
+        env: process.env
+    });
+}
+export function doctorZellijRepairConsoleLine(result) {
+    if (!result)
+        return null;
+    if (result.strategy === 'none-current')
+        return `Zellij repair: current ${result.after.version || ''}`.trim();
+    if (result.ok && (result.strategy === 'brew-install-zellij' || result.strategy === 'brew-install-homebrew-then-zellij')) {
+        return `Zellij repair: installed ${result.after.version || 'latest'} via ${result.command || 'brew install zellij'}`;
+    }
+    if (result.ok && result.strategy === 'brew-upgrade-zellij') {
+        return `Zellij repair: upgraded ${result.before.version || 'unknown'} -> ${result.after.version || 'latest'} via ${result.command || 'brew upgrade zellij'}`;
+    }
+    if (result.strategy === 'manual-required') {
+        return `Zellij repair: manual_required\nRun: ${result.command || 'sks doctor --fix --install-homebrew --yes'}`;
+    }
+    if (result.strategy === 'headless-fallback')
+        return 'Zellij repair: headless_fallback live_panes=false';
+    return `Zellij repair: failed\nRun: ${result.command || 'sks doctor --fix --yes'}`;
+}
+//# sourceMappingURL=doctor-zellij-repair.js.map

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '3.1.3';
+export const PACKAGE_VERSION = '3.1.4';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/hooks-runtime.js

@@ -14,6 +14,7 @@ import { REQUIRED_CODEX_MODEL, isForbiddenCodexModel } from './codex-model-guard
 import { dollarCommand, routeRequiresSubagents, stripVisibleDecisionAnswerBlocks } from './routes.js';
 import { appendMissionStatus } from './recallpulse.js';
 import { scanAgentTextForRecursion } from './agents/agent-recursion-guard.js';
+import { evaluateLoopContinuation } from './loops/loop-continuation-enforcer.js';
 import { buildCompactContinue, buildPermissionRequestAllow, buildPermissionRequestDeny, buildPostToolUseBlock, buildPostToolUseContinue, buildPreToolUseContinue, buildPreToolUseDeny, buildSessionStartContinue, buildStopBlock, buildStopContinue, buildSubagentStartContinue, buildSubagentStopBlock, buildSubagentStopContinue, buildUserPromptSubmitBlock, buildUserPromptSubmitContinue } from './codex-compat/codex-hook-output-builders.js';
 const TEAM_DIGEST_MAX_EVENTS = 4;
 const TEAM_DIGEST_MESSAGE_CHARS = 180;
@@ -606,6 +607,18 @@ function clarificationPauseBlockReason(state = {}) {
 }
 async function hookStop(root, state, payload, noQuestion) {
     const last = extractLastMessage(payload);
+    if (state?.mode === 'LOOP' || state?.route === 'Loop' || state?.route_command === '$Loop') {
+        const missionId = state?.mission_id;
+        if (missionId) {
+            const continuation = await evaluateLoopContinuation({ root, missionId }).catch(() => null);
+            if (continuation?.should_continue) {
+                return {
+                    decision: 'block',
+                    reason: `SKS Loop continuation required. Resume with: ${continuation.resume_instruction}`
+                };
+            }
+        }
+    }
     if (await consumeCodexGitActionStopBypass(root, payload)) {
         return {
             continue: true,

package/dist/core/loops/loop-continuation-enforcer.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import path from 'node:path';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { loopPlanPath } from './loop-artifacts.js';
+export async function evaluateLoopContinuation(input) {
+    const root = path.resolve(input.root || process.cwd());
+    const plan = await readJson(loopPlanPath(root, input.missionId), null);
+    const blockers = [];
+    if (!plan)
+        blockers.push('loop_plan_missing');
+    const nodes = plan?.graph?.nodes || [];
+    const proofs = await Promise.all(nodes.map((node) => readJson(path.join(root, '.sneakoscope', 'missions', input.missionId, 'loops', node.loop_id, 'loop-proof.json'), null)));
+    const completed = proofs.filter((proof) => proof?.status === 'completed').length;
+    const incomplete = Math.max(0, nodes.length - completed);
+    const shouldContinue = Boolean(plan && incomplete > 0 && blockers.length === 0);
+    const report = {
+        schema: 'sks.loop-continuation-enforcer.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        mission_id: input.missionId,
+        nodes: nodes.length,
+        completed,
+        incomplete,
+        max_continuation_turns: input.maxContinuationTurns || 3,
+        should_continue: shouldContinue,
+        resume_instruction: shouldContinue ? `sks loop resume ${input.missionId}` : null,
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'missions', input.missionId, 'loop-continuation-enforcer.json'), report).catch(() => undefined);
+    return report;
+}
+//# sourceMappingURL=loop-continuation-enforcer.js.map

package/dist/core/loops/loop-planner.js

@@ -5,6 +5,7 @@ import { selectLoopGates } from './loop-gate-selector.js';
 import { inferLoopOwnerScope } from './loop-owner-inference.js';
 import { classifyLoopRisk } from './loop-risk-classifier.js';
 import { defaultLoopBudget, validateLoopPlan } from './loop-schema.js';
+import { readInitDeepMemory } from '../codex-app/codex-init-deep.js';
 export async function planLoopsFromRequest(input) {
     const parallelism = input.parallelism || 'balanced';
     const maxLoops = Math.max(1, Math.min(32, input.maxLoops || 8));
@@ -83,6 +84,14 @@ export async function planLoopsFromRequest(input) {
         },
         blockers: []
     };
+    const projectMemory = await readInitDeepMemory(input.root).catch(() => null);
+    if (projectMemory) {
+        plan.project_memory = {
+            source: projectMemory.path,
+            injected: true,
+            summary: projectMemory.text.split(/\r?\n/).filter((line) => /^##\s+/.test(line)).slice(0, 8)
+        };
+    }
     const validation = validateLoopPlan(plan);
     plan.blockers = validation.blockers;
     await writeJsonAtomic(loopPlanPath(input.root, input.missionId), plan);

package/dist/core/loops/loop-worker-runtime.js

@@ -6,6 +6,7 @@ import { loopNodeRoot } from './loop-artifacts.js';
 import { computeLoopConcurrencyBudget, loopWorkerBudgetFor } from './loop-concurrency-budget.js';
 import { decideLoopFixturePolicy, writeLoopFixturePolicyDecision } from './loop-fixture-policy.js';
 import { buildLoopCheckerPrompt, buildLoopMakerPrompt } from './loop-worker-prompts.js';
+import { resolveCodexAppExecutionProfile } from '../codex-app/codex-app-execution-profile.js';
 export async function runLoopMakerWorkers(input) {
     return runLoopWorkers({ ...input, phase: 'maker' });
 }
@@ -51,6 +52,7 @@ async function runLoopWorkerNative(input) {
     // The loop worktree is still where workers cwd + write: it is threaded through the per-worker
     // `worktree` opt below, which launchWorker reads as ctx.opts.worktree -> workerCwd.
     const insideZellij = Boolean(process.env.SKS_ZELLIJ_SESSION_NAME || process.env.ZELLIJ);
+    const executionProfile = await resolveCodexAppExecutionProfile({ root: input.root }).catch(() => null);
     const visiblePaneCap = Math.min(resolveLoopVisiblePaneCap(workerCount), Math.max(1, workerCount));
     const zellijPlacementOpts = insideZellij ? {
         workerPlacement: 'zellij-pane',
@@ -77,7 +79,9 @@ async function runLoopWorkerNative(input) {
             SKS_LOOP_ID: input.node.loop_id,
             SKS_LOOP_PHASE: input.phase,
             SKS_LOOP_MAIN_ROOT: input.root,
-            SKS_LOOP_WORKER_BUDGET: String(workerCount)
+            SKS_LOOP_WORKER_BUDGET: String(workerCount),
+            SKS_CODEX_APP_EXECUTION_PROFILE: executionProfile?.mode || 'unknown',
+            SKS_CODEX_AGENT_ROLE_STRATEGY: executionProfile?.agent_role_strategy || 'message-role'
         },
         ...(input.worktree?.path ? {
             worktree: {

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '3.1.3';
+export const PACKAGE_VERSION = '3.1.4';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/homebrew-policy.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import readline from 'node:readline';
+export const HOMEBREW_INSTALL_COMMAND = '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"';
+export function resolveHomebrewInstallPolicy(input = {}) {
+    const args = (input.args || []).map(String);
+    const env = input.env || process.env;
+    const hasFlag = input.installHomebrew === true || args.includes('--install-homebrew');
+    const hasYes = input.autoApprove === true || args.includes('--yes') || args.includes('-y');
+    const envAllowed = env.SKS_ALLOW_HOMEBREW_INSTALL === '1';
+    const interactiveAccepted = input.interactiveAccepted === true;
+    const allowed = envAllowed || interactiveAccepted || (hasFlag && hasYes);
+    const source = envAllowed ? 'env'
+        : interactiveAccepted ? 'interactive_confirmed'
+            : hasFlag && hasYes ? 'yes_install_homebrew'
+                : hasFlag ? 'flag'
+                    : 'not_allowed';
+    return {
+        schema: 'sks.homebrew-policy.v1',
+        allowed,
+        source,
+        install_command: HOMEBREW_INSTALL_COMMAND,
+        blockers: allowed ? [] : ['homebrew_install_requires_explicit_approval']
+    };
+}
+export function homebrewMissingDoctorMessage() {
+    return [
+        'Zellij repair: Homebrew missing. Run:',
+        '  sks doctor --fix --install-homebrew --yes',
+        'or install Homebrew manually, then:',
+        '  sks doctor --fix --yes'
+    ].join('\n');
+}
+export async function askHomebrewInstallAllowed(question = 'Homebrew is missing. Install Homebrew now? [y/N] ') {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => rl.question(question, resolve));
+        return /^(y|yes|예|네|응)$/i.test(String(answer || '').trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=homebrew-policy.js.map

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

@@ -30,7 +30,10 @@ export function resolveZellijStackedPaneCapability(input = {}) {
     };
 }
 export async function checkZellijStackedPaneCapability(opts = {}) {
-    const versionRun = await runZellij(['--version'], { optional: true, timeoutMs: 5000 });
+    const runOpts = { optional: true, timeoutMs: 5000 };
+    if (opts.env !== undefined)
+        runOpts.env = opts.env;
+    const versionRun = await runZellij(['--version'], runOpts);
     const versionText = `${versionRun.stdout_tail}\n${versionRun.stderr_tail}`.trim();
     const report = resolveZellijStackedPaneCapability({
         ok: versionRun.ok,
@@ -45,8 +48,34 @@ export async function checkZellijStackedPaneCapability(opts = {}) {
     return report;
 }
 export async function checkZellijCapability(opts = {}) {
-    const requireZellij = opts.require === true || process.env.SKS_REQUIRE_ZELLIJ === '1';
-    const versionRun = await runZellij(['--version'], { optional: !requireZellij, timeoutMs: 5000 });
+    const env = opts.env || process.env;
+    const requireZellij = opts.require === true || env.SKS_REQUIRE_ZELLIJ === '1';
+    if (env.SKS_ZELLIJ_CAPABILITY_FAKE_STATUS) {
+        const fakeStatus = String(env.SKS_ZELLIJ_CAPABILITY_FAKE_STATUS);
+        const status = fakeStatus === 'ok' || fakeStatus === 'missing' || fakeStatus === 'too_old' || fakeStatus === 'blocked' ? fakeStatus : 'blocked';
+        const report = {
+            schema: ZELLIJ_CAPABILITY_SCHEMA,
+            generated_at: nowIso(),
+            ok: status === 'ok',
+            status,
+            integration_optional: !requireZellij,
+            require_zellij: requireZellij,
+            min_version: ZELLIJ_MIN_VERSION,
+            version: status === 'missing' ? null : String(env.SKS_ZELLIJ_CAPABILITY_FAKE_VERSION || '0.40.0'),
+            bin: 'zellij',
+            command: ['zellij', '--version'],
+            docs_evidence: [],
+            blockers: requireZellij && status !== 'ok' ? [`zellij_${status}_required`] : [],
+            warnings: !requireZellij && status !== 'ok' ? [`zellij_${status}_optional_integration`] : [],
+            operator_actions: status === 'ok' ? [] : ['Install Zellij. On macOS: `brew install zellij`.']
+        };
+        if (opts.writeReport !== false) {
+            const root = opts.root || process.cwd();
+            await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'zellij-capability.json'), report);
+        }
+        return report;
+    }
+    const versionRun = await runZellij(['--version'], { optional: !requireZellij, timeoutMs: 5000, env });
     const versionText = `${versionRun.stdout_tail}\n${versionRun.stderr_tail}`.trim();
     const version = parseZellijVersionText(versionText);
     const missing = !versionRun.ok && versionRun.blockers.includes('zellij_missing');