sneakoscope 3.1.3 → 3.1.5

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

@@ -22,29 +22,98 @@ 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)
         return madSksSubcommand(subcommand, args.filter((arg) => String(arg) !== subcommand));
     const cleanArgs = stripMadLaunchOnlyArgs(args);
-    if (args.includes('--json')) {
+    const rawArgs = (args || []).map((arg) => String(arg));
+    const dryRun = rawArgs.includes('--dry-run');
+    if (args.includes('--json') && !dryRun) {
         const profile = buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
     const update = { status: 'notice_only', non_blocking: true };
+    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, {});
+    if (dryRun) {
+        const zellijPlan = skipZellijRepair
+            ? { schema: 'sks.zellij-self-heal.v1', ok: true, status: 'skipped', dry_run: true, planned_mutations: [], command: null, blockers: [], warnings: ['zellij_repair_skipped'] }
+            : await repairZellijForSks({
+                root: launchRoot,
+                requestedBy: 'sks --mad',
+                fixRequested: true,
+                autoApprove: rawArgs.includes('--yes') || rawArgs.includes('-y'),
+                interactive: false,
+                installHomebrew: rawArgs.includes('--install-homebrew'),
+                allowHeadlessFallback: headlessZellij,
+                dryRun: true
+            });
+        const report = {
+            schema: 'sks.mad-sks-zellij-dry-run.v1',
+            ok: zellijPlan.ok === true,
+            status: zellijPlan.ok === true ? 'dry_run' : 'repair_required',
+            generated_at: nowIso(),
+            launch_skipped: true,
+            zellij_repair: zellijPlan
+        };
+        await writeJsonAtomic(path.join(launchRoot, '.sneakoscope', 'reports', 'mad-sks-zellij-dry-run.json'), report);
+        if (rawArgs.includes('--json'))
+            console.log(JSON.stringify(report, null, 2));
+        else {
+            console.log(`SKS MAD dry-run: launch_skipped=true status=${report.status}`);
+            const planned = Array.isArray(zellijPlan.planned_mutations) ? zellijPlan.planned_mutations : [];
+            for (const row of planned)
+                console.log(`- plan: ${row.command}`);
+            if (zellijPlan.command && planned.length === 0)
+                console.log(`- run: ${zellijPlan.command}`);
+        }
+        return report;
+    }
     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 +125,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 +132,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 +203,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 +224,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 +234,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 +255,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 +445,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 +564,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 +622,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/commands/qa-loop-command.js

@@ -146,6 +146,7 @@ async function qaLoopRun(args) {
     const mock = flag(args, '--mock');
     const qaGate = await readJson(path.join(dir, 'qa-gate.json'), {});
     const reportFile = qaGate.qa_report_file;
+    const executionProfile = await readJson(path.join(dir, 'qa-loop', 'execution-profile.json'), null);
     const uiRequired = qaUiRequired(contract.answers || {});
     const capabilityArtifact = await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), report: null }));
     const usageArtifact = await writeCodexAccountUsageArtifacts(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), snapshot: null }));
