sneakoscope 3.1.4 → 3.1.5

package/README.md

@@ -35,7 +35,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.1.4** makes `doctor --fix` a real Zellij dependency self-healer, lets `sks --mad` repair or explicitly run headless without contradictory optional/blocking messages, and adds Codex App Harness Matrix reporting for plugins, hooks, skills, agent roles, init-deep memory, and execution profile decisions.
+SKS **3.1.5** productionizes the Codex App harness with typed probe surfaces, dry-run Zellij self-heal planning, hook approval and `agent_type` evidence, LazyCodex live-source analysis, init-deep directory memory hints, and execution profile routing across Loop, QA, Research, and Naruto artifacts.
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "3.1.4"
+version = "3.1.5"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.1.4"
+version = "3.1.5"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 3.1.4"),
+        Some("--version") => println!("sks-rs 3.1.5"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "3.1.4",
-  "source_digest": "47f6028f6b91151c205109059bff2ef5c51d2f084ae930063eca118d1888a8fc",
-  "source_file_count": 2488,
-  "built_at_source_time": 1781425289529
+  "package_version": "3.1.5",
+  "source_digest": "89b81e91ec4d82c33320922ae0dc33bd6562ccf37c58171858e7f703d7767e4b",
+  "source_file_count": 2518,
+  "built_at_source_time": 1781439913355
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '3.1.4';
+const FAST_PACKAGE_VERSION = '3.1.5';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/install-helpers.js

@@ -144,6 +144,8 @@ async function reportPostinstallCodexLbAuth() {
         console.log(`codex-lb auth: restored from existing Codex login cache into ${codexLbAuth.env_path}.`);
     else if (codexLbAuth.status === 'synced' || codexLbAuth.status === 'present' || codexLbAuth.status === 'repaired')
         console.log(`codex-lb auth: preserved from ${codexLbAuth.env_path}.`);
+    else if (codexLbAuth.status === 'present_unselected')
+        console.log('codex-lb auth: preserved but not selected; ChatGPT OAuth remains active.');
     else if (codexLbAuth.status === 'skipped')
         console.log(`codex-lb auth: skipped (${codexLbAuth.reason}).`);
     else if (codexLbAuth.status === 'missing_env_key')
@@ -284,6 +286,7 @@ async function capturePostinstallCodexLbConfigSnapshot(home = process.env.HOME |
         env_path: envPath,
         auth_path: authPath,
         base_url: baseUrl ? normalizeCodexLbBaseUrl(baseUrl) : null,
+        selected: hasTopLevelCodexLbSelected(config),
         auth_existed: authExisted,
         auth_text: authText
     };
@@ -294,7 +297,7 @@ async function restorePostinstallCodexLbConfigSnapshot(snapshot) {
     let configRestored = false;
     if (snapshot.base_url) {
         const current = await readText(snapshot.config_path, '');
-        const next = normalizeCodexFastModeUiConfig(upsertCodexLbConfig(current, snapshot.base_url));
+        const next = normalizeCodexFastModeUiConfig(upsertCodexLbConfig(current, snapshot.base_url, snapshot.selected === true));
         const alreadyOk = next === ensureTrailingNewline(current) && codexLbProviderBaseUrl(current);
         if (!alreadyOk) {
             const safeWrite = await safeWriteCodexConfigToml(snapshot.config_path, current, next, 'codex-lb-restore');
@@ -488,6 +491,12 @@ export async function codexLbStatus(opts = {}) {
     const providerEnvKey = codexLbProviderEnvKey(config);
     const providerUsesCodexLbEnvAuth = providerConfigured && providerEnvKey === 'CODEX_LB_API_KEY' && providerOpenAiAuthDisabled;
     const codexAppUsableWithCodexLb = providerUsesCodexLbEnvAuth && envKeyConfigured && Boolean(baseUrl);
+    const launchEnvironment = await inspectCodexLbMacLaunchEnvironment(baseUrl, opts).catch((err) => ({
+        checked: true,
+        available: false,
+        status: 'inspect_failed',
+        error: err.message
+    }));
     return {
         ok: providerConfigured && envKeyConfigured && Boolean(baseUrl) && providerUsesCodexLbEnvAuth,
         config_path: configPath,
@@ -514,7 +523,8 @@ export async function codexLbStatus(opts = {}) {
         auth_path: authPath,
         auth_mode: authMode.mode,
         auth_usable_for_codex_app: authMode.codex_app_usable || codexAppUsableWithCodexLb,
-        auth_summary: codexAppUsableWithCodexLb ? 'codex-lb provider uses CODEX_LB_API_KEY env_key; OpenAI OAuth not required' : authMode.summary
+        auth_summary: codexAppUsableWithCodexLb ? 'codex-lb provider uses CODEX_LB_API_KEY env_key; OpenAI OAuth not required' : authMode.summary,
+        launch_environment: launchEnvironment
     };
 }
 export function formatCodexLbStatusText(status = {}, opts = {}) {
@@ -541,12 +551,12 @@ export function formatCodexLbStatusText(status = {}, opts = {}) {
         lines.push('', 'Sign in to Codex App/CLI again, then run: sks codex-lb repair');
     else if (status.ok && !status.selected)
         lines.push('', 'Run: sks codex-lb repair to activate codex-lb for Codex App.');
+    else if (status.ok)
+        lines.push('', 'Status: codex-lb active; no repair needed.');
     else if (!status.ok && status.base_url && status.env_key_configured)
         lines.push('', 'Run: sks codex-lb repair to restore the upstream codex-lb provider block.');
     else if (!status.ok)
         lines.push('', 'Run: sks codex-lb setup --host <domain> --api-key <key>');
-    else
-        lines.push('', 'Repair provider auth: sks codex-lb repair');
     if (backupPresent)
         lines.push('Switch fully away from codex-lb: sks codex-lb release');
     return `${lines.join('\n')}\n`;
@@ -862,6 +872,17 @@ export async function ensureCodexLbAuthDuringInstall(opts = {}) {
     const status = await codexLbStatus(opts);
     if (!status.selected && !status.provider_configured && !status.env_file)
         return { status: 'not_configured', codex_lb: status };
+    if (status.ok && !status.selected && status.auth_mode === 'chatgpt_oauth') {
+        return {
+            ok: true,
+            status: 'present_unselected',
+            reason: 'chatgpt_oauth_active_codex_lb_unselected',
+            config_path: status.config_path,
+            env_path: status.env_path,
+            base_url: status.base_url,
+            codex_lb: status
+        };
+    }
     await migrateCodexAuthKeyFormat({ home: opts.home });
     if (status.ok && (!status.selected || !status.provider_uses_codex_lb_env_auth))
         return repairCodexLbAuth(opts);
@@ -1236,6 +1257,9 @@ export async function maybePromptCodexLbSetupForLaunch(args = [], opts = {}) {
     if (args.includes('--json') || args.includes('--skip-codex-lb') || process.env.SKS_SKIP_CODEX_LB_PROMPT === '1')
         return { status: 'skipped' };
     let status = await codexLbStatus(opts);
+    if (status.env_key_configured && status.base_url && !status.selected && status.auth_mode === 'chatgpt_oauth') {
+        return { status: 'continued_to_codex', ok: false, chain_health: null, codex_lb: status, reason: 'chatgpt_oauth_active_codex_lb_unselected' };
+    }
     if (status.env_key_configured && status.base_url && (!status.provider_configured || !status.selected || !status.provider_uses_codex_lb_env_auth)) {
         let promptedRestore = false;
         if (!status.provider_configured && canAskYesNo()) {
@@ -1355,6 +1379,34 @@ async function syncCodexLbMacLaunchEnvironment(values = {}, opts = {}) {
         return { ok: false, status: 'launch_env_failed', variables: results.map((result) => result.key), failed, error: failed.map((result) => `${result.key}: ${result.error}`).join('; ') };
     return { ok: true, status: 'synced', variables: results.map((result) => result.key) };
 }
+async function inspectCodexLbMacLaunchEnvironment(baseUrl = '', opts = {}) {
+    if (process.platform !== 'darwin' && !opts.forceLaunchEnv)
+        return { checked: false, status: 'not_macos', skipped: true };
+    const launchctl = opts.launchctlBin || await which('launchctl').catch(() => null) || await exists('/bin/launchctl').then((ok) => ok ? '/bin/launchctl' : null).catch(() => null);
+    if (!launchctl)
+        return { checked: true, available: false, status: 'launchctl_missing' };
+    const readVar = async (key) => {
+        const result = await runProcess(launchctl, ['getenv', key], { timeoutMs: 3000, maxOutputBytes: 8192 });
+        return result.code === 0 ? String(result.stdout || '').trim() : '';
+    };
+    const currentBaseUrl = await readVar('CODEX_LB_BASE_URL');
+    const currentApiKey = await readVar('CODEX_LB_API_KEY');
+    const baseMatches = !baseUrl || currentBaseUrl === String(baseUrl || '').trim();
+    const basePresent = Boolean(currentBaseUrl);
+    const keyPresent = Boolean(currentApiKey);
+    return {
+        checked: true,
+        available: true,
+        status: basePresent && keyPresent && baseMatches ? 'synced' : basePresent || keyPresent ? 'partial' : 'missing',
+        variables: [
+            ...(keyPresent ? ['CODEX_LB_API_KEY'] : []),
+            ...(basePresent ? ['CODEX_LB_BASE_URL'] : [])
+        ],
+        base_url_present: basePresent,
+        base_url_matches: baseMatches,
+        api_key_present: keyPresent
+    };
+}
 async function maybeSyncCodexLbSharedLogin(apiKey, opts = {}) {
     if (!apiKey)
         return { ok: false, status: 'missing_env_key' };

package/dist/commands/codex-lb.js

@@ -302,16 +302,19 @@ async function resolveNewApiKey(args = []) {
     return '';
 }
 function shapeCodexLbStatus(status = {}) {
-    const mode = status.env_loader?.api_key?.source === 'env-file'
-        ? 'durable_env_file'
-        : status.env_loader?.api_key?.source === 'keychain'
-            ? 'durable_keychain'
-            : status.env_loader?.api_key?.source === 'process.env'
-                ? 'process_only_ephemeral'
-                : 'none';
+    const modes = [];
+    if (status.env_file && status.env_key_configured)
+        modes.push('durable_env_file');
+    if (status.env_loader?.api_key?.source === 'keychain' || status.env_loader?.keychain?.status === 'present')
+        modes.push('durable_keychain');
+    if (status.launch_environment?.status === 'synced')
+        modes.push('durable_launchctl');
+    if (!modes.length && status.env_loader?.api_key?.source === 'process.env')
+        modes.push('process_only_ephemeral');
+    const mode = modes[0] || 'none';
     const persistence = codexLbPersistenceSummary({
-        selectedModes: mode === 'none' ? [] : [mode],
-        appliedModes: mode === 'none' ? ['none'] : [mode],
+        selectedModes: modes.length ? modes : [],
+        appliedModes: modes.length ? modes : mode === 'none' ? ['none'] : [mode],
         processOnly: mode === 'process_only_ephemeral'
     });
     return {

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,97 @@ 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'))
                 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.5 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.5 directive role.`,
+        'Use the assigned scope only, cite concrete repo evidence, keep mutation surfaces bounded, and never clobber user files.',
+        'Report blockers as evidence-backed findings and write route artifacts before claiming completion.',
+        `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,13 +1,14 @@
-// @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';
 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
+    const maybeMatrix = input.matrix || await buildCodexAppHarnessMatrix({ root }).catch(() => null);
+    const matrix = isCodexAppHarnessMatrix(maybeMatrix) ? maybeMatrix : null;
+    const mode = !matrix?.codex_cli.available
         ? 'degraded-no-app'
-        : matrix.app_features?.app_handoff_ready && matrix.app_features?.agent_type_supported
+        : matrix.app_features.app_handoff_ready && matrix.app_features.agent_type_supported
             ? 'codex-app-native'
             : matrix.codex_cli.available
                 ? 'codex-cli-headless'
@@ -17,12 +18,18 @@ export async function resolveCodexAppExecutionProfile(input = { root: process.cw
         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: matrix?.app_features.agent_type_supported ? 'agent_type' : 'message-role',
         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: matrix?.app_features.hook_approval_state !== 'approved',
+        hook_approval_state: matrix?.app_features.hook_approval_state || 'unknown',
+        app_handoff_ready: matrix?.app_features.app_handoff_ready === true,
+        image_path_exposure_ready: matrix?.app_features.image_path_exposure_ready === true,
+        plugin_mcp_inventory_ready: 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: '.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 || []
     };

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) {