sneakoscope 3.1.4 → 3.1.5

package/dist/core/codex-app/codex-skill-sync.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -72,20 +71,93 @@ function skillName(value) {
     return value.replace(/^\$/, '').toLowerCase();
 }
 function skillContent(name) {
+    const profile = skillProfile(name);
     const body = [
         '---',
         `name: ${name}`,
-        `description: SKS managed Codex App route bridge for $${name}.`,
+        `description: SKS managed Codex App route bridge for ${profile.command}.`,
         '---',
         '',
         '<!-- BEGIN SKS MANAGED SKILL -->',
-        `Invoke the matching SKS route for $${name}. Do not overwrite user or LazyCodex/OmO skills.`,
+        `Command: ${profile.command}`,
+        `Purpose: ${profile.purpose}`,
+        `Use when: ${profile.when}`,
+        `Evidence: ${profile.evidence}`,
+        'Safety: keep route state bounded, preserve user and LazyCodex/OmO skills, and stop on hard blockers instead of fabricating fallback behavior.',
+        `Fallback: ${profile.fallback}`,
         `checksum: ${hash(name)}`,
         '<!-- END SKS MANAGED SKILL -->',
         ''
     ].join('\n');
     return body;
 }
+function skillProfile(name) {
+    const table = {
+        loop: {
+            command: '$Loop',
+            purpose: 'compile persisted route work into bounded loop plans with continuation evidence.',
+            when: 'a mission needs stage-by-stage execution, memory hints, or resume-safe artifacts.',
+            evidence: '.sneakoscope/loops/** plus codex-app-execution-profile.json',
+            fallback: 'use message-role routing when native agent_type is not verified.'
+        },
+        naruto: {
+            command: '$Naruto',
+            purpose: 'fan out bounded native worker lanes for high-scale review or implementation.',
+            when: 'parallel lanes are explicitly selected by the route and parent integration remains owner.',
+            evidence: 'naruto work graph, worker ledgers, and execution profile payloads.',
+            fallback: 'degrade to message-role workers without dropping proof artifacts.'
+        },
+        'qa-loop': {
+            command: '$QA-LOOP',
+            purpose: 'dogfood UI/API behavior with gate artifacts and current execution profile.',
+            when: 'route completion needs human-proxy verification or app handoff checks.',
+            evidence: 'qa-loop gate/result ledgers and codex-app-execution-profile.json.',
+            fallback: 'record the unavailable surface as blocked rather than inventing visual proof.'
+        },
+        research: {
+            command: '$Research',
+            purpose: 'run evidence-bound research cycles with source routing and synthesis ledgers.',
+            when: 'the request depends on discovery, evaluation, or external-source claims.',
+            evidence: 'research plan, source ledger, cycle record, and execution profile routing.',
+            fallback: 'mark unavailable source tools explicitly and avoid unsupported live-accuracy claims.'
+        },
+        dfix: {
+            command: '$DFix',
+            purpose: 'perform tiny direct fixes without the full Team route.',
+            when: 'copy/config/docs/labels/spacing/translation/mechanical edits are truly narrow.',
+            evidence: 'focused diff plus DFix Honest check.',
+            fallback: 'route broad implementation through Team/Loop instead.'
+        },
+        'image-ux-review': {
+            command: '$Image-UX-Review',
+            purpose: 'produce generated annotated UI review images and extract issue ledgers.',
+            when: 'visual UX critique is requested from screenshots or app captures.',
+            evidence: 'source inventory, generated annotation images, extracted issue ledger.',
+            fallback: 'block if raster annotation cannot be produced.'
+        },
+        'computer-use': {
+            command: '$Computer-Use',
+            purpose: 'operate native macOS desktop apps through the fast Computer Use lane.',
+            when: 'the task depends on non-web desktop UI or OS settings.',
+            evidence: 'desktop interaction notes/screenshots where available.',
+            fallback: 'use Browser/Chrome only for web targets.'
+        },
+        'init-deep': {
+            command: '$Init-Deep',
+            purpose: 'refresh project-local memory, directory AGENTS sections, and loop memory hints.',
+            when: 'a route needs deeper local context or directory-specific instruction recall.',
+            evidence: '.sneakoscope/context/AGENTS.generated.md and managed directory AGENTS blocks.',
+            fallback: 'preserve user content and skip directories that cannot be safely updated.'
+        }
+    };
+    return table[name] || {
+        command: `$${name}`,
+        purpose: 'bridge an SKS managed Codex App route.',
+        when: 'the matching SKS route is explicitly requested.',
+        evidence: '.sneakoscope route artifacts.',
+        fallback: 'record blockers with evidence.'
+    };
+}
 function hash(value) {
     return crypto.createHash('sha256').update(`sks-skill:${value}`).digest('hex').slice(0, 12);
 }

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