@@ -273,7 +274,7 @@ async function qaLoopRun(args) {
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.run.started', maxCycles, mock });
     const nativeAgentPlan = await readJson(path.join(dir, 'qa-agent-plan.json'), null);
     const nativeRoster = requestedAgents === 3 ? nativeAgentPlan : null;
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !(applyPatches && writeMode !== 'off'), profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: nativeRoster, routeCommand: 'sks qa-loop run', routeBlackboxKind: 'actual_qa_command' });
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !(applyPatches && writeMode !== 'off'), profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: nativeRoster, routeCommand: 'sks qa-loop run', routeBlackboxKind: 'actual_qa_command', env: { SKS_CODEX_APP_EXECUTION_PROFILE: executionProfile?.mode || 'unknown', SKS_CODEX_AGENT_ROLE_STRATEGY: executionProfile?.agent_role_strategy || 'message-role' } });
     await writeJsonAtomic(path.join(dir, 'qa-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (mock) {
@@ -343,7 +344,7 @@ async function qaLoopRun(args) {
     for (let cycle = 1; cycle <= maxCycles; cycle += 1) {
         const cycleDir = path.join(dir, 'qa-loop', `cycle-${cycle}`);
         const outputFile = path.join(cycleDir, 'final.md');
-        const prompt = buildQaLoopPrompt({ id, mission, contract, cycle, previous: last, reportFile, imagePathContract: imagePathContract?.contract || null, appHandoff });
+        const prompt = buildQaLoopPrompt({ id, mission, contract, cycle, previous: last, reportFile, imagePathContract: imagePathContract?.contract || null, appHandoff, executionProfile });
         await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.cycle.start', cycle });
         const result = await runCodexExec({ root, prompt, outputFile, json: true, profile, logDir: cycleDir });
         await writeJsonAtomic(path.join(cycleDir, 'process.json'), { code: result.code, stdout_tail: result.stdout, stderr_tail: result.stderr, stdout_bytes: result.stdoutBytes, stderr_bytes: result.stderrBytes, truncated: result.truncated, timed_out: result.timedOut });

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

@@ -52,7 +52,7 @@ async function researchPrepare(args) {
     const context7Required = routeNeedsContext7(route, prompt);
     const reasoning = routeReasoning(route, prompt);
     const autoresearch = flag(args, '--autoresearch');
-    const plan = await writeResearchPlan(dir, prompt, { depth: readFlagValue(args, '--depth', 'frontier'), missionId: id, autoresearch });
+    const plan = await writeResearchPlan(dir, prompt, { root, depth: readFlagValue(args, '--depth', 'frontier'), missionId: id, autoresearch });
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: prompt, required: context7Required, ambiguity: { required: false, status: 'direct_research_cli' } });
     await writeJsonAtomic(path.join(dir, 'route-context.json'), {
         route: route.id,
@@ -114,7 +114,7 @@ async function researchRun(args) {
     const { dir, mission } = await loadMission(root, id);
     const planPath = path.join(dir, 'research-plan.json');
     if (!(await exists(planPath)))
-        await writeResearchPlan(dir, mission.prompt || '', { missionId: id, autoresearch: flag(args, '--autoresearch') });
+        await writeResearchPlan(dir, mission.prompt || '', { root, missionId: id, autoresearch: flag(args, '--autoresearch') });
     const plan = await readJson(planPath);
     const dbScan = await scanDbSafety(root);
     if (!dbScan.ok) {

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,40 @@
+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',
+        dryRun: args.includes('--dry-run'),
+        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.dry_run) {
+        const planned = result.planned_mutations.map((row) => row.command).join(' && ') || result.command || 'none';
+        return `Zellij repair: dry_run planned ${planned}`;
+    }
+    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/feature-fixtures.js

@@ -107,6 +107,7 @@ const FIXTURES = Object.freeze({
     'route-from-chat-img': fixture('mock', '$From-Chat-IMG visual work order route', ['from-chat-img-work-order.md', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass'),
     'route-ux-review': fixture('mock', '$UX-Review image UX alias route', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
     'route-db': fixture('execute_and_validate_artifacts', 'sks db check --sql "SELECT 1" --json', ['completion-proof.json', 'db-operation-report.json'], 'pass'),
+    'route-mad-db': fixture('mock', '$MAD-DB one-cycle DB break-glass route contract', ['mad-db-capability.json', 'mad-db-ledger.jsonl', 'completion-proof.json'], 'pass'),
     'route-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: 'completion-proof.json', schema: 'sks.completion-proof.v1' }, { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }], 'pass'),
     'route-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'gx-validation.json'], 'pass'),
     'route-sks': fixture('mock', '$SKS control-surface route', ['completion-proof.json'], 'pass'),

package/dist/core/feature-registry.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS } from './routes.js';
+import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS, ROUTES } from './routes.js';
 import { FEATURE_QUALITY_LEVELS, fixtureForFeature, fixtureSummary, validateFeatureFixtures } from './feature-fixtures.js';
 import { runFeatureFixture, writeFeatureFixtureReports } from './feature-fixture-runner.js';
 import { PACKAGE_VERSION, exists, nowIso, packageRoot, readJson, readText, runProcess, writeJsonAtomic, writeTextAtomic } from './fsx.js';
@@ -46,6 +46,9 @@ export async function buildFeatureRegistry({ root = packageRoot(), generatedAt =
     }
     for (const route of DOLLAR_COMMANDS)
         features.push(routeFeature(route));
+    for (const route of ROUTES.filter((entry) => entry.hidden === true)) {
+        features.push(routeFeature(route));
+    }
     features.push(nativeAgentIntakeFeature());
     features.push(agentProofEvidenceFeature());
     for (const skillName of skillNames) {

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.5';
 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/init.js

@@ -639,7 +639,10 @@ export async function initProject(root, opts = {}) {
         const baseUrl = globalConfig.match(/(^|\n)\[model_providers\.codex-lb\][\s\S]*?\n\s*base_url\s*=\s*"([^"]+)"/)?.[2] || parseCodexLbEnvBaseUrl(envText);
         if (!parseCodexLbEnvKey(envText) || !baseUrl)
             return next;
-        next = upsertTopLevelTomlString(next, 'model_provider', 'codex-lb');
+        const shouldSelectCodexLb = selectedRe.test(next) || selectedRe.test(globalConfig);
+        next = shouldSelectCodexLb
+            ? upsertTopLevelTomlString(next, 'model_provider', 'codex-lb')
+            : removeTopLevelTomlKeyIfValue(next, 'model_provider', 'codex-lb');
         next = upsertTomlTable(next, 'model_providers.codex-lb', `[model_providers.codex-lb]\nname = "OpenAI"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nenv_key = "CODEX_LB_API_KEY"\nsupports_websockets = true\nrequires_openai_auth = false`);
         return `${next.trim()}\n`;
     }

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

@@ -0,0 +1,40 @@
+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 = loopNodes(plan);
+    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) => isRecord(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;
+}
+function loopNodes(value) {
+    if (!isRecord(value) || !isRecord(value.graph) || !Array.isArray(value.graph.nodes))
+        return [];
+    return value.graph.nodes
+        .filter((node) => isRecord(node) && typeof node.loop_id === 'string');
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+//# 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, readInitDeepMemoryHints } 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));
@@ -52,6 +53,11 @@ export async function planLoopsFromRequest(input) {
         })
     };
     const nodes = [...actionNodes, integrationNode];
+    const memoryHints = await readInitDeepMemoryHints(input.root, scopePathsForNodes(nodes)).catch(() => []);
+    const nodesWithMemory = nodes.map((node) => {
+        const hints = memoryHints.filter((hint) => hintAppliesToNode(hint, node)).slice(0, 5);
+        return hints.length ? { ...node, memory_hints: hints } : node;
+    });
     const plan = {
         schema: 'sks.loop-plan.v1',
         mission_id: input.missionId,
@@ -63,12 +69,12 @@ export async function planLoopsFromRequest(input) {
             confidence: actionNodes.length ? 'high' : 'medium'
         },
         graph: {
-            nodes,
+            nodes: nodesWithMemory,
             edges: actionNodes.map((node) => ({ from: node.loop_id, to: integrationNode.loop_id, reason: 'integration_after_loop_proof' }))
         },
         global_budget: defaultLoopBudget({
-            max_iterations: Math.max(...nodes.map((node) => node.budget.max_iterations)),
-            max_subagents: nodes.reduce((sum, node) => sum + node.budget.max_subagents, 0)
+            max_iterations: Math.max(...nodesWithMemory.map((node) => node.budget.max_iterations)),
+            max_subagents: nodesWithMemory.reduce((sum, node) => sum + node.budget.max_subagents, 0)
         }),
         safety: {
             no_unrequested_fallback_code: true,
@@ -83,6 +89,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);
@@ -167,4 +181,16 @@ function dynamicCheckerWorkerCount(input) {
 function titleFromDomain(domainId) {
     return domainId === 'loop-general-coding' ? 'General coding loop' : `${domainId} loop`;
 }
+function scopePathsForNodes(nodes) {
+    return nodes.flatMap((node) => [
+        ...node.owner_scope.files,
+        ...node.owner_scope.directories
+    ]).filter(Boolean);
+}
+function hintAppliesToNode(hint, node) {
+    if (hint.scope === '.')
+        return true;
+    const scopes = [...node.owner_scope.files, ...node.owner_scope.directories].map((value) => value.replace(/^\.?\//, ''));
+    return scopes.some((scope) => scope === hint.scope || scope.startsWith(`${hint.scope}/`) || hint.scope.startsWith(`${scope}/`));
+}
 //# sourceMappingURL=loop-planner.js.map

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' });
 }
@@ -42,7 +43,8 @@ async function runLoopWorkerNative(input) {
         ? buildLoopMakerPrompt({ plan: input.plan, node: input.node, worktreePath: input.worktree?.path || null })
         : buildLoopCheckerPrompt({ plan: input.plan, node: input.node, makerArtifacts: input.makerArtifacts || [] });
     const workerCount = effectiveLoopWorkerCount(input);
-    const workGraph = buildLoopNarutoWorkGraph(input, workerCount);
+    const executionProfile = await resolveCodexAppExecutionProfile({ root: input.root }).catch(() => null);
+    const workGraph = buildLoopNarutoWorkGraph(input, workerCount, executionProfile);
     // Root-cause-1 fix: keep the ORCHESTRATOR root on the MAIN repo (input.root), not the
     // loop worktree. All zellij/right-column/slot-telemetry state derives from the orchestrator
     // root, so anchoring it on input.root makes the SLOTS snapshot land under
@@ -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: {
@@ -95,9 +99,9 @@ async function runLoopWorkerNative(input) {
             fallback_reason: null
         } : null
     });
-    return normalizeNativeResult(input, orchestrator);
+    return normalizeNativeResult(input, orchestrator, executionProfile);
 }
-async function normalizeNativeResult(input, result) {
+async function normalizeNativeResult(input, result, executionProfile) {
     const artifacts = collectArtifactPaths(result);
     const changedFiles = stringArray(result?.changed_files || result?.proof?.changed_files || result?.results?.flatMap?.((row) => row?.changed_files || []));
     const blockers = [
@@ -120,7 +124,15 @@ async function normalizeNativeResult(input, result) {
         blockers: [...new Set(blockers)],
         runtime_proof_path: proofPath,
         worker_ids: stringArray(result?.results?.map?.((row) => row?.agent_id || row?.id)),
-        session_ids: stringArray(result?.results?.map?.((row) => row?.session_id))
+        session_ids: stringArray(result?.results?.map?.((row) => row?.session_id)),
+        ...(executionProfile ? {
+            codex_app_execution_profile: {
+                mode: executionProfile.mode,
+                agent_role_strategy: executionProfile.agent_role_strategy,
+                artifact_path: executionProfile.artifact_path,
+                agent_type_probe_artifact_path: executionProfile.agent_type_probe_artifact_path
+            }
+        } : {})
     };
     await writeJsonAtomic(proofPath, { ...normalized, native_result_summary: summarizeNativeResult(result), generated_at: nowIso() });
     return normalized;
@@ -185,7 +197,13 @@ async function runLoopWorkerFixture(input) {
         fixture_allowed_reason: fixturePolicy.allowed ? fixturePolicy.reason : null
     };
 }
-function buildLoopNarutoWorkGraph(input, workerCount) {
+function buildLoopNarutoWorkGraph(input, workerCount, executionProfile) {
+    const profilePayload = executionProfile ? {
+        mode: executionProfile.mode,
+        agent_role_strategy: executionProfile.agent_role_strategy,
+        artifact_path: executionProfile.artifact_path,
+        agent_type_probe_artifact_path: executionProfile.agent_type_probe_artifact_path
+    } : undefined;
     const workItems = Array.from({ length: Math.max(1, workerCount) }, (_, index) => {
         const id = `${input.node.loop_id}-${input.phase}-${index + 1}`;
         const writeAllowed = input.phase === 'maker';
@@ -214,7 +232,8 @@ function buildLoopNarutoWorkGraph(input, workerCount) {
                 mode: input.worktree?.path ? 'patch-envelope-only' : 'git-worktree',
                 required: input.node.worktree.required,
                 allocation_required: false
-            }
+            },
+            ...(profilePayload ? { codex_app_execution_profile: profilePayload } : {})
         };
     });
     return {
@@ -235,6 +254,7 @@ function buildLoopNarutoWorkGraph(input, workerCount) {
             worktree_root: null,
             fallback_reason: input.worktree?.path ? 'loop_worktree_already_allocated' : null
         },
+        ...(profilePayload ? { codex_app_execution_profile: profilePayload } : {}),
         blockers: [],
         ok: true
     };