sneakoscope 3.1.4 → 3.1.6

package/dist/core/codex-app/codex-agent-role-sync.js

@@ -1,9 +1,9 @@
-// @ts-nocheck
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { nowIso, writeJsonAtomic, writeTextAtomic, ensureDir } from '../fsx.js';
 import { repairAgentRoleConfigs } from '../agents/agent-role-config.js';
+import { agentRolePayloadFor, probeCodexAgentTypeSupport } from './codex-agent-type-probe.js';
 const DIRECTIVE_ROLES = [
     'sks-explorer',
     'sks-planner',
@@ -15,6 +15,7 @@ const DIRECTIVE_ROLES = [
 ];
 export async function syncCodexAgentRoles(input) {
     const root = path.resolve(input.root);
+    const env = input.env || process.env;
     const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
     const targetDir = path.join(codexHome, 'agents');
     const baseRepair = await repairAgentRoleConfigs({
@@ -22,46 +23,103 @@ export async function syncCodexAgentRoles(input) {
         apply: input.apply === true,
         codexHome,
         reportPath: path.join(root, '.sneakoscope', 'reports', 'agent-role-config-repair.json')
-    }).catch((err) => ({ ok: false, blockers: [err?.message || String(err)] }));
+    }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+    const agentTypeProbe = input.agentTypeSupported === undefined
+        ? await probeCodexAgentTypeSupport(root, { env }).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']
+        }))
+        : {
+            schema: 'sks.codex-agent-type-probe.v1',
+            generated_at: nowIso(),
+            ok: true,
+            supported: input.agentTypeSupported,
+            source: 'fixture',
+            spawn_tool_name: input.agentTypeSupported ? 'spawn_agent' : 'unknown',
+            schema_path: input.agentTypeSupported ? 'input.agentTypeSupported' : null,
+            evidence: [`input.agentTypeSupported=${input.agentTypeSupported}`],
+            blockers: [],
+            warnings: []
+        };
+    const rolePayloads = Object.fromEntries(DIRECTIVE_ROLES.map((role) => [role, agentRolePayloadFor(role, agentTypeProbe)]));
     const created = [];
     if (input.apply === true) {
         await ensureDir(targetDir);
         for (const role of DIRECTIVE_ROLES) {
             const file = path.join(targetDir, `${role}.toml`);
             const current = await fs.readFile(file, 'utf8').catch(() => '');
-            if (current && !current.includes('SKS managed 3.1.4 directive role'))
+            if (current && !current.includes('SKS managed 3.1.4 directive role') && !current.includes('SKS managed 3.1.5 directive role') && !current.includes('SKS managed 3.1.6 directive role') && !current.includes('SKS managed 3.1.6 bounded role'))
                 continue;
-            await writeTextAtomic(file, roleToml(role));
+            await writeTextAtomic(file, roleToml(role, rolePayloads[role]));
             created.push(file);
         }
     }
     const report = {
         schema: 'sks.codex-agent-role-sync.v1',
         generated_at: nowIso(),
-        ok: baseRepair.ok !== false,
+        ok: recordOk(baseRepair) !== false && agentTypeProbe.ok !== false,
         apply: input.apply === true,
-        agent_type_supported: input.agentTypeSupported === true || process.env.SKS_CODEX_AGENT_TYPE_SUPPORTED === '1',
-        fallback: (input.agentTypeSupported === true || process.env.SKS_CODEX_AGENT_TYPE_SUPPORTED === '1') ? 'agent_type' : 'message-role',
+        agent_type_supported: agentTypeProbe.supported,
+        fallback: agentTypeProbe.supported ? 'agent_type' : 'message-role',
         codex_home: codexHome,
         directive_roles: DIRECTIVE_ROLES,
+        role_payloads: rolePayloads,
+        agent_type_probe: agentTypeProbe,
         created,
         base_repair: baseRepair,
-        blockers: baseRepair.blockers || []
+        blockers: blockersOf(baseRepair)
     };
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-agent-role-sync.json'), report).catch(() => undefined);
     return report;
 }
