sneakoscope 3.1.5 → 3.1.7

package/dist/core/codex-app/codex-app-harness-matrix.js

@@ -1,104 +1,9 @@
 import path from 'node:path';
-import { findCodexBinary } from '../codex-adapter.js';
-import { codexAppIntegrationStatus } from '../codex-app.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 { repairAgentRoleConfigs } from '../agents/agent-role-config.js';
-import { buildLazyCodexInteropPolicy } from './lazycodex-interop-policy.js';
-import { probeCodexAgentTypeSupport } from './codex-agent-type-probe.js';
-import { probeCodexHookApprovalState } from './codex-hook-approval-probe.js';
-import { isRecord } from './codex-app-types.js';
+import { writeJsonAtomic } from '../fsx.js';
+import { buildCodexAppHarnessMatrixFromNative } from '../codex-native/codex-native-harness-compat.js';
 export async function buildCodexAppHarnessMatrix(input = { root: process.cwd() }) {
-    const root = path.resolve(input.root || process.cwd());
-    const codexBin = 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) => ({ plugins: [], marketplace_available: false, blockers: [messageOf(err)] }));
-    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 agents = await repairAgentRoleConfigs({ root, apply: input.applyRepairs === true, reportPath: path.join(root, '.sneakoscope', 'reports', 'codex-agent-role-sync.json') }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
-    const interop = await buildLazyCodexInteropPolicy({ root, inventory: plugins }).catch(() => null);
-    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 hasSkills = requiredSkills.ok === true || skills.ok === true || skillShadows.ok !== false;
-    const hookApprovalKnown = hookApproval.detectable === true;
-    const hookBlockers = hookApproval.approval_state === 'modified_requires_reapproval'
-        ? ['hook_modified_requires_reapproval']
-        : [];
-    const matrix = {
-        schema: 'sks.codex-app-harness-matrix.v1',
-        generated_at: nowIso(),
-        ok: Boolean(codexBin) && feature(cap0138, 'supports_plugin_json') !== false && recordOk(agents) !== false,
-        codex_cli: { available: Boolean(codexBin), version },
-        app_features: {
-            plugin_json: feature(cap0138, 'supports_plugin_json') === true,
-            marketplace_add: feature(cap0139, 'supports_marketplace_source_field') === true || feature(plugins, 'marketplace_available') === true,
-            marketplace_upgrade: feature(cap0139, 'supports_marketplace_source_field') === true,
-            startup_review_detectable: hookApprovalKnown,
-            hook_approval_state_detectable: hookApprovalKnown,
-            hook_approval_state: hookApproval.approval_state,
-            skill_picker_ready: Boolean(hasSkills),
-            agent_type_supported: agentType.supported,
-            mcp_inventory_ready: Array.isArray(isRecord(plugins) ? plugins.plugins : null),
-            app_handoff_ready: feature(cap0138, 'supports_app_handoff') === true,
-            image_path_exposure_ready: feature(cap0138, 'supports_image_path_exposure') === true
-        },
-        sks_integrations: {
-            dollar_skills_synced: Boolean(hasSkills),
-            agent_roles_synced: recordOk(agents) !== false,
-            hooks_synced: hookApproval.approval_state === 'approved',
-            init_deep_available: true,
-            loop_mesh_app_profile_available: true
-        },
-        probes: {
-            hook_approval: hookApproval,
-            agent_type: agentType
-        },
-        blockers: [
-            ...(!codexBin ? ['codex_cli_missing'] : []),
-            ...blockersOf(cap0138),
-            ...blockersOf(plugins),
-            ...blockersOf(agents),
-            ...hookBlockers
-        ],
-        warnings: [
-            ...blockersOf(cap0139).map((b) => `codex_0139:${b}`),
-            ...hookApproval.blockers.map((b) => `hooks:${b}`),
-            ...hookApproval.warnings,
-            ...agentType.warnings,
-            ...(hookApproval.approval_state === 'pending_review' ? ['hook_approval_pending_review'] : []),
-            ...(hookApproval.approval_state === 'not_installed' ? ['hooks_not_installed'] : []),
-            ...(interop?.lazycodex_detected ? ['lazycodex_detected_coexist_mode'] : [])
-        ]
-    };
-    matrix.ok = matrix.blockers.length === 0;
-    await writeCodexAppHarnessMatrix(root, matrix, input.missionDir);
+    const matrix = await buildCodexAppHarnessMatrixFromNative(input);
+    await writeCodexAppHarnessMatrix(path.resolve(input.root || process.cwd()), matrix, input.missionDir);
     return matrix;
 }
 export async function writeCodexAppHarnessMatrix(root, matrix, missionDir) {
@@ -106,22 +11,4 @@ export async function writeCodexAppHarnessMatrix(root, matrix, missionDir) {
     if (missionDir)
         await writeJsonAtomic(path.join(missionDir, 'codex-app-harness-matrix.json'), matrix).catch(() => undefined);
 }
-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 blockersOf(value) {
-    if (!isRecord(value) || !Array.isArray(value.blockers))
-        return [];
-    return value.blockers.map((item) => String(item)).filter(Boolean);
-}
-function feature(value, key) {
-    return isRecord(value) && typeof value[key] === 'boolean' ? value[key] : undefined;
-}
-function recordOk(value) {
-    return isRecord(value) && typeof value.ok === 'boolean' ? value.ok : undefined;
-}
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 //# sourceMappingURL=codex-app-harness-matrix.js.map

package/dist/core/codex-app/codex-hook-lifecycle.js

@@ -35,9 +35,12 @@ export async function buildCodexHookLifecycle(input = {}) {
         approval_state: probe.approval_state,
         approval_state_detectable: probe.detectable,
         lifecycle: Object.fromEntries(Object.entries(events).map(([event, actions]) => [event, {
+                event,
                 actions,
+                sks_action: actions.join(','),
                 installed: installedEvents.has(event),
-                approval_state: installedEvents.has(event) ? probe.approval_state : 'not_installed'
+                approval_state: installedEvents.has(event) ? probe.approval_state : 'not_installed',
+                counted_as_evidence: installedEvents.has(event) && probe.approval_state === 'approved'
             }])),
         actual_state: actual,
         install,

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-${Date.now()}-${beforeHash.slice(0, 12)}`;
                         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,53 @@ 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 backupPattern = new RegExp(`^${escapeRegExp(base)}\\.sks-backup-\\d{13}-[0-9a-f]{8,12}$`);
+    const rows = await fs.readdir(dir).catch(() => []);
+    const backups = rows
+        .filter((name) => backupPattern.test(name))
+        .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 escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+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 +190,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,11 +52,13 @@ 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_user_skills: false
+            clobbered_external_routes: false,
+            clobbered_user_skills: false,
+            skipped_user_skills: skipped,
+            managed_skills: desired
         },
         blockers: []
     };
@@ -82,10 +84,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 rules: 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-control/codex-0138-capability.js

@@ -22,6 +22,7 @@ export async function detectCodex0138Capability(input = {}) {
         };
     const pluginJsonOk = atLeast138 && (probeMode === 'version-only' || featureProbeResults.plugin_json !== 'failed');
     const appHandoffOk = atLeast138 && (probeMode === 'version-only' || featureProbeResults.app_handoff_platform === 'passed');
+    const imagePathExposureOk = atLeast138 && process.env.SKS_CODEX_0138_FAKE_IMAGE_PATH_FAIL !== '1';
     const blockers = [
         ...(!codexBin ? ['codex_cli_missing'] : []),
         ...(atLeast138 ? [] : ['codex_0_138_required_for_app_plugin_features']),
@@ -36,7 +37,7 @@ export async function detectCodex0138Capability(input = {}) {
         parsed_version: parsed,
         supports_app_handoff: appHandoffOk,
         supports_plugin_json: pluginJsonOk,
-        supports_image_path_exposure: atLeast138,
+        supports_image_path_exposure: imagePathExposureOk,
         supports_model_defined_efforts: atLeast138,
         supports_app_server_token_usage: atLeast138,
         supports_v2_pat_auth: atLeast138,
@@ -78,7 +79,9 @@ async function probeCodex0138Features(codexBin, opts = {}) {
     if (opts.fake) {
         return {
             plugin_json: process.env.SKS_CODEX_0138_FAKE_PLUGIN_JSON_FAIL === '1' ? 'failed' : 'passed',
-            app_handoff_platform: process.platform === 'darwin' || process.platform === 'win32' ? 'passed' : 'failed',
+            app_handoff_platform: process.env.SKS_CODEX_0138_FAKE_APP_HANDOFF_FAIL === '1'
+                ? 'failed'
+                : process.platform === 'darwin' || process.platform === 'win32' ? 'passed' : 'failed',
             image_path_exposure_contract: 'sks-enforced'
         };
     }

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,250 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { findCodexBinary } from '../codex-adapter.js';
+import { codexAppIntegrationStatus } from '../codex-app.js';
+import { probeCodexAgentTypeSupport } from '../codex-app/codex-agent-type-probe.js';
+import { probeCodexHookApprovalState } from '../codex-app/codex-hook-approval-probe.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';
+const REQUIRED_SKILL_NAMES = ['loop', 'naruto', 'qa-loop', 'research', 'dfix', 'image-ux-review', 'computer-use', 'init-deep'];
+const REQUIRED_AGENT_ROLES = ['sks-explorer', 'sks-planner', 'sks-implementer', 'sks-checker', 'sks-release-verifier', 'sks-zellij-ui-verifier', 'sks-codex-probe-verifier'];
+export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd() }) {
+    const root = path.resolve(input.root || process.cwd());
+    const deprecatedApplyRepairs = input.applyRepairs === true;
+    const mode = input.mode || (deprecatedApplyRepairs || input.repairManagedAssets === true ? 'repair' : 'read-only');
+    const repairManagedAssets = mode === 'repair' && (input.repairManagedAssets === true || deprecatedApplyRepairs);
+    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 inspectManagedSkillState(root);
+    const agentRoles = await inspectManagedAgentRoleState(root);
+    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,
+            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),
+            ...(deprecatedApplyRepairs ? ['deprecated_apply_repairs_input'] : []),
+            ...(mode === 'repair' && !repairManagedAssets ? ['repair_mode_without_managed_asset_repair'] : [])
+        ]
+    };
+    const matrix = {
+        ...matrixBase,
+        ok: matrixBase.blockers.length === 0,
+        invocation_defaults: computeCodexNativeInvocationDefaults(matrixBase)
+    };
+    await writeCodexNativeFeatureMatrix(root, matrix, input.missionDir);
+    return matrix;
+}
+async function inspectManagedSkillState(root) {
+    const skillRoots = [
+        path.join(root, '.agents', 'skills'),
+        ...(process.env.CODEX_HOME ? [path.join(process.env.CODEX_HOME, 'skills')] : [])
+    ];
+    let existingCount = 0;
+    const managed = new Set();
+    for (const dir of skillRoots) {
+        const rows = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+        existingCount += rows.filter((row) => row.isDirectory()).length;
+        for (const name of REQUIRED_SKILL_NAMES) {
+            if (managed.has(name))
+                continue;
+            const text = await fs.readFile(path.join(dir, name, 'SKILL.md'), 'utf8').catch(() => '');
+            if (text.includes('BEGIN SKS MANAGED SKILL'))
+                managed.add(name);
+        }
+    }
+    const missing = REQUIRED_SKILL_NAMES.filter((name) => !managed.has(name));
+    return {
+        ok: missing.length === 0,
+        apply: false,
+        artifact_path: '.sneakoscope/reports/codex-skill-sync.json',
+        existing_count: existingCount,
+        managed_count: managed.size,
+        missing_required: missing,
+        blockers: missing.length ? [`managed_skills_missing:${missing.join(',')}`] : [],
+        warnings: existingCount > managed.size ? ['non_sks_skill_dirs_ignored'] : []
+    };
+}
+async function inspectManagedAgentRoleState(root) {
+    const dirs = [
+        path.join(root, '.codex', 'agents'),
+        ...(process.env.CODEX_HOME ? [path.join(process.env.CODEX_HOME, 'agents')] : [])
+    ];
+    let existingCount = 0;
+    const managed = new Set();
+    for (const dir of dirs) {
+        const rows = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+        existingCount += rows.filter((row) => row.isFile() && row.name.endsWith('.toml')).length;
+        for (const role of REQUIRED_AGENT_ROLES) {
+            if (managed.has(role))
+                continue;
+            const text = await fs.readFile(path.join(dir, `${role}.toml`), 'utf8').catch(() => '');
+            if (text.includes('SKS managed 3.1.7 directive role'))
+                managed.add(role);
+        }
+    }
+    const missing = REQUIRED_AGENT_ROLES.filter((role) => !managed.has(role));
+    return {
+        ok: missing.length === 0,
+        apply: false,
+        artifact_path: '.sneakoscope/reports/codex-agent-role-sync.json',
+        existing_count: existingCount,
+        managed_count: managed.size,
+        missing_required: missing,
+        blockers: missing.length ? [`managed_agent_roles_missing:${missing.join(',')}`] : [],
+        warnings: existingCount > managed.size ? ['non_sks_agent_roles_ignored'] : []
+    };
+}
+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