@@ -1,7 +1,14 @@
-// @ts-nocheck
 import path from 'node:path';
-import { nowIso, writeJsonAtomic } from '../fsx.js';
-export function buildLazyCodexPatternAnalysis() {
+import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { analyzeLazyCodexLiveSource } from './lazycodex-live-analyzer.js';
+export function buildLazyCodexPatternAnalysis(live = null) {
+    const liveByPattern = new Map(live?.patterns.map((row) => [row.id, row]) || []);
+    const liveEvidenceByPattern = new Map();
+    for (const row of live?.evidence || []) {
+        const list = liveEvidenceByPattern.get(row.pattern_id) || [];
+        list.push(`${row.file}:${row.lines?.join('-') || 'unknown'}:${row.snippet_hash}`);
+        liveEvidenceByPattern.set(row.pattern_id, list);
+    }
     return {
         schema: 'sks.lazycodex-pattern-analysis.v1',
         source_repo: 'code-yeongyu/lazycodex',
@@ -21,28 +28,42 @@ export function buildLazyCodexPatternAnalysis() {
             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: []
+        ].map((row) => {
+            const livePattern = liveByPattern.get(row.id);
+            const liveEvidence = liveEvidenceByPattern.get(row.id) || [];
+            return {
+                ...row,
+                evidence: [...row.evidence, ...liveEvidence],
+                confidence: liveEvidence.length ? 'high' : livePattern ? 'medium' : 'low',
+                live_evidence: liveEvidence
+            };
+        }),
+        blockers: live?.blockers || [],
+        warnings: live?.warnings || (live ? [] : ['live_analysis_not_available_static_only']),
+        live_analysis_path: live ? '.sneakoscope/reports/lazycodex-live-analysis.json' : null
     };
 }
 export async function writeLazyCodexPatternAnalysis(root) {
-    const report = buildLazyCodexPatternAnalysis();
+    const live = await analyzeLazyCodexLiveSource({ root, writeReport: true }).catch(() => null);
+    const report = buildLazyCodexPatternAnalysis(live);
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-analysis.json'), report);
+    await writeTextAtomic(path.join(root, 'docs', 'lazycodex-analysis.md'), renderLazyCodexAnalysisMarkdown(report)).catch(() => undefined);
     return report;
 }
 export function renderLazyCodexAnalysisMarkdown(report) {
-    const rows = report.patterns.map((p) => `| ${p.id} | ${p.sks_adoption} | ${p.rationale.replace(/\|/g, '\\|')} |`).join('\n');
+    const rows = report.patterns.map((p) => `| ${p.id} | ${p.sks_adoption} | ${p.confidence} | ${p.live_evidence.length} | ${p.rationale.replace(/\|/g, '\\|')} |`).join('\n');
     return [
         '# LazyCodex / OmO Pattern Analysis',
         '',
         `Source repo: \`${report.source_repo}\``,
         `Analyzed at: \`${report.analyzed_at}\``,
+        `Live analysis: \`${report.live_analysis_path || 'not available'}\``,
         '',
-        '| Pattern | Adoption | Rationale |',
-        '|---|---|---|',
+        '| Pattern | Adoption | Confidence | Live Evidence | 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.'
+        'This artifact combines static directive mapping with hashed current-source evidence when available. Long source excerpts are intentionally omitted.'
     ].join('\n');
 }
 function pattern(id, title, evidence, sks_adoption, rationale, target_modules) {

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -6,7 +5,7 @@ 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 inventory = normalizeInventory(input.inventory || await buildCodexPluginInventory().catch((err) => ({ plugins: [], blockers: [messageOf(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());
@@ -36,6 +35,18 @@ export async function buildLazyCodexInteropPolicy(input) {
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-interop-policy.json'), report).catch(() => undefined);
     return report;
 }
+function normalizeInventory(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return { plugins: [], blockers: [] };
+    const record = value;
+    return {
+        plugins: Array.isArray(record.plugins) ? record.plugins.map((plugin) => plugin && typeof plugin === 'object' ? plugin : {}) : [],
+        blockers: Array.isArray(record.blockers) ? record.blockers.map(String) : []
+    };
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 async function discoverSkillNames(roots) {
     const names = new Set();
     for (const root of roots) {

package/dist/core/codex-app/lazycodex-live-analyzer.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+const PATTERNS = [
+    { id: 'npx-no-global-install', claim: 'npx install command evidence', re: /\bnpx\b.+(?:lazycodex|omo|oh-my-openagent)/i },
+    { id: 'codex-marketplace-plugin', claim: 'Codex marketplace install command evidence', re: /\bcodex\b.+(?:plugin|marketplace).+(?:add|install)/i },
+    { id: 'startup-review-hooks', claim: 'Hook approval statement evidence', re: /\bhook\b.+\b(approval|approve|review|trusted|trust)\b/i },
+    { id: 'doctor-health-report', claim: 'Doctor health report evidence', re: /\bdoctor\b.+\b(health|report|check)\b/i },
+    { id: 'plan-start-loop', claim: '$ulw-loop/$ulw-plan/$start-work command evidence', re: /\$(?:ulw-loop|ulw-plan|start-work)\b/ },
+    { id: 'init-deep-agents', claim: '$init-deep evidence', re: /\$init-deep\b|init-deep/i },
+    { id: 'native-agent-type', claim: 'agent_type fallback evidence', re: /\bagent_type\b|message[- ]role|fallback/i }
+];
+export async function analyzeLazyCodexLiveSource(input) {
+    const root = path.resolve(input.root);
+    const sourceDir = input.sourceDir ? path.resolve(input.sourceDir) : path.join(root, '.sneakoscope', 'cache', 'lazycodex');
+    const files = ['README.md', 'package.json', 'bin/lazycodex-ai.js', '.gitmodules'];
+    const evidence = [];
+    const blockers = [];
+    for (const rel of files) {
+        const file = path.join(sourceDir, rel);
+        const text = await fs.readFile(file, 'utf8').catch(() => '');
+        if (!text)
+            continue;
+        evidence.push(...extractEvidence(rel, text));
+    }
+    if (!evidence.length)
+        blockers.push(`lazycodex_source_evidence_missing:${sourceDir}`);
+    const sourceSha = await gitSha(sourceDir);
+    const patterns = PATTERNS.map((pattern) => ({
+        id: pattern.id,
+        title: pattern.claim,
+        evidence: evidence.filter((row) => row.pattern_id === pattern.id).map((row) => `${row.file}:${row.lines?.join('-') || 'unknown'}:${row.snippet_hash}`),
+        sks_adoption: pattern.id === 'native-agent-type' || pattern.id === 'startup-review-hooks' || pattern.id === 'doctor-health-report' ? 'adopt' : 'adapt',
+        rationale: evidence.some((row) => row.pattern_id === pattern.id) ? 'Live source evidence found and hashed.' : 'No live source evidence found; keep static analysis as lower confidence.',
+        target_modules: []
+    }));
+    const report = {
+        schema: 'sks.lazycodex-live-analysis.v1',
+        generated_at: nowIso(),
+        source_repo: 'code-yeongyu/lazycodex',
+        source_ref: input.sourceRef || sourceSha || 'local-snapshot',
+        source_sha: sourceSha,
+        evidence,
+        patterns,
+        blockers,
+        warnings: blockers.length ? ['live_evidence_incomplete_static_fallback_required'] : []
+    };
+    if (input.writeReport !== false) {
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-live-analysis.json'), report).catch(() => undefined);
+        await writeTextAtomic(path.join(root, 'docs', 'lazycodex-analysis.md'), renderLazyCodexLiveMarkdown(report)).catch(() => undefined);
+    }
+    return report;
+}
+export function extractEvidence(file, text) {
+    const lines = text.split(/\r?\n/);
+    const rows = [];
+    for (const pattern of PATTERNS) {
+        const index = lines.findIndex((line) => pattern.re.test(line));
+        if (index < 0)
+            continue;
+        const snippet = lines.slice(Math.max(0, index - 1), Math.min(lines.length, index + 2)).join('\n').slice(0, 500);
+        rows.push({
+            pattern_id: pattern.id,
+            file,
+            lines: [index + 1, index + 1],
+            snippet_hash: createHash('sha256').update(snippet).digest('hex'),
+            claim: pattern.claim,
+            confidence: 'high'
+        });
+    }
+    return rows;
+}
+export function renderLazyCodexLiveMarkdown(report) {
+    const rows = report.evidence.map((row) => `| ${row.pattern_id} | ${row.file} | ${row.lines?.join('-') || '-'} | ${row.snippet_hash.slice(0, 16)} | ${row.confidence} |`).join('\n');
+    return [
+        '# LazyCodex / OmO Pattern Analysis',
+        '',
+        `Source repo: \`${report.source_repo}\``,
+        `Source ref: \`${report.source_ref}\``,
+        `Source sha: \`${report.source_sha || 'unknown'}\``,
+        `Generated at: \`${report.generated_at}\``,
+        '',
+        '| Pattern | File | Lines | Snippet Hash | Confidence |',
+        '|---|---|---:|---|---|',
+        rows || '| none | - | - | - | low |',
+        '',
+        'Long source excerpts are intentionally omitted; release artifacts store line anchors and snippet hashes only.'
+    ].join('\n');
+}
+async function gitSha(sourceDir) {
+    const head = await fs.readFile(path.join(sourceDir, '.git', 'HEAD'), 'utf8').catch(() => '');
+    const ref = head.match(/^ref:\s*(.+)$/m)?.[1];
+    if (ref)
+        return (await fs.readFile(path.join(sourceDir, '.git', ref), 'utf8').catch(() => '')).trim() || null;
+    return /^[0-9a-f]{40}$/i.test(head.trim()) ? head.trim() : null;
+}
+//# sourceMappingURL=lazycodex-live-analyzer.js.map

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

@@ -28,17 +28,52 @@ export async function madHighCommand(args = [], deps = {}) {
     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 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, {});
+    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'}`);

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-zellij-repair.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
 export async function runDoctorZellijRepair(input) {
     const args = (input.args || []).map(String);
@@ -10,6 +9,7 @@ export async function runDoctorZellijRepair(input) {
         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
@@ -18,6 +18,10 @@ export async function runDoctorZellijRepair(input) {
 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')) {

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.4';
+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/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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { loopPlanPath } from './loop-artifacts.js';
@@ -8,9 +7,9 @@ export async function evaluateLoopContinuation(input) {
     const blockers = [];
     if (!plan)
         blockers.push('loop_plan_missing');
-    const nodes = plan?.graph?.nodes || [];
+    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) => proof?.status === 'completed').length;
+    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 = {
@@ -29,4 +28,13 @@ export async function evaluateLoopContinuation(input) {
     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,7 +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';
+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));
@@ -53,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,
@@ -64,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,
@@ -176,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