-function roleToml(role) {
+function roleToml(role, payload) {
+    const strategyLine = payload?.strategy === 'agent_type'
+        ? `agent_type = "${payload.agent_type || role}"`
+        : `message_role_prefix = "${escapeToml(payload?.message_role_prefix || `Role: ${role}.`)}"`;
     return [
         `name = "${role}"`,
-        `description = "SKS managed 3.1.4 directive role: ${role}"`,
+        `description = "SKS managed 3.1.6 directive role: ${role}"`,
+        strategyLine,
         'model_reasoning_effort = "medium"',
         role.includes('implementer') ? 'sandbox_mode = "workspace-write"' : 'sandbox_mode = "read-only"',
         'approval_policy = "never"',
         'developer_instructions = """',
-        `You are ${role}. SKS managed 3.1.4 directive role. Respect bounded ownership and never clobber user files.`,
+        `You are ${role}. SKS managed 3.1.6 directive role with bounded ownership.`,
+        'Bounded ownership: use only the assigned owner files/directories and treat memory as guidance, not permission.',
+        role.includes('implementer') ? 'Maker/checker separation: implementer may patch only owner scope and cannot self-approve.' : 'Maker/checker separation: checker is read-only and must reject missing gates or missing proof artifacts.',
+        role.includes('release') ? 'Release verifier: verify version truth, release DAG coverage, package scripts, packlist, and changelog evidence.' : '',
+        role.includes('zellij') ? 'UI/Zellij verifier: inspect readiness status, headless fallback, repair_required, pane proof, and slot telemetry without mutating unrelated UI state.' : '',
+        role.includes('codex') ? 'Codex native verifier: inspect hook approval, agent_type, skill sync, plugin inventory, MCP candidates, and invocation plan artifacts.' : '',
+        'Side effects: no destructive shell, package publish, global config mutation, database mutation, or external service write unless the sealed route contract explicitly allows it.',
+        'Required proof artifacts: cite concrete repo paths, command outputs, and route-local JSON proof before claiming completion.',
+        'Final arbiter: parent integration owns final acceptance; this role supplies evidence and cannot override missing gates.',
+        `Execution role strategy: ${payload?.strategy || 'message-role'}. Probe: ${payload?.probe_artifact_path || '.sneakoscope/reports/codex-agent-type-probe.json'}.`,
         '"""',
         ''
     ].join('\n');
 }
+function blockersOf(value) {
+    return Boolean(value) && typeof value === 'object' && Array.isArray(value.blockers)
+        ? (value.blockers).map((item) => String(item)).filter(Boolean)
+        : [];
+}
+function recordOk(value) {
+    return Boolean(value) && typeof value === 'object' && typeof value.ok === 'boolean'
+        ? value.ok
+        : undefined;
+}
+function escapeToml(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 //# sourceMappingURL=codex-agent-role-sync.js.map

package/dist/core/codex-app/codex-agent-type-probe.js

@@ -0,0 +1,202 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+import { isRecord } from './codex-app-types.js';
+export async function probeCodexAgentTypeSupport(root, input = {}) {
+    const env = input.env || process.env;
+    const fixture = await fixtureSchemaProbe(env);
+    if (fixture)
+        return persist(root, fixture, input.writeReport !== false);
+    const schema = await readSchemaFromEnv(env);
+    if (schema)
+        return persist(root, probeSchema(schema.value, schema.source, schema.schemaPath), input.writeReport !== false);
+    const doctor = await probeDoctorJson(input.codexBin, env);
+    if (doctor.source !== 'unknown')
+        return persist(root, doctor, input.writeReport !== false);
+    const help = await probeHelp(input.codexBin, env);
+    if (help.source !== 'unknown')
+        return persist(root, help, input.writeReport !== false);
+    const envProbe = envFallbackProbe(env);
+    if (envProbe)
+        return persist(root, envProbe, input.writeReport !== false);
+    return persist(root, {
+        schema: 'sks.codex-agent-type-probe.v1',
+        generated_at: nowIso(),
+        ok: true,
+        supported: false,
+        source: 'unknown',
+        spawn_tool_name: 'unknown',
+        schema_path: null,
+        evidence: [],
+        blockers: [],
+        warnings: ['agent_type_support_unknown_message_role_fallback']
+    }, input.writeReport !== false);
+}
+export function agentRolePayloadFor(role, probe) {
+    if (probe.supported)
+        return { strategy: 'agent_type', agent_type: role, probe_artifact_path: '.sneakoscope/reports/codex-agent-type-probe.json' };
+    return {
+        strategy: 'message-role',
+        message_role_prefix: `Role: ${role}. Use this as a message-level role because native agent_type is unavailable or unverified.`,
+        probe_artifact_path: '.sneakoscope/reports/codex-agent-type-probe.json'
+    };
+}
+async function fixtureSchemaProbe(env) {
+    const raw = env.SKS_CODEX_AGENT_TYPE_FIXTURE;
+    if (!raw)
+        return null;
+    const supported = raw === '1' || raw === 'supported' || raw === 'true';
+    return {
+        schema: 'sks.codex-agent-type-probe.v1',
+        generated_at: nowIso(),
+        ok: true,
+        supported,
+        source: 'fixture',
+        spawn_tool_name: supported ? 'spawn_agent' : 'unknown',
+        schema_path: supported ? 'fixture.spawn_agent.parameters.agent_type' : null,
+        evidence: [`fixture:${raw}`],
+        blockers: [],
+        warnings: []
+    };
+}
+async function readSchemaFromEnv(env) {
+    if (env.SKS_CODEX_TOOL_SCHEMA_FILE) {
+        const file = path.resolve(env.SKS_CODEX_TOOL_SCHEMA_FILE);
+        const text = await fs.readFile(file, 'utf8').catch(() => '');
+        if (text)
+            return { value: JSON.parse(text), source: 'codex-tool-schema', schemaPath: file };
+    }
+    if (env.SKS_CODEX_TOOL_SCHEMA_JSON) {
+        return { value: JSON.parse(env.SKS_CODEX_TOOL_SCHEMA_JSON), source: 'codex-tool-schema', schemaPath: 'env:SKS_CODEX_TOOL_SCHEMA_JSON' };
+    }
+    return null;
+}
+async function probeDoctorJson(codexBin, env) {
+    const bin = codexBin || env.CODEX_BIN || await findCodexBinary().catch(() => null);
+    if (!bin)
+        return unknownProbe(['codex_cli_missing']);
+    const run = await runProcess(bin, ['doctor', '--json'], { env, timeoutMs: 8000, maxOutputBytes: 256 * 1024 }).catch(() => null);
+    const text = `${run?.stdout || ''}${run?.stderr || ''}`.trim();
+    if (!run || run.code !== 0 || !text)
+        return unknownProbe(['codex_doctor_json_unavailable']);
+    try {
+        const parsed = JSON.parse(text);
+        const probed = probeSchema(parsed, 'codex-doctor-json', 'doctor-json');
+        return { ...probed, source: probed.supported ? 'codex-doctor-json' : 'unknown' };
+    }
+    catch {
+        return unknownProbe(['codex_doctor_json_parse_failed']);
+    }
+}
+async function probeHelp(codexBin, env) {
+    const bin = codexBin || env.CODEX_BIN || await findCodexBinary().catch(() => null);
+    if (!bin)
+        return unknownProbe(['codex_cli_missing']);
+    const run = await runProcess(bin, ['--help'], { env, timeoutMs: 5000, maxOutputBytes: 128 * 1024 }).catch(() => null);
+    const text = `${run?.stdout || ''}${run?.stderr || ''}`;
+    if (!run || run.code !== 0 || !text)
+        return unknownProbe(['codex_help_unavailable']);
+    const supported = /\bagent_type\b/.test(text) && /\bspawn_agent\b|\bmulti_agent_v2\b/.test(text);
+    return {
+        schema: 'sks.codex-agent-type-probe.v1',
+        generated_at: nowIso(),
+        ok: true,
+        supported,
+        source: supported ? 'codex-help' : 'unknown',
+        spawn_tool_name: text.includes('multi_agent_v2') ? 'multi_agent_v2' : supported ? 'spawn_agent' : 'unknown',
+        schema_path: supported ? 'codex --help' : null,
+        evidence: supported ? ['help_mentions_agent_type'] : [],
+        blockers: [],
+        warnings: supported ? [] : ['agent_type_not_found_in_help']
+    };
+}
+function envFallbackProbe(env) {
+    if (env.SKS_CODEX_AGENT_TYPE_SUPPORTED === undefined)
+        return null;
+    if (env.SKS_CODEX_AGENT_TYPE_ALLOW_ENV_FALLBACK !== '1' && env.NODE_ENV !== 'test') {
+        return {
+            schema: 'sks.codex-agent-type-probe.v1',
+            generated_at: nowIso(),
+            ok: true,
+            supported: false,
+            source: 'env',
+            spawn_tool_name: 'unknown',
+            schema_path: null,
+            evidence: [],
+            blockers: [],
+            warnings: ['env_agent_type_fallback_ignored_outside_test_mode']
+        };
+    }
+    const supported = env.SKS_CODEX_AGENT_TYPE_SUPPORTED === '1';
+    return {
+        schema: 'sks.codex-agent-type-probe.v1',
+        generated_at: nowIso(),
+        ok: true,
+        supported,
+        source: 'env',
+        spawn_tool_name: supported ? 'spawn_agent' : 'unknown',
+        schema_path: supported ? 'env:SKS_CODEX_AGENT_TYPE_SUPPORTED' : null,
+        evidence: [`env:SKS_CODEX_AGENT_TYPE_SUPPORTED=${env.SKS_CODEX_AGENT_TYPE_SUPPORTED}`],
+        blockers: [],
+        warnings: ['env_agent_type_fallback_test_only']
+    };
+}
+function probeSchema(value, source, schemaPath) {
+    const found = findAgentType(value);
+    return {
+        schema: 'sks.codex-agent-type-probe.v1',
+        generated_at: nowIso(),
+        ok: true,
+        supported: found.supported,
+        source,
+        spawn_tool_name: found.tool,
+        schema_path: found.path || schemaPath,
+        evidence: found.supported ? [`agent_type:${found.path || 'found'}`] : ['agent_type_absent'],
+        blockers: [],
+        warnings: found.supported ? [] : ['agent_type_not_supported_message_role_fallback']
+    };
+}
+function findAgentType(value, trail = []) {
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            const found = findAgentType(value[index], [...trail, String(index)]);
+            if (found.supported)
+                return found;
+        }
+        return { supported: false, tool: 'unknown', path: null };
+    }
+    if (!isRecord(value))
+        return { supported: false, tool: 'unknown', path: null };
+    const name = String(value.name || value.tool || value.id || '');
+    const tool = name.includes('multi_agent_v2') ? 'multi_agent_v2' : name.includes('spawn_agent') ? 'spawn_agent' : 'unknown';
+    if ('agent_type' in value || isRecord(value.properties) && 'agent_type' in value.properties) {
+        return { supported: true, tool: tool === 'unknown' ? 'spawn_agent' : tool, path: [...trail, 'agent_type'].join('.') };
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        const found = findAgentType(entry, [...trail, key]);
+        if (found.supported)
+            return { ...found, tool: found.tool === 'unknown' && tool !== 'unknown' ? tool : found.tool };
+    }
+    return { supported: false, tool, path: null };
+}
+function unknownProbe(blockers) {
+    return {
+        schema: 'sks.codex-agent-type-probe.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        supported: false,
+        source: 'unknown',
+        spawn_tool_name: 'unknown',
+        schema_path: null,
+        evidence: [],
+        blockers,
+        warnings: ['agent_type_support_unknown_message_role_fallback']
+    };
+}
+async function persist(root, report, writeReport) {
+    if (writeReport)
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-agent-type-probe.json'), report).catch(() => undefined);
+    return report;
+}
+//# sourceMappingURL=codex-agent-type-probe.js.map

