sneakoscope 3.1.5 → 3.1.6

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

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { ensureDir, mergeManagedBlock, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { guardContextForRoute, guardedRm } from '../safety/mutation-guard.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
 export async function runCodexInitDeep(input = {}) {
     const root = path.resolve(input.root || process.cwd());
     const dirs = await scoreDirectories(root);
@@ -8,7 +10,8 @@ export async function runCodexInitDeep(input = {}) {
     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: [] };
+    const directoryLocalAgents = { created: [], updated: [], skipped: [], backup_paths: [], backups_created: 0, backups_pruned: [], unchanged_files: [], changed_only_backup: true, blockers: [] };
+    const backupRetention = Math.max(0, Number(process.env.SKS_INIT_DEEP_BACKUP_RETENTION || 5) || 5);
     if (input.apply === true) {
         await ensureDir(contextDir);
         await writeTextAtomic(generatedPath, markdown);
@@ -18,12 +21,22 @@ export async function runCodexInitDeep(input = {}) {
                 try {
                     await ensureDir(path.dirname(agentsPath));
                     const existing = await fs.readFile(agentsPath, 'utf8').catch(() => '');
+                    const next = mergeManagedBlockPreview(existing, 'SKS INIT-DEEP MANAGED SECTION', renderDirectoryAgentsBlock(row));
+                    if (existing === next) {
+                        directoryLocalAgents.unchanged_files.push(path.relative(root, agentsPath));
+                        continue;
+                    }
                     if (existing.trim()) {
-                        const backup = `${agentsPath}.sks-backup-${Date.now()}`;
+                        const beforeHash = hashText(existing);
+                        const backup = `${agentsPath}.sks-backup-${beforeHash.slice(0, 12)}-${Date.now()}`;
                         await fs.copyFile(agentsPath, backup);
                         directoryLocalAgents.backup_paths.push(path.relative(root, backup));
+                        directoryLocalAgents.backups_created += 1;
                     }
-                    const status = await mergeManagedBlock(agentsPath, 'SKS INIT-DEEP MANAGED SECTION', renderDirectoryAgentsBlock(row));
+                    await writeTextAtomic(agentsPath, next);
+                    const pruned = await pruneBackups(root, agentsPath, backupRetention);
+                    directoryLocalAgents.backups_pruned.push(...pruned.map((file) => path.relative(root, file)));
+                    const status = existing.trim() ? (existing.includes('BEGIN SKS INIT-DEEP MANAGED SECTION') ? 'updated' : 'appended') : 'created';
                     if (status === 'created')
                         directoryLocalAgents.created.push(path.relative(root, agentsPath));
                     else
@@ -51,6 +64,49 @@ export async function runCodexInitDeep(input = {}) {
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-init-deep.json'), report).catch(() => undefined);
     return report;
 }
+function mergeManagedBlockPreview(current, markerName, content) {
+    const begin = `<!-- BEGIN ${markerName} -->`;
+    const end = `<!-- END ${markerName} -->`;
+    const block = `${begin}\n${content.trim()}\n${end}\n`;
+    if (!current.trim())
+        return `${block}\n`;
+    const beginIdx = current.indexOf(begin);
+    const endIdx = current.indexOf(end);
+    if (beginIdx >= 0 && endIdx >= beginIdx) {
+        const afterEnd = endIdx + end.length;
+        return `${current.slice(0, beginIdx)}${block}${current.slice(afterEnd).replace(/^\n/, '')}`;
+    }
+    return `${current.replace(/\s*$/, '\n\n')}${block}\n`;
+}
+async function pruneBackups(root, agentsPath, keep) {
+    if (keep < 1)
+        return [];
+    const dir = path.dirname(agentsPath);
+    const base = path.basename(agentsPath);
+    const rows = await fs.readdir(dir).catch(() => []);
+    const backups = rows
+        .filter((name) => name.startsWith(`${base}.sks-backup-`))
+        .map((name) => path.join(dir, name))
+        .sort();
+    const remove = backups.slice(0, Math.max(0, backups.length - keep));
+    const contract = createRequestedScopeContract({
+        route: 'codex-app:init-deep',
+        userRequest: 'Prune only SKS init-deep AGENTS.md backup files after creating a fresh backup.',
+        projectRoot: root
+    });
+    const guard = guardContextForRoute(root, contract, 'prune SKS init-deep backup retention');
+    for (const file of remove)
+        await guardedRm(guard, file, { force: true }).catch(() => undefined);
+    return remove;
+}
+function hashText(text) {
+    let hash = 2166136261;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
 export async function readInitDeepMemory(root) {
     const file = path.join(root, '.sneakoscope', 'context', 'AGENTS.generated.md');
     const text = await fs.readFile(file, 'utf8').catch(() => '');
@@ -130,6 +186,8 @@ async function walk(dir, root, counts, depth = 0) {
                 await walk(full, root, counts, depth + 1);
         }
         else if (row.isFile()) {
+            if (row.name.includes('.sks-backup-'))
+                continue;
             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;

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

@@ -13,19 +13,19 @@ const SKS_SKILLS = [
     '$Computer-Use',
     '$Init-Deep'
 ];
-const LAZYCODEX_RESERVED = new Set(['ulw-loop', 'ulw-plan', 'start-work']);
+const EXTERNAL_ROUTE_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 collisions = existing.filter((name) => EXTERNAL_ROUTE_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)) {
+            if (EXTERNAL_ROUTE_RESERVED.has(name)) {
                 skipped.push(name);
                 continue;
             }
@@ -52,10 +52,10 @@ export async function syncCodexSksSkills(input) {
         existing_skills: existing,
         created,
         skipped,
-        lazycodex_reserved_present: collisions,
+        external_route_names_preserved: collisions,
         interop: {
             mode: 'coexist',
-            clobbered_lazycodex: false,
+            clobbered_external_routes: false,
             clobbered_user_skills: false
         },
         blockers: []
@@ -82,10 +82,13 @@ function skillContent(name) {
         `Command: ${profile.command}`,
         `Purpose: ${profile.purpose}`,
         `Use when: ${profile.when}`,
+        `Route: ${profile.command}`,
         `Evidence: ${profile.evidence}`,
-        'Safety: keep route state bounded, preserve user and LazyCodex/OmO skills, and stop on hard blockers instead of fabricating fallback behavior.',
+        'Safety: keep route state bounded, preserve user and external route assets, and stop on hard blockers instead of fabricating fallback behavior.',
+        'Proof paths: write the route-local mission artifact named in Evidence before claiming completion.',
+        'Failure recovery: if a proof path cannot be produced, record the blocker and continue only when the selected SKS route has another allowed evidence path.',
         `Fallback: ${profile.fallback}`,
-        `checksum: ${hash(name)}`,
+        `checksum: ${hash(`${name}:${profile.command}:${profile.evidence}:${profile.fallback}`)}`,
         '<!-- END SKS MANAGED SKILL -->',
         ''
     ].join('\n');

package/dist/core/codex-native/codex-native-capability-cache.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+const CACHE_RELATIVE_PATH = '.sneakoscope/reports/codex-native-feature-matrix.json';
+export function codexNativeCapabilityCachePath(root) {
+    return path.join(root, CACHE_RELATIVE_PATH);
+}
+export async function readCodexNativeCapabilityCache(root) {
+    const file = codexNativeCapabilityCachePath(root);
+    const text = await fs.readFile(file, 'utf8').catch(() => null);
+    if (!text)
+        return null;
+    const parsed = JSON.parse(text);
+    return parsed?.schema === 'sks.codex-native-feature-matrix.v1' ? parsed : null;
+}
+export async function writeCodexNativeCapabilityCache(root, matrix) {
+    const file = codexNativeCapabilityCachePath(root);
+    await writeJsonAtomic(file, matrix);
+    return file;
+}
+//# sourceMappingURL=codex-native-capability-cache.js.map

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-app/lazycodex-interop-policy.js → codex-native/codex-native-interop-policy.js}

@@ -1,38 +1,36 @@
-import fs from 'node:fs/promises';
 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';
-export async function buildLazyCodexInteropPolicy(input) {
+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());
-    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 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.lazycodex-interop-policy.v1',
+        schema: 'sks.codex-native-interop-policy.v1',
         generated_at: nowIso(),
         ok: true,
         mode: input.mode || 'coexist',
-        lazycodex_detected: lazycodexInstalled,
         detection: {
             plugin_inventory_ids: pluginIds,
             skill_names: skillNames,
-            collisions
+            preserved_skill_names: preservedSkillNames
         },
         policy: {
-            clobber_lazycodex_skills: false,
             clobber_user_skills: false,
-            default_mode: 'coexist',
-            explicit_handoff_required: true
+            clobber_external_route_assets: false,
+            explicit_handoff_required: true,
+            artifact_names_brand_neutral: true
         },
-        actions: collisions.map((name) => `preserve_existing_skill:${name}`),
+        actions: preservedSkillNames.map((name) => `preserve_existing_skill:${name}`),
         blockers: []
     };
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-interop-policy.json'), report).catch(() => undefined);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-native-interop-policy.json'), report).catch(() => undefined);
     return report;
 }
 function normalizeInventory(value) {
@@ -57,4 +55,4 @@ async function discoverSkillNames(roots) {
     }
     return [...names].sort();
 }
-//# sourceMappingURL=lazycodex-interop-policy.js.map
+//# 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