sneakoscope 3.1.3 → 3.1.5

package/dist/core/codex-app/codex-init-deep.js

@@ -0,0 +1,180 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, mergeManagedBlock, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+export async function runCodexInitDeep(input = {}) {
+    const root = path.resolve(input.root || process.cwd());
+    const dirs = await scoreDirectories(root);
+    const selected = dirs.filter((row) => row.score >= 4).slice(0, 12);
+    const contextDir = path.join(root, '.sneakoscope', 'context');
+    const generatedPath = path.join(contextDir, 'AGENTS.generated.md');
+    const markdown = renderGeneratedAgents(selected);
+    const directoryLocalAgents = { created: [], updated: [], skipped: [], backup_paths: [], blockers: [] };
+    if (input.apply === true) {
+        await ensureDir(contextDir);
+        await writeTextAtomic(generatedPath, markdown);
+        if (input.directoryLocal === true) {
+            for (const row of selected) {
+                const agentsPath = path.join(root, row.dir, 'AGENTS.md');
+                try {
+                    await ensureDir(path.dirname(agentsPath));
+                    const existing = await fs.readFile(agentsPath, 'utf8').catch(() => '');
+                    if (existing.trim()) {
+                        const backup = `${agentsPath}.sks-backup-${Date.now()}`;
+                        await fs.copyFile(agentsPath, backup);
+                        directoryLocalAgents.backup_paths.push(path.relative(root, backup));
+                    }
+                    const status = await mergeManagedBlock(agentsPath, 'SKS INIT-DEEP MANAGED SECTION', renderDirectoryAgentsBlock(row));
+                    if (status === 'created')
+                        directoryLocalAgents.created.push(path.relative(root, agentsPath));
+                    else
+                        directoryLocalAgents.updated.push(path.relative(root, agentsPath));
+                }
+                catch (err) {
+                    directoryLocalAgents.skipped.push(path.relative(root, agentsPath));
+                    directoryLocalAgents.blockers.push(`${path.relative(root, agentsPath)}:${messageOf(err)}`);
+                }
+            }
+        }
+    }
+    const report = {
+        schema: 'sks.codex-init-deep.v1',
+        generated_at: nowIso(),
+        ok: directoryLocalAgents.blockers.length === 0,
+        apply: input.apply === true,
+        root,
+        generated_path: path.relative(root, generatedPath),
+        root_agents_preserved: true,
+        directory_guidance: selected,
+        directory_local_agents: directoryLocalAgents,
+        blockers: directoryLocalAgents.blockers
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-init-deep.json'), report).catch(() => undefined);
+    return report;
+}
+export async function readInitDeepMemory(root) {
+    const file = path.join(root, '.sneakoscope', 'context', 'AGENTS.generated.md');
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    return text.trim() ? { path: file, text } : null;
+}
+export async function readInitDeepMemoryHints(root, scopePaths = []) {
+    const resolvedRoot = path.resolve(root);
+    const hints = [];
+    const generated = await readInitDeepMemory(resolvedRoot).catch(() => null);
+    if (generated) {
+        hints.push({
+            path: path.relative(resolvedRoot, generated.path),
+            scope: '.',
+            summary: generated.text.split(/\r?\n/).filter((line) => /^##\s+/.test(line)).slice(0, 8).join(' | ')
+        });
+    }
+    const candidateDirs = new Set();
+    for (const scopePath of scopePaths) {
+        const absolute = path.resolve(resolvedRoot, scopePath);
+        if (!absolute.startsWith(resolvedRoot))
+            continue;
+        const stat = await fs.stat(absolute).catch(() => null);
+        let dir = stat?.isFile() ? path.dirname(absolute) : absolute;
+        while (dir.startsWith(resolvedRoot)) {
+            candidateDirs.add(dir);
+            if (dir === resolvedRoot)
+                break;
+            dir = path.dirname(dir);
+        }
+    }
+    for (const dir of [...candidateDirs].sort((a, b) => b.length - a.length)) {
+        const file = path.join(dir, 'AGENTS.md');
+        const text = await fs.readFile(file, 'utf8').catch(() => '');
+        if (!text.trim())
+            continue;
+        const managed = extractManagedSection(text, 'SKS INIT-DEEP MANAGED SECTION');
+        const userSummary = text.replace(/<!-- BEGIN [\s\S]*?<!-- END [^>]+-->/g, '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 4).join(' | ');
+        const summary = [managed ? managed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 4).join(' | ') : '', userSummary ? `user:${userSummary}` : ''].filter(Boolean).join(' || ');
+        if (summary) {
+            hints.push({
+                path: path.relative(resolvedRoot, file),
+                scope: path.relative(resolvedRoot, dir) || '.',
+                summary
+            });
+        }
+    }
+    const unique = new Map();
+    for (const hint of hints)
+        unique.set(`${hint.path}:${hint.scope}`, hint);
+    return [...unique.values()].slice(0, 12);
+}
+async function scoreDirectories(root) {
+    const counts = new Map();
+    await walk(path.join(root, 'src'), root, counts);
+    await walk(path.join(root, 'docs'), root, counts);
+    const highRisk = [/src\/core\/zellij/, /src\/core\/loops/, /src\/core\/codex-app/, /src\/commands/];
+    return [...counts.entries()].map(([dir, value]) => {
+        const risky = highRisk.some((re) => re.test(dir));
+        const score = Math.min(10, Math.ceil(value.file_count / 6) + value.langs.size + (risky ? 3 : 0));
+        return {
+            dir,
+            file_count: value.file_count,
+            languages: [...value.langs].sort(),
+            score,
+            guidance: risky ? 'High-risk SKS runtime area; hydrate TriWiki/current source before edits.' : 'Use local source conventions and keep changes owner-scoped.'
+        };
+    }).sort((a, b) => b.score - a.score || a.dir.localeCompare(b.dir));
+}
+async function walk(dir, root, counts, depth = 0) {
+    if (depth > 3)
+        return;
+    const rows = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const row of rows) {
+        const full = path.join(dir, row.name);
+        if (row.isDirectory()) {
+            if (!['node_modules', 'dist', '.git'].includes(row.name))
+                await walk(full, root, counts, depth + 1);
+        }
+        else if (row.isFile()) {
+            const relDir = path.relative(root, path.dirname(full)).split(path.sep).join('/');
+            const entry = counts.get(relDir) || { file_count: 0, langs: new Set() };
+            entry.file_count += 1;
+            entry.langs.add(path.extname(row.name).replace(/^\./, '') || 'text');
+            counts.set(relDir, entry);
+        }
+    }
+}
+function renderGeneratedAgents(rows) {
+    return [
+        '# SKS Init-Deep Generated Context',
+        '',
+        'This file is generated under `.sneakoscope/context` so user-authored `AGENTS.md` files are preserved.',
+        '',
+        ...rows.flatMap((row) => [
+            `## ${row.dir}`,
+            '',
+            `- Files: ${row.file_count}`,
+            `- Languages: ${row.languages.join(', ') || 'unknown'}`,
+            `- Guidance: ${row.guidance}`,
+            ''
+        ])
+    ].join('\n');
+}
+function renderDirectoryAgentsBlock(row) {
+    return [
+        `# SKS Init-Deep Local Guidance: ${row.dir}`,
+        '',
+        `- Files observed: ${row.file_count}`,
+        `- Languages: ${row.languages.join(', ') || 'unknown'}`,
+        `- Guidance: ${row.guidance}`,
+        '- Preserve user-authored content outside this managed block.',
+        '- Hydrate TriWiki/current source before risky edits in this directory.'
+    ].join('\n');
+}
+function extractManagedSection(text, markerName) {
+    const begin = `<!-- BEGIN ${markerName} -->`;
+    const end = `<!-- END ${markerName} -->`;
+    const beginIdx = text.indexOf(begin);
+    const endIdx = text.indexOf(end);
+    if (beginIdx < 0 || endIdx < beginIdx)
+        return '';
+    return text.slice(beginIdx + begin.length, endIdx).trim();
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=codex-init-deep.js.map

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

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+const SKS_SKILLS = [
+    '$Loop',
+    '$Naruto',
+    '$QA-LOOP',
+    '$Research',
+    '$DFix',
+    '$Image-UX-Review',
+    '$Computer-Use',
+    '$Init-Deep'
+];
+const LAZYCODEX_RESERVED = new Set(['ulw-loop', 'ulw-plan', 'start-work']);
+export async function syncCodexSksSkills(input) {
+    const root = path.resolve(input.root);
+    const skillsRoot = input.skillsRoot || path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'skills');
+    const existing = await listSkillNames(skillsRoot);
+    const collisions = existing.filter((name) => LAZYCODEX_RESERVED.has(name));
+    const desired = SKS_SKILLS.map((skill) => skillName(skill));
+    const created = [];
+    const skipped = [];
+    if (input.apply === true) {
+        await ensureDir(skillsRoot);
+        for (const name of desired) {
+            if (LAZYCODEX_RESERVED.has(name)) {
+                skipped.push(name);
+                continue;
+            }
+            const dir = path.join(skillsRoot, name);
+            const file = path.join(dir, 'SKILL.md');
+            const content = skillContent(name);
+            const current = await fs.readFile(file, 'utf8').catch(() => '');
+            if (current && !current.includes('BEGIN SKS MANAGED SKILL')) {
+                skipped.push(name);
+                continue;
+            }
+            await ensureDir(dir);
+            await writeTextAtomic(file, content);
+            created.push(file);
+        }
+    }
+    const report = {
+        schema: 'sks.codex-skill-sync.v1',
+        generated_at: nowIso(),
+        ok: true,
+        apply: input.apply === true,
+        skills_root: skillsRoot,
+        desired_skills: desired,
+        existing_skills: existing,
+        created,
+        skipped,
+        lazycodex_reserved_present: collisions,
+        interop: {
+            mode: 'coexist',
+            clobbered_lazycodex: false,
+            clobbered_user_skills: false
+        },
+        blockers: []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-skill-sync.json'), report).catch(() => undefined);
+    return report;
+}
+async function listSkillNames(root) {
+    const rows = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    return rows.filter((row) => row.isDirectory()).map((row) => row.name).sort();
+}
+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 ${profile.command}.`,
+        '---',
+        '',
+        '<!-- BEGIN SKS MANAGED SKILL -->',
+        `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);
+}
+//# sourceMappingURL=codex-skill-sync.js.map

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

@@ -0,0 +1,72 @@
+import path from 'node:path';
+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',
+        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'])
+        ].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 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.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 | Confidence | Live Evidence | Rationale |',
+        '|---|---|---|---:|---|',
+        rows,
+        '',
+        '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) {
+    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,60 @@
+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 = 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());
+    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;
+}
+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) {
+        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/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/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);