package/dist/core/codex-app/codex-app-execution-profile.js

@@ -1,32 +1,61 @@
-// @ts-nocheck
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { buildCodexAppHarnessMatrix } from './codex-app-harness-matrix.js';
+import { isCodexAppHarnessMatrix } from './codex-app-types.js';
+import { buildCodexNativeFeatureMatrix } from '../codex-native/codex-native-feature-broker.js';
 export async function resolveCodexAppExecutionProfile(input = { root: process.cwd() }) {
     const root = path.resolve(input.root || process.cwd());
-    const matrix = input.matrix || await buildCodexAppHarnessMatrix({ root }).catch(() => null);
-    const mode = !matrix?.codex_cli?.available
-        ? 'degraded-no-app'
-        : matrix.app_features?.app_handoff_ready && matrix.app_features?.agent_type_supported
-            ? 'codex-app-native'
-            : matrix.codex_cli.available
-                ? 'codex-cli-headless'
-                : 'sks-loop-headless';
+    const nativeMatrix = await buildCodexNativeFeatureMatrix({ root }).catch(() => null);
+    const maybeMatrix = input.matrix || (nativeMatrix ? null : await buildCodexAppHarnessMatrix({ root }).catch(() => null));
+    const matrix = isCodexAppHarnessMatrix(maybeMatrix) ? maybeMatrix : null;
+    const mode = nativeMatrix
+        ? modeFromNative(nativeMatrix)
+        : !matrix?.codex_cli.available
+            ? 'degraded-no-app'
+            : matrix.app_features.app_handoff_ready && matrix.app_features.agent_type_supported
+                ? 'codex-app-native'
+                : matrix.codex_cli.available
+                    ? 'codex-cli-headless'
+                    : 'sks-loop-headless';
+    const agentRoleStrategy = nativeMatrix?.invocation_defaults.loop_worker_role_strategy || (matrix?.app_features.agent_type_supported ? 'agent_type' : 'message-role');
+    const hookApprovalState = hookApprovalStateFrom(nativeMatrix) || matrix?.app_features.hook_approval_state || 'unknown';
     const profile = {
         schema: 'sks.codex-app-execution-profile.v1',
         generated_at: nowIso(),
         ok: mode !== 'degraded-no-app',
         mode,
-        agent_role_strategy: matrix?.app_features?.agent_type_supported ? 'agent_type' : 'message-role',
+        agent_role_strategy: agentRoleStrategy,
         hooks_assumed_running: false,
-        hooks_approval_required: matrix?.app_features?.hook_approval_state_detectable !== true,
-        app_handoff_ready: matrix?.app_features?.app_handoff_ready === true,
-        image_path_exposure_ready: matrix?.app_features?.image_path_exposure_ready === true,
+        hooks_approval_required: hookApprovalState !== 'approved',
+        hook_approval_state: hookApprovalState,
+        app_handoff_ready: nativeMatrix?.features.app_handoff.ok === true || matrix?.app_features.app_handoff_ready === true,
+        image_path_exposure_ready: nativeMatrix?.features.image_path_exposure.ok === true || matrix?.app_features.image_path_exposure_ready === true,
+        plugin_mcp_inventory_ready: nativeMatrix?.features.mcp_inventory.ok === true || matrix?.app_features.mcp_inventory_ready === true,
         loop_mesh_app_profile_available: true,
+        artifact_path: '.sneakoscope/reports/codex-app-execution-profile.json',
+        matrix_artifact_path: nativeMatrix ? '.sneakoscope/reports/codex-native-feature-matrix.json' : '.sneakoscope/reports/codex-app-harness-matrix.json',
+        agent_type_probe_artifact_path: '.sneakoscope/reports/codex-agent-type-probe.json',
+        hook_approval_probe_artifact_path: '.sneakoscope/reports/codex-hook-approval-probe.json',
         blockers: mode === 'degraded-no-app' ? ['codex_cli_missing'] : [],
-        warnings: matrix?.warnings || []
+        warnings: nativeMatrix?.warnings || matrix?.warnings || []
     };
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-app-execution-profile.json'), profile).catch(() => undefined);
     return profile;
 }
