sneakoscope 3.1.5 → 3.1.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.1.5",
+  "version": "3.1.7",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -55,7 +55,7 @@
     "agent:janitor": "node ./dist/scripts/agent-janitor-check.js",
     "agent:multi-project-isolation": "node ./dist/scripts/agent-multi-project-isolation-check.js",
     "verification:parallel-engine": "node ./dist/scripts/parallel-verification-engine-check.js",
-    "release:check:parallel": "npm run build --silent && node ./dist/scripts/release-check-stamp.js write && node ./dist/scripts/release-parallel-check.js",
+    "release:check:parallel": "npm run build --silent && node ./dist/scripts/release-parallel-check.js && node ./dist/scripts/release-check-stamp.js write",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "typecheck:suppressions": "node ./dist/scripts/check-ts-suppressions.js",
     "typescript:migration-report": "node ./dist/scripts/typescript-migration-report.js",
@@ -819,7 +819,6 @@
     "mad:zellij-self-heal-blackbox": "node ./dist/scripts/mad-zellij-self-heal-blackbox.js",
     "mad:zellij-headless-fallback-blackbox": "node ./dist/scripts/mad-zellij-headless-fallback-blackbox.js",
     "mad:zellij-no-contradictory-output": "node ./dist/scripts/mad-zellij-no-contradictory-output-check.js",
-    "lazycodex:analysis": "node ./dist/scripts/lazycodex-analysis-check.js",
     "codex-app:harness-matrix": "node ./dist/scripts/codex-app-harness-matrix-check.js",
     "doctor:codex-app-harness": "node ./dist/scripts/doctor-codex-app-harness-check.js",
     "codex-app:skill-sync": "node ./dist/scripts/codex-skill-sync-check.js",
@@ -829,9 +828,7 @@
     "codex-app:hook-lifecycle": "node ./dist/scripts/codex-hook-lifecycle-check.js",
     "loop:continuation-enforcer": "node ./dist/scripts/loop-continuation-enforcer-check.js",
     "codex-app:execution-profile": "node ./dist/scripts/codex-app-execution-profile-check.js",
-    "lazycodex:interop-policy": "node ./dist/scripts/lazycodex-interop-policy-check.js",
     "codex-app:harness-blackbox": "node ./dist/scripts/codex-app-harness-blackbox.js",
-    "lazycodex:pattern-adoption-blackbox": "node ./dist/scripts/lazycodex-pattern-adoption-blackbox.js",
     "codex-app:skill-agent-blackbox": "node ./dist/scripts/codex-app-skill-agent-blackbox.js",
     "lint:no-ts-nocheck-core": "node ./dist/scripts/no-ts-nocheck-core-check.js",
     "codex-app:type-safety": "node ./dist/scripts/codex-app-type-safety-check.js",
@@ -845,9 +842,6 @@
     "codex-app:agent-type-probe": "node ./dist/scripts/codex-agent-type-probe-check.js",
     "codex-app:agent-type-routing": "node ./dist/scripts/codex-agent-type-routing-check.js",
     "codex-app:agent-type-blackbox": "node ./dist/scripts/codex-agent-type-blackbox.js",
-    "lazycodex:live-analysis": "node ./dist/scripts/lazycodex-live-analysis-check.js",
-    "lazycodex:analysis-with-evidence": "node ./dist/scripts/lazycodex-analysis-with-evidence-check.js",
-    "lazycodex:live-analysis-blackbox": "node ./dist/scripts/lazycodex-live-analysis-blackbox.js",
     "codex-app:init-deep-managed-agents": "node ./dist/scripts/codex-init-deep-managed-agents-check.js",
     "loop:planner-project-memory-deep": "node ./dist/scripts/loop-planner-project-memory-deep-check.js",
     "codex-app:init-deep-directory-local-blackbox": "node ./dist/scripts/codex-init-deep-directory-local-blackbox.js",
@@ -856,7 +850,47 @@
     "research:execution-profile-routing": "node ./dist/scripts/research-execution-profile-routing-check.js",
     "pipeline:execution-profile-routing-blackbox": "node ./dist/scripts/pipeline-execution-profile-routing-blackbox.js",
     "codex-app:skill-rich-content": "node ./dist/scripts/codex-skill-rich-content-check.js",
