sneakoscope 3.1.4 → 3.1.6

package/dist/core/codex-native/codex-native-feature-broker.js

@@ -0,0 +1,182 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { codexAppIntegrationStatus } from '../codex-app.js';
+import { syncCodexAgentRoles } from '../codex-app/codex-agent-role-sync.js';
+import { probeCodexAgentTypeSupport } from '../codex-app/codex-agent-type-probe.js';
+import { probeCodexHookApprovalState } from '../codex-app/codex-hook-approval-probe.js';
+import { syncCodexSksSkills } from '../codex-app/codex-skill-sync.js';
+import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
+import { detectCodex0139Capability } from '../codex-control/codex-0139-capability.js';
+import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+import { buildMcpPluginServerCandidates } from '../mcp/mcp-plugin-inventory.js';
+import { codexNativeFeatureState, computeCodexNativeInvocationDefaults } from './codex-native-feature-matrix.js';
+const REPORT_PATH = '.sneakoscope/reports/codex-native-feature-matrix.json';
+export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd() }) {
+    const root = path.resolve(input.root || process.cwd());
+    const fixtureMode = process.env.SKS_CODEX_0138_FAKE === '1' || process.env.SKS_CODEX_0139_FAKE === '1' || process.env.SKS_CODEX_PLUGIN_JSON_FAKE === '1';
+    const codexBin = fixtureMode ? process.env.CODEX_BIN || 'codex' : await findCodexBinary().catch(() => null);
+    const version = codexBin ? await codexVersion(codexBin) : null;
+    const cap0138 = await detectCodex0138Capability({ codexBin }).catch((err) => ({ blockers: [messageOf(err)] }));
+    const cap0139 = await detectCodex0139Capability({ codexBin }).catch((err) => ({ blockers: [messageOf(err)] }));
+    const app = await codexAppIntegrationStatus({ codex: { bin: codexBin, version, available: Boolean(codexBin) } }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+    const plugins = await buildCodexPluginInventory().catch((err) => ({
+        schema: 'sks.codex-plugin-inventory.v1',
+        generated_at: nowIso(),
+        codex_0138_capability: null,
+        fetch_concurrency: 0,
+        detail_fetch_count: 0,
+        detail_fetch_failed_count: 0,
+        duration_ms: 0,
+        plugins: [],
+        marketplace_available: false,
+        blockers: [messageOf(err)]
+    }));
+    const mcpCandidates = buildMcpPluginServerCandidates(plugins);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'codex-plugin-inventory.json'), plugins).catch(() => undefined);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'mcp-plugin-server-candidates.json'), mcpCandidates).catch(() => undefined);
+    const hookApproval = await probeCodexHookApprovalState(root, { codexBin }).catch((err) => ({
+        schema: 'sks.codex-hook-approval-probe.v1',
+        generated_at: nowIso(),
+        ok: false,
+        detectable: false,
+        approval_state: 'unknown',
+        sources_checked: [],
+        blockers: [messageOf(err)],
+        warnings: ['hook_approval_probe_failed']
+    }));
+    const agentType = await probeCodexAgentTypeSupport(root, { codexBin }).catch((err) => ({
+        schema: 'sks.codex-agent-type-probe.v1',
+        generated_at: nowIso(),
+        ok: false,
+        supported: false,
+        source: 'unknown',
+        spawn_tool_name: 'unknown',
+        schema_path: null,
+        evidence: [],
+        blockers: [messageOf(err)],
+        warnings: ['agent_type_probe_failed_message_role_fallback']
+    }));
+    const skillSync = await syncCodexSksSkills({ root, apply: input.applyRepairs === true }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+    const agentRoles = await syncCodexAgentRoles({ root, apply: input.applyRepairs === true }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+    const appRecord = isRecord(app) ? app : {};
+    const requiredSkills = isRecord(appRecord.required_skills) ? appRecord.required_skills : {};
+    const skills = isRecord(appRecord.skills) ? appRecord.skills : {};
+    const skillShadows = isRecord(appRecord.skill_shadows) ? appRecord.skill_shadows : {};
+    const skillPickerReady = requiredSkills.ok === true || skills.ok === true || skillShadows.ok !== false;
+    const hookApproved = hookApproval.approval_state === 'approved';
+    const hookInstalled = hookApproval.approval_state !== 'not_installed';
+    const features = {
+        plugin_json: boolState(booleanFeature(cap0138, 'supports_plugin_json'), 'actual-probe', '.sneakoscope/codex-0138-capability.json', blockersOf(cap0138)),
+        plugin_marketplace: boolState(booleanFeature(cap0139, 'supports_marketplace_source_field') || plugins.marketplace_available, 'plugin-inventory', '.sneakoscope/codex-plugin-inventory.json', blockersOf(plugins)),
+        hook_approval: codexNativeFeatureState({
+            ok: hookApproved,
+            source: 'actual-probe',
+            artifact_path: '.sneakoscope/reports/codex-hook-approval-probe.json',
+            evidence: [`approval_state:${hookApproval.approval_state}`],
+            blockers: hookApproval.approval_state === 'modified_requires_reapproval' ? ['hook_modified_requires_reapproval'] : [],
+            warnings: [...hookApproval.warnings, ...(!hookApproved && hookInstalled ? ['hook_derived_evidence_not_counted'] : [])],
+            unavailableStatus: hookInstalled ? 'unknown' : 'unavailable'
+        }),
+        skill_picker: boolState(skillPickerReady, 'config', '.sneakoscope/reports/codex-native-feature-matrix.json', [], skillPickerReady ? [] : ['skill_picker_unverified']),
+        skill_sync: boolState(recordOk(skillSync) !== false, 'actual-probe', '.sneakoscope/reports/codex-skill-sync.json', blockersOf(skillSync)),
+        agent_roles: boolState(recordOk(agentRoles) !== false, 'actual-probe', '.sneakoscope/reports/codex-agent-role-sync.json', blockersOf(agentRoles)),
+        agent_type: codexNativeFeatureState({
+            ok: agentType.supported === true,
+            source: agentType.source === 'fixture' ? 'fixture' : 'actual-probe',
+            artifact_path: '.sneakoscope/reports/codex-agent-type-probe.json',
+            evidence: agentType.evidence,
+            blockers: [],
+            warnings: [...agentType.warnings, ...(agentType.supported ? [] : ['agent_type_unavailable_message_role_fallback'])],
+            unavailableStatus: 'fallback'
+        }),
+        mcp_inventory: codexNativeFeatureState({
+            ok: mcpCandidates.candidates.length > 0 || Array.isArray(plugins.plugins),
+            source: 'plugin-inventory',
+            artifact_path: '.sneakoscope/mcp-plugin-server-candidates.json',
+            evidence: [`candidate_count:${mcpCandidates.candidates.length}`],
+            blockers: [...plugins.blockers, ...mcpCandidates.blockers],
+            warnings: mcpCandidates.candidates.length ? [] : ['mcp_plugin_candidates_empty'],
+            unavailableStatus: 'fallback'
+        }),
+        app_handoff: boolState(booleanFeature(cap0138, 'supports_app_handoff'), 'actual-probe', '.sneakoscope/codex-0138-capability.json', blockersOf(cap0138)),
+        image_path_exposure: boolState(booleanFeature(cap0138, 'supports_image_path_exposure'), 'actual-probe', '.sneakoscope/codex-0138-capability.json', blockersOf(cap0138)),
+        code_mode_web_search: boolState(booleanFeature(cap0139, 'supports_code_mode_web_search'), 'actual-probe', '.sneakoscope/codex-0139-capability.json', blockersOf(cap0139)),
+        slash_command_bridge: boolState(true, 'config', '.sneakoscope/reports/codex-native-feature-matrix.json'),
+        project_memory: boolState(true, 'config', '.sneakoscope/context/AGENTS.generated.md')
+    };
+    const matrixBase = {
+        schema: 'sks.codex-native-feature-matrix.v1',
+        generated_at: nowIso(),
+        ok: false,
+        codex_cli: { available: Boolean(codexBin), version, bin: codexBin },
+        features,
+        probes: {
+            codex_0138: cap0138,
+            codex_0139: cap0139,
+            app,
+            plugin_inventory: plugins,
+            mcp_candidates: mcpCandidates,
+            hook_approval: hookApproval,
+            agent_type: agentType,
+            skill_sync: skillSync,
+            agent_roles: agentRoles
+        },
+        invocation_defaults: {
+            loop_worker_role_strategy: 'message-role',
+            qa_visual_review_strategy: 'headless-artifact',
+            research_source_strategy: 'local-files',
+            image_followup_strategy: 'artifact-path',
+            hook_evidence_policy: 'unknown-do-not-count',
+            skill_bridge_strategy: 'cli-only'
+        },
+        blockers: [
+            ...(!codexBin ? ['codex_cli_missing'] : []),
+            ...Object.values(features).flatMap((feature) => feature.blockers)
+        ],
+        warnings: Object.values(features).flatMap((feature) => feature.warnings)
+    };
+    const matrix = {
+        ...matrixBase,
+        ok: matrixBase.blockers.length === 0,
+        invocation_defaults: computeCodexNativeInvocationDefaults(matrixBase)
+    };
+    await writeCodexNativeFeatureMatrix(root, matrix, input.missionDir);
+    return matrix;
+}
+export async function writeCodexNativeFeatureMatrix(root, matrix, missionDir) {
+    await writeJsonAtomic(path.join(root, REPORT_PATH), matrix);
+    if (missionDir)
+        await writeJsonAtomic(path.join(missionDir, 'codex-native-feature-matrix.json'), matrix).catch(() => undefined);
+}
+function boolState(ok, source, artifactPath, blockers = [], warnings = []) {
+    return codexNativeFeatureState({
+        ok,
+        source,
+        artifact_path: artifactPath,
+        blockers: ok ? [] : blockers,
+        warnings: ok ? warnings : [...warnings, ...(!blockers.length ? ['feature_unavailable'] : [])]
+    });
+}
+async function codexVersion(bin) {
+    const run = await runProcess(bin, ['--version'], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch(() => null);
+    return run?.code === 0 ? `${run.stdout || run.stderr || ''}`.trim() || null : null;
+}
+function booleanFeature(value, key) {
+    return isRecord(value) && value[key] === true;
+}
+function blockersOf(value) {
+    if (!isRecord(value) || !Array.isArray(value.blockers))
+        return [];
+    return value.blockers.map((item) => String(item)).filter(Boolean);
+}
+function recordOk(value) {
+    return isRecord(value) && typeof value.ok === 'boolean' ? value.ok : undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=codex-native-feature-broker.js.map

package/dist/core/codex-native/codex-native-feature-matrix.js

@@ -0,0 +1,31 @@
+export function codexNativeFeatureState(input) {
+    const blockers = uniq(input.blockers || []);
+    return {
+        ok: input.ok && blockers.length === 0,
+        status: input.ok && blockers.length === 0 ? 'available' : input.unavailableStatus || (blockers.length ? 'blocked' : 'unavailable'),
+        source: input.source,
+        artifact_path: input.artifact_path ?? null,
+        evidence: uniq(input.evidence || []),
+        blockers,
+        warnings: uniq(input.warnings || [])
+    };
+}
+export function computeCodexNativeInvocationDefaults(matrix) {
+    const features = matrix.features;
+    const hookStatus = features.hook_approval.status;
+    return {
+        loop_worker_role_strategy: features.agent_type.ok ? 'agent_type' : 'message-role',
+        qa_visual_review_strategy: features.app_handoff.ok ? 'app-handoff' : 'headless-artifact',
+        research_source_strategy: features.mcp_inventory.ok ? 'mcp-plugin-candidates' : features.code_mode_web_search.ok ? 'web-sources' : 'local-files',
+        image_followup_strategy: features.image_path_exposure.ok ? 'model-visible-path' : 'artifact-path',
+        hook_evidence_policy: hookStatus === 'available' ? 'approved-only' : hookStatus === 'unavailable' ? 'not-installed' : 'unknown-do-not-count',
+        skill_bridge_strategy: features.skill_sync.ok || features.skill_picker.ok ? 'sks-managed-skills' : 'cli-only'
+    };
+}
+export function matrixFeatureOk(matrix, key) {
+    return matrix.features[key].ok;
+}
+export function uniq(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+//# sourceMappingURL=codex-native-feature-matrix.js.map

package/dist/core/codex-native/codex-native-harness-compat.js

@@ -0,0 +1,54 @@
+import { buildCodexNativeFeatureMatrix } from './codex-native-feature-broker.js';
+export async function buildCodexAppHarnessMatrixFromNative(input) {
+    const matrix = await buildCodexNativeFeatureMatrix(input);
+    return codexAppHarnessMatrixFromNative(matrix);
+}
+export function codexAppHarnessMatrixFromNative(matrix) {
+    const hookApproval = probeRecord(matrix.probes.hook_approval);
+    const agentType = probeRecord(matrix.probes.agent_type);
+    const hookState = typeof hookApproval.approval_state === 'string' ? hookApproval.approval_state : 'unknown';
+    return {
+        schema: 'sks.codex-app-harness-matrix.v1',
+        generated_at: matrix.generated_at,
+        ok: matrix.ok,
+        codex_cli: {
+            available: matrix.codex_cli.available,
+            version: matrix.codex_cli.version
+        },
+        app_features: {
+            plugin_json: matrix.features.plugin_json.ok,
+            marketplace_add: matrix.features.plugin_marketplace.ok,
+            marketplace_upgrade: matrix.features.plugin_marketplace.ok,
+            startup_review_detectable: hookState !== 'unknown',
+            hook_approval_state_detectable: hookState !== 'unknown',
+            hook_approval_state: hookState === 'approved'
+                || hookState === 'pending_review'
+                || hookState === 'modified_requires_reapproval'
+                || hookState === 'not_installed'
+                ? hookState
+                : 'unknown',
+            skill_picker_ready: matrix.features.skill_picker.ok,
+            agent_type_supported: matrix.features.agent_type.ok,
+            mcp_inventory_ready: matrix.features.mcp_inventory.ok,
+            app_handoff_ready: matrix.features.app_handoff.ok,
+            image_path_exposure_ready: matrix.features.image_path_exposure.ok
+        },
+        sks_integrations: {
+            dollar_skills_synced: matrix.features.skill_sync.ok,
+            agent_roles_synced: matrix.features.agent_roles.ok,
+            hooks_synced: hookState === 'approved',
+            init_deep_available: matrix.features.project_memory.ok,
+            loop_mesh_app_profile_available: true
+        },
+        probes: {
+            hook_approval: hookApproval,
+            agent_type: agentType
+        },
+        blockers: matrix.blockers,
+        warnings: matrix.warnings
+    };
+}
+function probeRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+//# sourceMappingURL=codex-native-harness-compat.js.map

package/dist/core/codex-native/codex-native-interop-policy.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
+const RESERVED_EXTERNAL_ROUTE_SKILLS = ['ulw-loop', 'ulw-plan', 'start-work'];
+export async function buildCodexNativeInteropPolicy(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()).filter(Boolean);
+    const preservedSkillNames = RESERVED_EXTERNAL_ROUTE_SKILLS.filter((name) => skillNames.includes(name));
+    const report = {
+        schema: 'sks.codex-native-interop-policy.v1',
+        generated_at: nowIso(),
+        ok: true,
+        mode: input.mode || 'coexist',
+        detection: {
+            plugin_inventory_ids: pluginIds,
+            skill_names: skillNames,
+            preserved_skill_names: preservedSkillNames
+        },
+        policy: {
+            clobber_user_skills: false,
+            clobber_external_route_assets: false,
+            explicit_handoff_required: true,
+            artifact_names_brand_neutral: true
+        },
+        actions: preservedSkillNames.map((name) => `preserve_existing_skill:${name}`),
+        blockers: []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-native-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=codex-native-interop-policy.js.map

package/dist/core/codex-native/codex-native-invocation-router.js

@@ -0,0 +1,112 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { buildCodexNativeFeatureMatrix } from './codex-native-feature-broker.js';
+export async function resolveCodexNativeInvocationPlan(input) {
+    const root = path.resolve(input.root || process.cwd());
+    const matrix = input.matrix || await buildCodexNativeFeatureMatrix({
+        root,
+        missionDir: input.missionId ? path.join(root, '.sneakoscope', 'missions', input.missionId) : null
+    });
+    const plan = planFor(matrix, input.route, input.desiredCapability);
+    if (input.missionId) {
+        const filename = `codex-native-invocation-plan.${routeSlug(input.route)}.${capabilitySlug(input.desiredCapability)}.json`;
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'missions', input.missionId, filename), plan).catch(() => undefined);
+    }
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-native-invocation-plan.json'), plan).catch(() => undefined);
+    return plan;
+}
+function planFor(matrix, route, capability) {
+    const blockers = [];
+    const warnings = [];
+    let selected = 'sks-managed-artifact';
+    const artifacts = ['.sneakoscope/reports/codex-native-feature-matrix.json'];
+    const proofPolicy = ['record selected strategy and blockers before counting route evidence'];
+    if (capability === 'agent-role') {
+        if (matrix.invocation_defaults.loop_worker_role_strategy === 'agent_type') {
+            selected = 'codex-app-native';
+            proofPolicy.push('include native agent_type payload in worker proof');
+        }
+        else {
+            selected = 'message-role-fallback';
+            warnings.push('agent_type unavailable; message-role fallback active');
+            proofPolicy.push('include message-role fallback in worker proof');
+        }
+    }
+    else if (capability === 'visual-review') {
+        if (matrix.invocation_defaults.hook_evidence_policy === 'unknown-do-not-count')
+            warnings.push('hook-derived evidence will not count');
+        selected = matrix.invocation_defaults.qa_visual_review_strategy === 'app-handoff' ? 'codex-app-native' : 'sks-managed-artifact';
+        if (matrix.invocation_defaults.qa_visual_review_strategy === 'blocked') {
+            selected = 'blocked';
+            blockers.push('qa_visual_review_unavailable');
+        }
+        proofPolicy.push('do not pass visual review without accepted artifact or app handoff confirmation');
+    }
+    else if (capability === 'plugin-source' || capability === 'mcp-source') {
+        if (matrix.features.mcp_inventory.ok) {
+            selected = 'codex-app-native';
+            artifacts.push('.sneakoscope/mcp-plugin-server-candidates.json');
+            proofPolicy.push('treat remote MCP servers as candidates only until explicitly enabled');
+        }
+        else if (matrix.features.code_mode_web_search.ok) {
+            selected = 'codex-cli-headless';
+            warnings.push('plugin inventory unavailable; code/web source fallback selected');
+        }
+        else {
+            selected = 'sks-managed-artifact';
+            warnings.push('plugin inventory unavailable; local/source-ledger fallback selected');
+        }
+    }
+    else if (capability === 'web-search') {
+        selected = matrix.features.code_mode_web_search.ok ? 'codex-cli-headless' : 'sks-managed-artifact';
+        if (!matrix.features.code_mode_web_search.ok)
+            warnings.push('code-mode web search not verified');
+    }
+    else if (capability === 'image-followup') {
+        selected = matrix.features.image_path_exposure.ok ? 'codex-app-native' : 'sks-managed-artifact';
+        proofPolicy.push(matrix.features.image_path_exposure.ok ? 'include model-visible image path' : 'use saved artifact path contract');
+    }
+    else if (capability === 'hook-evidence') {
+        if (matrix.invocation_defaults.hook_evidence_policy !== 'approved-only') {
+            selected = 'blocked';
+            blockers.push('hook_approval_not_approved');
+            warnings.push('hook-derived proof cannot count');
+        }
+        else {
+            selected = 'codex-app-native';
+        }
+        proofPolicy.push('approved hooks only; unknown hook state does not count');
+    }
+    else if (capability === 'project-memory') {
+        selected = matrix.features.project_memory.ok ? 'sks-managed-artifact' : 'blocked';
+        if (!matrix.features.project_memory.ok)
+            blockers.push('project_memory_unavailable');
+        proofPolicy.push('project memory is guidance only and never expands write scope');
+    }
+    return {
+        schema: 'sks.codex-native-invocation-plan.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        route,
+        desired_capability: capability,
+        selected_strategy: selected,
+        required_artifacts: artifacts,
+        proof_policy: proofPolicy,
+        env: {
+            SKS_CODEX_NATIVE_STRATEGY: selected,
+            SKS_CODEX_NATIVE_FEATURE_MATRIX: '.sneakoscope/reports/codex-native-feature-matrix.json',
+            SKS_CODEX_NATIVE_AGENT_ROLE_STRATEGY: matrix.invocation_defaults.loop_worker_role_strategy,
+            SKS_CODEX_NATIVE_HOOK_EVIDENCE_POLICY: matrix.invocation_defaults.hook_evidence_policy
+        },
+        blockers,
+        warnings,
+        feature_matrix_artifact: '.sneakoscope/reports/codex-native-feature-matrix.json'
+    };
+}
+function routeSlug(route) {
+    return route.replace(/^\$/, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+function capabilitySlug(capability) {
+    return capability.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+//# sourceMappingURL=codex-native-invocation-router.js.map

package/dist/core/codex-native/codex-native-pattern-analysis.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { analyzeCodexNativeReferenceSource, renderCodexNativeReferenceMarkdown } from './codex-native-reference-source.js';
+const PATTERN_ROWS = [
+    row('no-global-optional-tooling', 'Optional tooling stays non-global by default', 'adapt', ['src/core/zellij/zellij-self-heal.ts'], ['Keep optional repair/install paths explicit and proof-backed.']),
+    row('plugin-lifecycle-state-separation', 'Plugin install and approval are separate states', 'adopt', ['src/core/codex-native/codex-native-feature-broker.ts'], ['Do not count installed tools as approved evidence.']),
+    row('hook-approval-gating', 'Hook approval gates counted evidence', 'adopt', ['src/core/codex-app/codex-hook-lifecycle.ts'], ['Unknown or pending hook approval does not count as proof.']),
+    row('skill-picker-route-bridge', 'SKS route skills bridge command picker usage', 'adapt', ['src/core/codex-app/codex-skill-sync.ts'], ['Managed skills expose route purpose, command, proof path, and failure recovery.']),
+    row('native-agent-role-probe', 'Native agent role payload is probed before use', 'adopt', ['src/core/codex-app/codex-agent-type-probe.ts'], ['Use agent_type only when the probe supports it.']),
+    row('message-role-fallback', 'Message-role fallback is explicit', 'adopt', ['src/core/codex-native/codex-native-invocation-router.ts'], ['Fallback remains valid but must be recorded in proof.']),
+    row('directory-local-memory', 'Directory-local memory is guidance', 'adapt', ['src/core/codex-app/codex-init-deep.ts', 'src/core/loops/loop-planner.ts'], ['Memory hints never widen owner scope.']),
+    row('plan-work-proof-separation', 'Plan, work, and proof stay separate', 'adopt', ['src/core/loops', 'src/core/naruto'], ['Route artifacts separate planning, execution, and verification.']),
+    row('continuation-enforcer', 'Continuation is stateful and bounded', 'adapt', ['src/core/loops/loop-continuation-enforcer.ts'], ['Use runtime proof when hook approval is not approved.']),
+    row('doctor-harness-matrix', 'Doctor merges readiness into one story', 'adopt', ['src/commands/doctor.ts'], ['Doctor should show Zellij, Codex Native, Loop, QA, and Research together.']),
+    row('mcp-tool-candidate-inventory', 'MCP plugin servers are candidates', 'adapt', ['src/core/mcp/mcp-plugin-inventory.ts'], ['Candidate-only inventory prevents accidental destructive auto-enable.']),
+    row('non-clobber-managed-assets', 'Managed assets avoid clobbering user files', 'adopt', ['src/core/codex-app/codex-skill-sync.ts', 'src/core/codex-app/codex-agent-role-sync.ts'], ['Skip unmarked user assets and include checksums for managed content.'])
+];
+export async function buildCodexNativePatternAnalysis(input) {
+    const root = path.resolve(input.root);
+    const evidence = input.evidence || await analyzeCodexNativeReferenceSource({ root, sourceDir: input.sourceDir || null, writeReport: true }).catch(() => null);
+    const evidenceByPattern = new Map();
+    for (const item of evidence?.evidence || []) {
+        const list = evidenceByPattern.get(item.pattern_id) || [];
+        list.push(item.snippet_hash);
+        evidenceByPattern.set(item.pattern_id, list);
+    }
+    return {
+        schema: 'sks.codex-native-pattern-analysis.v1',
+        generated_at: nowIso(),
+        source_kind: 'external-reference-source',
+        source_ref: evidence?.source_ref || input.sourceDir || '.sneakoscope/cache/codex-native-reference',
+        source_sha: evidence?.source_sha || null,
+        patterns: PATTERN_ROWS.map((pattern) => {
+            const hashes = evidenceByPattern.get(pattern.id) || [];
+            return {
+                ...pattern,
+                confidence: hashes.length ? 'high' : evidence ? 'medium' : 'low',
+                evidence_hashes: hashes
+            };
+        }),
+        blockers: evidence?.blockers || ['source_snapshot_missing'],
+        warnings: evidence?.warnings || ['reference_evidence_unavailable']
+    };
+}
+export async function writeCodexNativePatternAnalysis(root, input = {}) {
+    const evidence = await analyzeCodexNativeReferenceSource({ root, sourceDir: input.sourceDir || null, writeReport: true }).catch(() => null);
+    const report = await buildCodexNativePatternAnalysis({ root, evidence, sourceDir: input.sourceDir || null });
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-native-pattern-analysis.json'), report);
+    if (evidence)
+        await writeTextAtomic(path.join(root, 'docs', 'codex-native-patterns.md'), renderCodexNativeReferenceMarkdown(evidence)).catch(() => undefined);
+    return report;
+}
+function row(id, title, adoption, sks_target_modules, implementation_notes) {
+    return { id, title, adoption, sks_target_modules, implementation_notes };
+}
+//# sourceMappingURL=codex-native-pattern-analysis.js.map

package/dist/core/codex-native/codex-native-reference-evidence.js

@@ -0,0 +1,2 @@
+export { analyzeCodexNativeReferenceSource, extractCodexNativeEvidence, renderCodexNativeReferenceMarkdown } from './codex-native-reference-source.js';
+//# sourceMappingURL=codex-native-reference-evidence.js.map

package/dist/core/codex-native/codex-native-reference-source.js

@@ -0,0 +1,110 @@
+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: 'no-global-optional-tooling', claim: 'optional tooling avoids mandatory global install', re: /\bnpx\b|no[- ]global|global install/i },
+    { id: 'plugin-lifecycle-state-separation', claim: 'plugin install state is separated from approval/readiness', re: /\bplugin\b.+\b(install|enable|marketplace|lifecycle)\b/i },
+    { id: 'hook-approval-gating', claim: 'hook approval is a separate counted evidence gate', re: /\bhook\b.+\b(approval|approve|review|trusted|trust)\b/i },
+    { id: 'skill-picker-route-bridge', claim: 'route skills are exposed through command picker style bridges', re: /\b(skill|command picker|slash command|\$[A-Za-z-]+)\b/i },
+    { id: 'native-agent-role-probe', claim: 'native agent role support is probed before use', re: /\bagent_type\b|agent role|spawn_agent/i },
+    { id: 'message-role-fallback', claim: 'message-role fallback is used when native role payload is unavailable', re: /message[- ]role|fallback/i },
+    { id: 'directory-local-memory', claim: 'directory-local memory is injected as context', re: /AGENTS\.md|directory[- ]local|project memory/i },
+    { id: 'plan-work-proof-separation', claim: 'planning, work, and proof are separated', re: /\b(plan|work|proof)\b/i },
+    { id: 'continuation-enforcer', claim: 'continuation is enforced through loop state', re: /continuation|resume|stop hook/i },
+    { id: 'doctor-harness-matrix', claim: 'doctor merges feature probes into one readiness matrix', re: /doctor|health|matrix|readiness/i },
+    { id: 'mcp-tool-candidate-inventory', claim: 'MCP tools are candidates until approved', re: /\bMCP\b|tool candidate|server candidate/i },
+    { id: 'non-clobber-managed-assets', claim: 'managed assets preserve user-authored content', re: /non[- ]clobber|managed|preserve user|checksum/i }
+];
+export async function analyzeCodexNativeReferenceSource(input) {
+    const root = path.resolve(input.root);
+    const sourceDir = input.sourceDir ? path.resolve(input.sourceDir) : path.join(root, '.sneakoscope', 'cache', 'codex-native-reference');
+    const files = await listTextFiles(sourceDir);
+    const evidence = [];
+    const blockers = [];
+    for (const file of files) {
+        const rel = path.relative(sourceDir, file).split(path.sep).join('/');
+        const text = await fs.readFile(file, 'utf8').catch(() => '');
+        if (text)
+            evidence.push(...extractCodexNativeEvidence(rel, text));
+    }
+    if (!files.length || !evidence.length)
+        blockers.push('source_snapshot_missing');
+    const report = {
+        schema: 'sks.codex-native-reference-evidence.v1',
+        generated_at: nowIso(),
+        source_kind: 'external-reference-source',
+        source_ref: input.sourceRef || sourceDir,
+        source_sha: await gitSha(sourceDir),
+        evidence,
+        blockers,
+        warnings: blockers.length ? ['reference_evidence_incomplete'] : []
+    };
+    if (input.writeReport !== false) {
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-native-reference-evidence.json'), report).catch(() => undefined);
+        await writeTextAtomic(path.join(root, 'docs', 'codex-native-patterns.md'), renderCodexNativeReferenceMarkdown(report)).catch(() => undefined);
+    }
+    return report;
+}
+export function extractCodexNativeEvidence(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,
+            line_range: [index + 1, index + 1],
+            snippet_hash: createHash('sha256').update(snippet).digest('hex'),
+            claim_id: pattern.claim,
+            confidence: 'high'
+        });
+    }
+    return rows;
+}
+export function renderCodexNativeReferenceMarkdown(report) {
+    const rows = report.evidence.map((row) => `| ${row.pattern_id} | ${row.file} | ${row.line_range?.join('-') || '-'} | ${row.snippet_hash.slice(0, 16)} | ${row.confidence} |`).join('\n');
+    return [
+        '# SKS Codex Native Patterns',
+        '',
+        'This document records reference-derived Codex-native patterns in SKS-owned vocabulary. It stores line anchors and snippet hashes only.',
+        '',
+        `Generated at: \`${report.generated_at}\``,
+        `Source kind: \`${report.source_kind}\``,
+        '',
+        '| Pattern | File | Lines | Snippet Hash | Confidence |',
+        '|---|---|---:|---|---|',
+        rows || '| none | - | - | - | low |',
+        ''
+    ].join('\n');
+}
+async function listTextFiles(dir) {
+    const out = [];
+    await walk(dir, out);
+    return out.filter((file) => /\.(md|txt|json|toml|ya?ml|js|ts|mjs|cjs)$/i.test(file)).slice(0, 500);
+}
+async function walk(dir, out) {
+    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 (['.git', 'node_modules', 'dist'].includes(row.name))
+                continue;
+            await walk(full, out);
+        }
+        else if (row.isFile()) {
+            out.push(full);
+        }
+    }
+}
+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=codex-native-reference-source.js.map