+function modeFromNative(matrix) {
+    if (!matrix.codex_cli.available)
+        return 'degraded-no-app';
+    if (matrix.features.app_handoff.ok && matrix.features.agent_type.ok)
+        return 'codex-app-native';
+    return 'codex-cli-headless';
+}
+function hookApprovalStateFrom(matrix) {
+    const probe = matrix?.probes.hook_approval;
+    if (!probe || typeof probe !== 'object' || Array.isArray(probe))
+        return null;
+    const state = probe.approval_state;
+    return state === 'approved' || state === 'pending_review' || state === 'modified_requires_reapproval' || state === 'not_installed' || state === 'unknown'
+        ? state
+        : null;
+}
 //# sourceMappingURL=codex-app-execution-profile.js.map

package/dist/core/codex-app/codex-app-fast-ui-repair.js

@@ -4,8 +4,9 @@ import { ensureDir, nowIso, readText, sha256, writeJsonAtomic, writeTextAtomic }
 import { codexHome, scanProjectLocalForbiddenKeys, snapshotCodexAppUiState } from './codex-app-ui-state-snapshot.js';
 import { assertCodexAppUiMutationAllowed } from './codex-app-ui-clobber-guard.js';
 export const CODEX_APP_FAST_UI_REPAIR_SCHEMA = 'sks.codex-app-fast-ui-repair.v1';