-    "codex-app:agent-role-rich-content": "node ./dist/scripts/codex-agent-role-rich-content-check.js"
+    "codex-app:agent-role-rich-content": "node ./dist/scripts/codex-agent-role-rich-content-check.js",
+    "brand-neutrality:rename-map": "node ./dist/scripts/brand-neutrality-rename-map-check.js",
+    "brand-neutrality:zero-leakage": "node ./dist/scripts/brand-neutrality-zero-leakage-check.js",
+    "brand-neutrality:zero-leakage-blackbox": "node ./dist/scripts/brand-neutrality-zero-leakage-blackbox.js",
+    "brand-neutrality:generated-artifacts": "node ./dist/scripts/brand-neutrality-generated-artifacts-check.js",
+    "docs:brand-neutrality": "node ./dist/scripts/docs-brand-neutrality-check.js",
+    "codex-native:feature-broker": "node ./dist/scripts/codex-native-feature-broker-check.js",
+    "codex-native:harness-compat": "node ./dist/scripts/codex-native-harness-compat-check.js",
+    "codex-native:invocation-defaults": "node ./dist/scripts/codex-native-invocation-defaults-check.js",
+    "codex-native:invocation-router": "node ./dist/scripts/codex-native-invocation-router-check.js",
+    "codex-native:route-map": "node ./dist/scripts/codex-native-route-map-check.js",
+    "pipeline:codex-native-loop-routing": "node ./dist/scripts/pipeline-codex-native-loop-routing-check.js",
+    "pipeline:codex-native-qa-routing": "node ./dist/scripts/pipeline-codex-native-qa-routing-check.js",
+    "pipeline:codex-native-research-routing": "node ./dist/scripts/pipeline-codex-native-research-routing-check.js",
+    "pipeline:codex-native-image-routing": "node ./dist/scripts/pipeline-codex-native-image-routing-check.js",
+    "pipeline:codex-native-doctor-mad-routing": "node ./dist/scripts/pipeline-codex-native-doctor-mad-routing-check.js",
+    "pipeline:codex-native-loop-routing-real-blackbox": "node ./dist/scripts/pipeline-codex-native-loop-routing-real-blackbox.js",
+    "pipeline:codex-native-qa-routing-real-blackbox": "node ./dist/scripts/pipeline-codex-native-qa-routing-real-blackbox.js",
+    "pipeline:codex-native-research-routing-real-blackbox": "node ./dist/scripts/pipeline-codex-native-research-routing-real-blackbox.js",
+    "pipeline:codex-native-image-routing-real-blackbox": "node ./dist/scripts/pipeline-codex-native-image-routing-real-blackbox.js",
+    "pipeline:codex-native-doctor-mad-routing-real-blackbox": "node ./dist/scripts/pipeline-codex-native-doctor-mad-routing-real-blackbox.js",
+    "codex-native:pattern-analysis": "node ./dist/scripts/codex-native-pattern-analysis-check.js",
+    "codex-native:reference-cache": "node ./dist/scripts/codex-native-reference-cache-check.js",
+    "codex-native:reference-cache-blackbox": "node ./dist/scripts/codex-native-reference-cache-blackbox.js",
+    "codex-native:reference-evidence": "node ./dist/scripts/codex-native-reference-evidence-check.js",
+    "codex-native:pattern-analysis-blackbox": "node ./dist/scripts/codex-native-pattern-analysis-blackbox.js",
+    "codex-native:interop-policy": "node ./dist/scripts/codex-native-interop-policy-check.js",
+    "codex-native:skill-content": "node ./dist/scripts/codex-native-skill-content-check.js",
+    "codex-native:agent-role-content": "node ./dist/scripts/codex-native-agent-role-content-check.js",
+    "codex-native:hook-lifecycle-proof": "node ./dist/scripts/codex-native-hook-lifecycle-proof-check.js",
+    "codex-native:broker-read-only": "node ./dist/scripts/codex-native-broker-read-only-check.js",
+    "codex-native:repair-transaction": "node ./dist/scripts/codex-native-repair-transaction-check.js",
+    "codex-native:read-repair-split-blackbox": "node ./dist/scripts/codex-native-read-repair-split-blackbox.js",
+    "init-deep:backup-retention": "node ./dist/scripts/init-deep-backup-retention-check.js",
+    "init-deep:memory-scope-safety": "node ./dist/scripts/init-deep-memory-scope-safety-check.js",
+    "release-scripts:type-safe": "node ./dist/scripts/release-script-type-safety-check.js",
+    "lint:no-ts-nocheck-release-scripts": "node ./dist/scripts/no-ts-nocheck-release-scripts-check.js",
+    "doctor:codex-native-readiness-ux": "node ./dist/scripts/doctor-codex-native-readiness-ux-check.js",
+    "doctor:codex-native-repair-actions": "node ./dist/scripts/doctor-codex-native-repair-actions-check.js",
+    "codex-native:feature-broker-blackbox": "node ./dist/scripts/codex-native-feature-broker-blackbox.js",
+    "pipeline:codex-native-e2e-blackbox": "node ./dist/scripts/pipeline-codex-native-e2e-blackbox.js"
   },
   "keywords": [
     "sneakoscope",
@@ -864,10 +898,7 @@
     "sks",
     "openai",
     "openai-codex",
-    "openclaw",
-    "openclaw-skill",
-    "hermes-agent",
-    "hermes-skill",
+    "codex-native",
     "cli",
     "developer-tools",
     "ai-coding",

package/dist/cli/hermes-command.js

@@ -1,99 +0,0 @@
-import path from 'node:path';
-import { HERMES_SKILL_NAME, buildHermesSkillFiles, defaultHermesSkillDir, installHermesSkill } from '../core/hermes.js';
-import { exists } from '../core/fsx.js';
-const flag = (args, name) => args.includes(name);
-function readFlagValue(args, name, fallback) {
-    const i = args.indexOf(name);
-    return i >= 0 && args[i + 1] ? args[i + 1] : fallback;
-}
-function positionalArgs(args = []) {
-    const out = [];
-    const valueFlags = new Set(['--dir']);
-    for (let i = 0; i < args.length; i++) {
-        const arg = String(args[i]);
-        if (valueFlags.has(arg)) {
-            i++;
-            continue;
-        }
-        if (!arg.startsWith('--'))
-            out.push(arg);
-    }
-    return out;
-}
-export async function hermesCommand(args = []) {
-    const action = args[0] || 'help';
-    const targetDir = readFlagValue(args, '--dir', defaultHermesSkillDir());
-    const resultOptions = {
-        targetDir,
-        force: flag(args, '--force'),
-        dryRun: flag(args, '--dry-run')
-    };
-    if (action === 'path') {
-        const result = { skill: HERMES_SKILL_NAME, target_dir: path.resolve(targetDir) };
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        console.log(result.target_dir);
-        return;
-    }
-    if (action === 'status') {
-        const files = buildHermesSkillFiles();
-        const target = path.resolve(targetDir);
-        const installed = await exists(path.join(target, 'SKILL.md'));
-        const result = {
-            schema: 'sks.hermes-skill-status.v1',
-            ok: true,
-            skill: HERMES_SKILL_NAME,
-            target_dir: target,
-            installed,
-            expected_files: Object.keys(files),
-            env_mode: 'SKS_HERMES=1',
-            slash_command: `/${HERMES_SKILL_NAME}`
-        };
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        console.log(`Hermes skill: ${installed ? 'installed' : 'not installed'} ${target}`);
-        return;
-    }
-    if (action === 'print') {
-        const files = buildHermesSkillFiles();
-        const file = (positionalArgs(args.slice(1))[0] || 'SKILL.md');
-        if (!files[file]) {
-            console.error(`Unknown Hermes skill file: ${file}`);
-            console.error(`Files: ${Object.keys(files).join(', ')}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(files[file]);
-        return;
-    }
-    if (action === 'install') {
-        const result = await installHermesSkill(resultOptions);
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        if (!result.ok) {
-            console.error(`Hermes skill install blocked: ${result.reason}`);
-            console.error(`Target: ${result.target_dir}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(`Hermes skill ${result.status}: ${result.target_dir}`);
-        console.log(`Use it in Hermes as /${HERMES_SKILL_NAME} and run SKS shell commands with SKS_HERMES=1.`);
-        return;
-    }
-    console.log(`Hermes
-
-Usage:
-  sks hermes install [--dir path] [--force] [--dry-run] [--json]
-  sks hermes status [--dir path] [--json]
-  sks hermes path [--dir path] [--json]
-  sks hermes print [SKILL.md|README.md|hermes-config.example.yaml|skill-bundle.example.yaml]
-
-Default skill: ${HERMES_SKILL_NAME}
-Default path:  ${defaultHermesSkillDir()}
-
-After install, open Hermes and invoke:
-
-/${HERMES_SKILL_NAME} Use SKS in this repository.
-`);
-}
-//# sourceMappingURL=hermes-command.js.map

package/dist/cli/openclaw-command.js

@@ -1,83 +0,0 @@
-import path from 'node:path';
-import { OPENCLAW_SKILL_NAME, buildOpenClawSkillFiles, defaultOpenClawSkillDir, installOpenClawSkill } from '../core/openclaw.js';
-const flag = (args, name) => args.includes(name);
-function readFlagValue(args, name, fallback) {
-    const i = args.indexOf(name);
-    return i >= 0 && args[i + 1] ? args[i + 1] : fallback;
-}
-function positionalArgs(args = []) {
-    const out = [];
-    const valueFlags = new Set(['--dir']);
-    for (let i = 0; i < args.length; i++) {
-        const arg = String(args[i]);
-        if (valueFlags.has(arg)) {
-            i++;
-            continue;
-        }
-        if (!arg.startsWith('--'))
-            out.push(arg);
-    }
-    return out;
-}
-export async function openClawCommand(args = []) {
-    const action = args[0] || 'help';
-    const targetDir = readFlagValue(args, '--dir', defaultOpenClawSkillDir());
-    const resultOptions = {
-        targetDir,
-        force: flag(args, '--force'),
-        dryRun: flag(args, '--dry-run')
-    };
-    if (action === 'path') {
-        const result = { skill: OPENCLAW_SKILL_NAME, target_dir: path.resolve(targetDir) };
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        console.log(result.target_dir);
-        return;
-    }
-    if (action === 'print') {
-        const files = buildOpenClawSkillFiles();
-        const file = (positionalArgs(args.slice(1))[0] || 'SKILL.md');
-        if (!files[file]) {
-            console.error(`Unknown OpenClaw skill file: ${file}`);
-            console.error(`Files: ${Object.keys(files).join(', ')}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(files[file]);
-        return;
-    }
-    if (action === 'install') {
-        const result = await installOpenClawSkill(resultOptions);
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        if (!result.ok) {
-            console.error(`OpenClaw skill install blocked: ${result.reason}`);
-            console.error(`Target: ${result.target_dir}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(`OpenClaw skill ${result.status}: ${result.target_dir}`);
-        console.log(`Attach it to an agent with skills: [${OPENCLAW_SKILL_NAME}] and tools: [shell].`);
-        return;
-    }
-    console.log(`OpenClaw
-
-Usage:
-  sks openclaw install [--dir path] [--force] [--dry-run] [--json]
-  sks openclaw path [--dir path] [--json]
-  sks openclaw print [SKILL.md|manifest.yaml|README.md|openclaw-agent-config.example.yaml]
-
-Default skill: ${OPENCLAW_SKILL_NAME}
-Default path:  ${defaultOpenClawSkillDir()}
-
-After install, add this to an OpenClaw agent config:
-
-agents:
-  coding-agent:
-    tools:
-      - shell
-    skills:
-      - ${OPENCLAW_SKILL_NAME}
-`);
-}
-//# sourceMappingURL=openclaw-command.js.map

package/dist/commands/hermes.js

@@ -1,5 +0,0 @@
-import { hermesCommand } from '../cli/hermes-command.js';
-export async function run(_command, args = []) {
-    return hermesCommand(args);
-}
-//# sourceMappingURL=hermes.js.map

package/dist/commands/openclaw.js

@@ -1,3 +0,0 @@
-import { openClawCommand } from '../cli/openclaw-command.js';
-export async function run(_command, args = []) { return openClawCommand(args); }
-//# sourceMappingURL=openclaw.js.map

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

@@ -1,72 +0,0 @@
-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-live-analyzer.js

@@ -1,98 +0,0 @@
-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