package/dist/core/codex-native/codex-native-rename-map.js

@@ -0,0 +1,25 @@
+export const CODEX_NATIVE_RENAME_RULES = [
+    { from_hash: 'external-analysis', to: 'codex-native:pattern-analysis', surface: 'gate' },
+    { from_hash: 'external-evidence', to: 'codex-native:reference-evidence', surface: 'gate' },
+    { from_hash: 'external-interop', to: 'codex-native:interop-policy', surface: 'gate' },
+    { from_hash: 'app-harness', to: 'codex-native:harness-matrix', surface: 'gate' },
+    { from_hash: 'skill-sync', to: 'codex-native:skill-sync', surface: 'gate' },
+    { from_hash: 'agent-role-sync', to: 'codex-native:agent-role-sync', surface: 'gate' },
+    { from_hash: 'hook-lifecycle', to: 'codex-native:hook-lifecycle', surface: 'gate' },
+    { from_hash: 'execution-profile', to: 'codex-native:execution-profile', surface: 'gate' },
+    { from_hash: 'feature-broker', to: 'codex-native:feature-broker', surface: 'gate' },
+    { from_hash: 'invocation-router', to: 'codex-native:invocation-router', surface: 'gate' },
+    { from_hash: 'pattern-schema', to: 'sks.codex-native-pattern-analysis.v1', surface: 'schema' },
+    { from_hash: 'evidence-schema', to: 'sks.codex-native-reference-evidence.v1', surface: 'schema' },
+    { from_hash: 'matrix-schema', to: 'sks.codex-native-feature-matrix.v1', surface: 'schema' },
+    { from_hash: 'plan-schema', to: 'sks.codex-native-invocation-plan.v1', surface: 'schema' },
+    { from_hash: 'pattern-report', to: '.sneakoscope/reports/codex-native-pattern-analysis.json', surface: 'artifact' },
+    { from_hash: 'evidence-report', to: '.sneakoscope/reports/codex-native-reference-evidence.json', surface: 'artifact' },
+    { from_hash: 'matrix-report', to: '.sneakoscope/reports/codex-native-feature-matrix.json', surface: 'artifact' },
+    { from_hash: 'plan-report', to: '.sneakoscope/reports/codex-native-invocation-plan.json', surface: 'artifact' },
+    { from_hash: 'patterns-doc', to: 'docs/codex-native-patterns.md', surface: 'docs' }
+];
+export function codexNativeRenameTargets() {
+    return CODEX_NATIVE_RENAME_RULES.map((rule) => rule.to);
+}
+//# sourceMappingURL=codex-native-rename-map.js.map