-const HOST_OWNED_TOP_LEVEL_RE = /^\s*(openai_base_url|chatgpt_base_url|apps_mcp_product_sku|model_provider|notify|profile|experimental_realtime_ws_base_url|service_tier)\s*=/;
-const HOST_OWNED_TABLE_RE = /^\s*\[(model_providers(?:[.\]].*)?|profiles(?:[.\]].*)?|otel(?:[.\]].*)?|user\.fast_mode(?:[.\]].*)?)\]\s*$/;
+const FAST_UI_TOP_LEVEL_RE = /^\s*service_tier\s*=/;
+const FAST_UI_FEATURE_LINE_RE = /^\s*fast_mode\s*=/;
+const FAST_UI_USER_TABLE_LINE_RE = /^\s*(enabled|visible|locked|hidden|disabled)\s*=/;
 const SKS_CAUSED_RE = /(?:SKS|Sneakoscope|codex-lb|sks-mad|sks fast)/i;
 export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
     const resolvedRoot = path.resolve(root);
@@ -124,8 +125,10 @@ function stripProjectLocalForbiddenKeys(text) {
 }
 function stripSksCausedHostOwnedLines(text) {
     return stripMatchingLines(text, (line, table, previous, next) => {
-        const isHostOwned = HOST_OWNED_TOP_LEVEL_RE.test(line) || HOST_OWNED_TABLE_RE.test(line) || Boolean(table && /^(model_providers|profiles|otel|user\.fast_mode)/.test(table));
-        return isHostOwned && (SKS_CAUSED_RE.test(line) || SKS_CAUSED_RE.test(previous) || SKS_CAUSED_RE.test(next));
+        const isFastUiLine = FAST_UI_TOP_LEVEL_RE.test(line)
+            || (table === 'features' && FAST_UI_FEATURE_LINE_RE.test(line))
+            || (table === 'user.fast_mode' && FAST_UI_USER_TABLE_LINE_RE.test(line));
+        return isFastUiLine && (SKS_CAUSED_RE.test(line) || SKS_CAUSED_RE.test(previous) || SKS_CAUSED_RE.test(next));
     });
 }
 function stripMatchingLines(text, shouldRemove) {

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

@@ -1,66 +1,9 @@
-// @ts-nocheck
 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 { readCodexHookActualState } from '../codex-hooks/codex-hook-actual-discovery.js';
-import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
-import { repairAgentRoleConfigs } from '../agents/agent-role-config.js';
-import { buildLazyCodexInteropPolicy } from './lazycodex-interop-policy.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: [err?.message || String(err)] }));
-    const cap0139 = await detectCodex0139Capability({ codexBin }).catch((err) => ({ blockers: [err?.message || String(err)] }));
-    const app = await codexAppIntegrationStatus({ codex: { bin: codexBin, version, available: Boolean(codexBin) } }).catch((err) => ({ ok: false, blockers: [err?.message || String(err)] }));
-    const plugins = await buildCodexPluginInventory().catch((err) => ({ plugins: [], marketplace_available: false, blockers: [err?.message || String(err)] }));
-    const hooks = await readCodexHookActualState(root).catch((err) => ({ ok: false, entries: [], blockers: [err?.message || String(err)] }));
-    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: [err?.message || String(err)] }));
-    const interop = await buildLazyCodexInteropPolicy({ root, inventory: plugins }).catch(() => null);
-    const hasSkills = app?.required_skills?.ok === true || app?.skills?.ok === true || app?.skill_shadows?.ok !== false;
-    const hookApprovalKnown = false;
-    const matrix = {
-        schema: 'sks.codex-app-harness-matrix.v1',
-        generated_at: nowIso(),
-        ok: Boolean(codexBin) && cap0138.supports_plugin_json !== false && agents.ok !== false,
-        codex_cli: { available: Boolean(codexBin), version },
-        app_features: {
-            plugin_json: cap0138.supports_plugin_json === true,
-            marketplace_add: cap0139.supports_marketplace_source_field === true || plugins.marketplace_available === true,
-            marketplace_upgrade: cap0139.supports_marketplace_source_field === true,
-            startup_review_detectable: hookApprovalKnown,
-            hook_approval_state_detectable: hookApprovalKnown,
-            skill_picker_ready: Boolean(hasSkills),
-            agent_type_supported: process.env.SKS_CODEX_AGENT_TYPE_SUPPORTED === '1',
-            mcp_inventory_ready: Array.isArray(plugins.plugins),
-            app_handoff_ready: cap0138.supports_app_handoff === true,
-            image_path_exposure_ready: cap0138.supports_image_path_exposure === true
-        },
-        sks_integrations: {
-            dollar_skills_synced: Boolean(hasSkills),
-            agent_roles_synced: agents.ok !== false,
-            hooks_synced: hooks.ok !== false && (hooks.entries || []).length > 0,
-            init_deep_available: true,
-            loop_mesh_app_profile_available: true
-        },
-        blockers: [
-            ...(!codexBin ? ['codex_cli_missing'] : []),
-            ...(cap0138.blockers || []),
-            ...(plugins.blockers || []),
-            ...(agents.blockers || [])
-        ],
-        warnings: [
-            ...(cap0139.blockers || []).map((b) => `codex_0139:${b}`),
-            ...(hooks.blockers || []).map((b) => `hooks:${b}`),
-            ...(!hookApprovalKnown ? ['hook_approval_state_unknown'] : []),
-            ...(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) {
@@ -68,8 +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;
-}
 //# sourceMappingURL=codex-app-harness-matrix.js.map

package/dist/core/codex-app/codex-app-types.js

@@ -0,0 +1,21 @@
+export function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function stringList(value) {
+    return Array.isArray(value) ? value.map((item) => String(item)).filter(Boolean) : [];
+}
+export function isCodexAppHarnessMatrix(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.schema !== 'sks.codex-app-harness-matrix.v1')
+        return false;
+    const app = value.app_features;
+    const sks = value.sks_integrations;
+    return isRecord(app)
+        && isRecord(sks)
+        && typeof value.ok === 'boolean'
+        && isRecord(value.codex_cli)
+        && Array.isArray(value.blockers)
+        && Array.isArray(value.warnings);
+}
+//# sourceMappingURL=codex-app-types.js.map