sneakoscope 6.0.3 → 6.1.2

package/dist/core/codex-lb/codex-lb-tool-output-recovery.js

@@ -0,0 +1,291 @@
+import { codexLbBaseUrlSecurityBlocker, normalizeCodexLbBaseUrl } from './codex-lb-env.js';
+import { redactString } from '../secret-redaction.js';
+export const CODEX_LB_TOOL_OUTPUT_RECOVERY_SCHEMA = 'sks.codex-lb-tool-output-recovery.v1';
+export const CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION = '1.21.0-beta.3';
+export const CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_ENV = 'SKS_ALLOW_UNVERIFIED_CODEX_LB_RECOVERY';
+export const CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_FLAG = '--allow-unverified-codex-lb-recovery';
+const UPGRADE_ACTION = `Upgrade codex-lb to ${CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION} or later, then rerun \`sks codex-lb status\`.`;
+const OAUTH_ACTION = 'To avoid the proxy, run `sks codex-lb use-oauth`; SKS will not switch providers silently.';
+const FRESH_THREAD_ACTION = 'After upgrading or switching providers, open a fresh Codex thread and continue the persisted mission; do not replay the corrupted turn.';
+export async function probeCodexLbToolOutputRecovery(opts = {}) {
+    const baseUrl = normalizeCodexLbBaseUrl(opts.baseUrl);
+    if (!baseUrl) {
+        return blockedProbe('invalid_base_url', {
+            baseUrl: null,
+            healthUrl: null,
+            blockers: ['codex_lb_tool_output_recovery_base_url_missing']
+        });
+    }
+    const transportBlocker = codexLbBaseUrlSecurityBlocker(baseUrl);
+    if (transportBlocker) {
+        return blockedProbe('transport_blocked', {
+            baseUrl,
+            healthUrl: codexLbHealthUrl(baseUrl),
+            blockers: [transportBlocker]
+        });
+    }
+    const healthUrl = codexLbHealthUrl(baseUrl);
+    if (!healthUrl) {
+        return blockedProbe('invalid_base_url', {
+            baseUrl,
+            healthUrl: null,
+            blockers: ['codex_lb_tool_output_recovery_base_url_invalid']
+        });
+    }
+    if (opts.allowReservedTestHostBypass === true && isReservedTestHost(baseUrl)) {
+        return {
+            ...baseProbe(baseUrl, healthUrl),
+            ok: true,
+            status: 'skipped_reserved_host',
+            required: false,
+            test_bypass: true
+        };
+    }
+    const fetchImpl = opts.fetchImpl || globalThis.fetch;
+    if (typeof fetchImpl !== 'function') {
+        return applyCodexLbToolOutputRecoveryOverride(blockedProbe('probe_unavailable', {
+            baseUrl,
+            healthUrl,
+            blockers: ['codex_lb_tool_output_recovery_probe_unavailable']
+        }), opts.allowUnverified === true);
+    }
+    const controller = new AbortController();
+    const timeoutMs = Math.max(250, Number(opts.timeoutMs || 4_000));
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    try {
+        const response = await fetchImpl(healthUrl, {
+            method: 'GET',
+            headers: { accept: 'application/json' },
+            redirect: 'follow',
+            signal: controller.signal
+        });
+        if (!response.ok) {
+            return applyCodexLbToolOutputRecoveryOverride(blockedProbe('probe_unavailable', {
+                baseUrl,
+                healthUrl,
+                httpStatus: response.status,
+                blockers: [`codex_lb_tool_output_recovery_health_http_error:${response.status}`]
+            }), opts.allowUnverified === true);
+        }
+        const observedVersion = normalizeCodexLbVersion(response.headers.get('x-app-version'));
+        if (!observedVersion) {
+            return applyCodexLbToolOutputRecoveryOverride(blockedProbe('version_unverified', {
+                baseUrl,
+                healthUrl,
+                httpStatus: response.status,
+                blockers: ['codex_lb_tool_output_recovery_version_unverified']
+            }), opts.allowUnverified === true);
+        }
+        const compatible = compareCodexLbVersions(observedVersion, CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION) >= 0;
+        const result = {
+            ...baseProbe(baseUrl, healthUrl),
+            ok: compatible,
+            status: compatible ? 'compatible' : 'version_too_old',
+            observed_version: observedVersion,
+            supports_interrupted_tool_output_recovery: compatible,
+            verified: true,
+            http_status: response.status,
+            blockers: compatible ? [] : ['codex_lb_tool_output_recovery_version_too_old']
+        };
+        return applyCodexLbToolOutputRecoveryOverride(result, opts.allowUnverified === true);
+    }
+    catch (err) {
+        const error = err instanceof Error
+            ? err.name === 'AbortError' ? 'codex-lb health probe timed out' : redactCodexLbProbeText(err.message)
+            : redactCodexLbProbeText(String(err));
+        return applyCodexLbToolOutputRecoveryOverride(blockedProbe('probe_unavailable', {
+            baseUrl,
+            healthUrl,
+            blockers: ['codex_lb_tool_output_recovery_probe_failed'],
+            error
+        }), opts.allowUnverified === true);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function codexLbToolOutputRecoveryNotSelected() {
+    return {
+        ...baseProbe(null, null),
+        ok: true,
+        required: false,
+        status: 'not_selected'
+    };
+}
+export function codexLbToolOutputRecoveryNotChecked(required = false) {
+    return {
+        ...baseProbe(null, null),
+        ok: !required,
+        required,
+        status: 'not_checked',
+        blockers: required ? ['codex_lb_tool_output_recovery_not_checked'] : []
+    };
+}
+export function codexLbToolOutputRecoveryOverrideAcknowledged(input = {}) {
+    const args = (input.args || []).map((arg) => String(arg));
+    const env = input.env || process.env;
+    return args.includes(CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_FLAG)
+        || env[CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_ENV] === '1';
+}
+export function applyCodexLbToolOutputRecoveryOverride(probe, acknowledged) {
+    if (probe.ok || !acknowledged)
+        return probe;
+    return {
+        ...probe,
+        ok: true,
+        status: 'override_acknowledged',
+        override_acknowledged: true,
+        blockers: [],
+        warnings: [
+            ...probe.warnings,
+            `Operator explicitly acknowledged unverified codex-lb tool-output recovery via ${CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_FLAG} or ${CODEX_LB_TOOL_OUTPUT_RECOVERY_OVERRIDE_ENV}=1.`,
+            ...probe.blockers
+        ]
+    };
+}
+export function codexLbHealthUrl(baseUrl) {
+    try {
+        const parsed = new URL(normalizeCodexLbBaseUrl(baseUrl));
+        return new URL('/health', parsed.origin).toString();
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeCodexLbVersion(value) {
+    const match = String(value || '').trim().match(/v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
+    if (!match)
+        return null;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    if (![major, minor, patch].every(Number.isSafeInteger))
+        return null;
+    return `${major}.${minor}.${patch}${match[4] ? `-${match[4]}` : ''}`;
+}
+export function compareCodexLbVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return -1;
+    for (let index = 0; index < 3; index += 1) {
+        const delta = (a.core[index] || 0) - (b.core[index] || 0);
+        if (delta !== 0)
+            return delta > 0 ? 1 : -1;
+    }
+    if (!a.pre.length && !b.pre.length)
+        return 0;
+    if (!a.pre.length)
+        return 1;
+    if (!b.pre.length)
+        return -1;
+    const length = Math.max(a.pre.length, b.pre.length);
+    for (let index = 0; index < length; index += 1) {
+        const aPart = a.pre[index];
+        const bPart = b.pre[index];
+        if (aPart === undefined)
+            return -1;
+        if (bPart === undefined)
+            return 1;
+        if (aPart === bPart)
+            continue;
+        const aNumber = /^\d+$/.test(aPart) ? Number(aPart) : null;
+        const bNumber = /^\d+$/.test(bPart) ? Number(bPart) : null;
+        if (aNumber !== null && bNumber !== null)
+            return aNumber > bNumber ? 1 : -1;
+        if (aNumber !== null)
+            return -1;
+        if (bNumber !== null)
+            return 1;
+        return aPart > bPart ? 1 : -1;
+    }
+    return 0;
+}
+function baseProbe(baseUrl, healthUrl) {
+    return {
+        schema: CODEX_LB_TOOL_OUTPUT_RECOVERY_SCHEMA,
+        ok: false,
+        required: true,
+        status: 'version_unverified',
+        base_url: redactCodexLbProbeUrl(baseUrl),
+        health_url: redactCodexLbProbeUrl(healthUrl),
+        observed_version: null,
+        minimum_version: CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION,
+        version_header: 'x-app-version',
+        supports_interrupted_tool_output_recovery: null,
+        verified: false,
+        override_acknowledged: false,
+        test_bypass: false,
+        http_status: null,
+        blockers: [],
+        warnings: [],
+        operator_actions: [UPGRADE_ACTION, OAUTH_ACTION, FRESH_THREAD_ACTION]
+    };
+}
+function blockedProbe(status, input) {
+    return {
+        ...baseProbe(input.baseUrl, input.healthUrl),
+        status,
+        blockers: input.blockers,
+        ...(input.httpStatus === undefined ? {} : { http_status: input.httpStatus }),
+        ...(input.error === undefined ? {} : { error: redactCodexLbProbeText(input.error) })
+    };
+}
+function redactCodexLbProbeUrl(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = new URL(value);
+        parsed.username = '';
+        parsed.password = '';
+        parsed.hash = '';
+        for (const key of [...parsed.searchParams.keys()]) {
+            if (/(?:access[_-]?token|api[_-]?key|secret|password|token|credential)/i.test(key)) {
+                parsed.searchParams.set(key, 'redacted');
+            }
+        }
+        return redactCodexLbProbeText(parsed.toString());
+    }
+    catch {
+        return redactCodexLbProbeText(value);
+    }
+}
+function redactCodexLbProbeText(value) {
+    return redactString(String(value || ''))
+        .replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/gi, '$1[redacted]@')
+        .replace(/([?&](?:access[_-]?token|api[_-]?key|secret|password|token|credential)=)[^&#\s]*/gi, '$1[redacted]')
+        .replace(/(\b(?:access[_-]?token|api[_-]?key|secret|password|token|credential)\s*[:=]\s*)(?:\[redacted\]|"[^"]*"|'[^']*'|[^\s,;}\]]+)/gi, '$1[redacted]');
+}
+function parseVersion(value) {
+    const normalized = normalizeCodexLbVersion(value);
+    if (!normalized)
+        return null;
+    const [coreText = '', preText = ''] = normalized.split('-', 2);
+    const coreParts = coreText.split('.').map(Number);
+    const major = coreParts[0];
+    const minor = coreParts[1];
+    const patch = coreParts[2];
+    if (major === undefined || minor === undefined || patch === undefined)
+        return null;
+    return { core: [major, minor, patch], pre: preText ? preText.split('.') : [] };
+}
+function isReservedTestHost(baseUrl) {
+    try {
+        const hostname = new URL(baseUrl).hostname.toLowerCase();
+        return hostname === 'example.test'
+            || hostname.endsWith('.example.test')
+            || hostname === 'example.invalid'
+            || hostname.endsWith('.example.invalid')
+            || hostname === 'example.com'
+            || hostname.endsWith('.example.com')
+            || hostname === 'example.org'
+            || hostname.endsWith('.example.org')
+            || hostname === 'example.net'
+            || hostname.endsWith('.example.net');
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=codex-lb-tool-output-recovery.js.map

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

@@ -7,15 +7,15 @@ import { probeCodexHookApprovalState } from '../codex-app/codex-hook-approval-pr
 import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
 import { detectCodex0139Capability } from '../codex-control/codex-0139-capability.js';
 import { detectCodex0140Capability } from '../codex-control/codex-0140-capability.js';
-import { detectCodex0142Capability } from '../codex-control/codex-0142-capability.js';
+import { detectCodex0144Capability } from '../codex-control/codex-0144-capability.js';
 import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
 import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
-import { MANAGED_AGENT_ROLES, MANAGED_SKILLS, managedAgentRoleOwnsText } from '../managed-assets/managed-assets-manifest.js';
+import { MANAGED_OFFICIAL_SUBAGENT_ROLES, MANAGED_SKILLS, managedOfficialSubagentRoleOwnsText } from '../managed-assets/managed-assets-manifest.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 = MANAGED_SKILLS.map((skill) => skill.id);
-const REQUIRED_AGENT_ROLES = MANAGED_AGENT_ROLES.map((role) => role.id);
+const REQUIRED_AGENT_ROLES = MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.id);
 const invocationMatrixCache = new Map();
 export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd() }) {
     const root = path.resolve(input.root || process.cwd());
@@ -37,26 +37,26 @@ export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd(
             process.env.SKS_CODEX_0138_FAKE,
             process.env.SKS_CODEX_0139_FAKE,
             process.env.SKS_CODEX_0140_FAKE,
-            process.env.SKS_CODEX_0142_FAKE,
+            process.env.SKS_CODEX_0144_FAKE,
             process.env.SKS_CODEX_PLUGIN_JSON_FAKE
         ]
     });
     if (!input.missionDir && !repairManagedAssets && invocationMatrixCache.has(cacheKey)) {
         return invocationMatrixCache.get(cacheKey);
     }
-    const fixtureMode = process.env.SKS_CODEX_0138_FAKE === '1' || process.env.SKS_CODEX_0139_FAKE === '1' || process.env.SKS_CODEX_0140_FAKE === '1' || process.env.SKS_CODEX_0142_FAKE === '1' || process.env.SKS_CODEX_PLUGIN_JSON_FAKE === '1';
+    const fixtureMode = process.env.SKS_CODEX_0138_FAKE === '1' || process.env.SKS_CODEX_0139_FAKE === '1' || process.env.SKS_CODEX_0140_FAKE === '1' || process.env.SKS_CODEX_0144_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 cap0140 = await detectCodex0140Capability({ codexBin }).catch((err) => ({ blockers: [messageOf(err)] }));
-    const cap0142 = await detectCodex0142Capability({ codexBin, root }).catch((err) => ({
-        schema: 'sks.codex-0142-capability.v1',
+    const cap0144 = await detectCodex0144Capability({ codexBin, root }).catch((err) => ({
+        schema: 'sks.codex-0144-capability.v1',
         ok: false,
         release_authorizing: false,
         feature_states: {},
         blockers: [messageOf(err)],
-        warnings: ['codex_0142_probe_exception']
+        warnings: ['codex_0144_probe_exception']
     }));
     const app = await codexAppIntegrationStatus({ codex: { bin: codexBin, version, available: Boolean(codexBin) } }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
     const plugins = await buildCodexPluginInventory().catch((err) => ({
@@ -141,17 +141,17 @@ export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd(
         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)),
-        codex_0142: boolState(recordOk(cap0142) === true, 'actual-probe', '.sneakoscope/codex/codex-0142-capability.json', blockersOf(cap0142), warningsOf(cap0142)),
-        multi_agent_mode: codex0142State(cap0142, 'multi_agent_mode_schema'),
-        rollout_budget: codex0142State(cap0142, 'rollout_budget_schema'),
-        indexed_web_search: codex0142State(cap0142, 'indexed_web_search_schema'),
-        current_time_read: codex0142State(cap0142, 'current_time_read_schema'),
-        terminal_subagent_error: codex0142State(cap0142, 'terminal_subagent_error_schema'),
-        exec_mcp_reconnect: codex0142State(cap0142, 'exec_mcp_reconnect_schema'),
-        plugin_catalog_refresh: codex0142State(cap0142, 'plugin_catalog_refresh_schema'),
-        native_thread_list_search: codex0142State(cap0142, 'native_thread_list_search_schema'),
-        remote_native_environment: codex0142State(cap0142, 'remote_native_environment_schema'),
-        app_server_overload: codex0142State(cap0142, 'app_server_overload_schema'),
+        codex_0144: boolState(recordOk(cap0144) === true, 'actual-probe', '.sneakoscope/codex/codex-0144-capability.json', blockersOf(cap0144), warningsOf(cap0144)),
+        multi_agent_mode: codex0144State(cap0144, 'multi_agent_mode_schema'),
+        rollout_budget: codex0144State(cap0144, 'rollout_budget_schema'),
+        indexed_web_search: codex0144State(cap0144, 'indexed_web_search_schema'),
+        current_time_read: codex0144State(cap0144, 'current_time_read_schema'),
+        terminal_subagent_error: codex0144State(cap0144, 'terminal_subagent_error_schema'),
+        exec_mcp_reconnect: codex0144State(cap0144, 'exec_mcp_reconnect_schema'),
+        plugin_catalog_refresh: codex0144State(cap0144, 'plugin_catalog_refresh_schema'),
+        native_thread_list_search: codex0144State(cap0144, 'native_thread_list_search_schema'),
+        remote_native_environment: codex0144State(cap0144, 'remote_native_environment_schema'),
+        app_server_overload: codex0144State(cap0144, 'app_server_overload_schema'),
         codex_0140: boolState(booleanFeature(cap0140, 'supports_0140'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
         usage_views: boolState(booleanFeature(cap0140?.features || {}, 'usage_views'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
         goal_attachment_preservation: boolState(booleanFeature(cap0140?.features || {}, 'goal_attachment_preservation'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
@@ -176,7 +176,7 @@ export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd(
             codex_0138: cap0138,
             codex_0139: cap0139,
             codex_0140: cap0140,
-            codex_0142: cap0142,
+            codex_0144: cap0144,
             app,
             plugin_inventory: plugins,
             mcp_candidates: mcpCandidates,
@@ -248,22 +248,15 @@ async function inspectManagedSkillState(root) {
     };
 }
 async function inspectManagedAgentRoleState(root) {
-    const dirs = [
-        path.join(root, '.codex', 'agents'),
-        ...(process.env.CODEX_HOME ? [path.join(process.env.CODEX_HOME, 'agents')] : [])
-    ];
+    const dir = path.join(root, '.codex', '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 MANAGED_AGENT_ROLES) {
-            if (managed.has(role.id))
-                continue;
-            const text = await fs.readFile(path.join(dir, role.filename), 'utf8').catch(() => '');
-            if (managedAgentRoleOwnsText(text, role))
-                managed.add(role.id);
-        }
+    const rows = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    existingCount = rows.filter((row) => row.isFile() && row.name.endsWith('.toml')).length;
+    for (const role of MANAGED_OFFICIAL_SUBAGENT_ROLES) {
+        const text = await fs.readFile(path.join(dir, role.filename), 'utf8').catch(() => '');
+        if (managedOfficialSubagentRoleOwnsText(text, role))
+            managed.add(role.id);
     }
     const missing = REQUIRED_AGENT_ROLES.filter((role) => !managed.has(role));
     return {
@@ -336,23 +329,23 @@ function warningsOf(value) {
         return [];
     return value.warnings.map((item) => String(item)).filter(Boolean);
 }
-function codex0142State(capability, key) {
+function codex0144State(capability, key) {
     const state = isRecord(capability)
         && isRecord(capability.feature_states)
         && isRecord(capability.feature_states[key])
         ? capability.feature_states[key]
         : null;
     const evidence = Array.isArray(state?.evidence) ? state.evidence.map(String) : [];
-    const blockers = Array.isArray(state?.blockers) ? state.blockers.map(String) : [`codex_0142_${key}_not_verified`];
+    const blockers = Array.isArray(state?.blockers) ? state.blockers.map(String) : [`codex_0144_${key}_not_verified`];
     const supported = state?.supported === true;
     const certainty = typeof state?.certainty === 'string' ? state.certainty : '';
     const input = {
         ok: supported,
         source: 'actual-probe',
-        artifact_path: '.sneakoscope/codex/codex-0142-capability.json',
+        artifact_path: '.sneakoscope/codex/codex-0144-capability.json',
         evidence,
         blockers: supported ? [] : blockers,
-        warnings: certainty && certainty !== 'actual' && certainty !== 'discovered' ? [`codex_0142_${key}_${certainty}`] : []
+        warnings: certainty && certainty !== 'actual' && certainty !== 'discovered' ? [`codex_0144_${key}_${certainty}`] : []
     };
     if (!supported)
         input.unavailableStatus = 'fallback';

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

@@ -21,14 +21,14 @@ export function computeCodexNativeInvocationDefaults(matrix) {
     return {
         loop_worker_role_strategy: features.agent_type.ok ? 'agent_type' : 'message-role',
         multi_agent_mode: multiAgentOk && features.agent_type.ok ? 'proactive' : multiAgentOk ? 'explicitRequestOnly' : 'none',
-        rollout_budget_strategy: rolloutBudgetOk ? 'codex-0142-shared' : 'sks-local-only',
+        rollout_budget_strategy: rolloutBudgetOk ? 'codex-0144-shared' : 'sks-local-only',
         qa_visual_review_strategy: features.app_handoff.ok ? 'app-handoff' : 'headless-artifact',
         research_source_strategy: indexedSearchOk ? 'indexed-web-search' : 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',
         current_time_source: currentTimeOk ? 'codex-currentTime-read' : 'external-clock',
-        overload_retry_policy: overloadOk ? 'codex-0142-retryable' : 'generic'
+        overload_retry_policy: overloadOk ? 'codex-0144-retryable' : 'generic'
     };
 }
 export function matrixFeatureOk(matrix, key) {

package/dist/core/codex-native/codex-native-repair-transaction.js

@@ -54,7 +54,7 @@ export async function repairCodexNativeManagedAssets(input) {
         rows.push({
             asset: 'agent_roles',
             ok: recordOk(report) !== false,
-            changed: listLength(report, 'created') > 0,
+            changed: listLength(report, 'created') + listLength(report, 'updated') > 0,
             artifact_path: '.sneakoscope/reports/codex-agent-role-sync.json',
             blockers: blockersOf(report)
         });

package/dist/core/codex-native/core-skill-manifest.js

@@ -20,10 +20,13 @@ const CORE_SKILL_DEFINITIONS = [
         canonical_name: 'naruto',
         display_name: 'naruto',
         route: '$Naruto',
-        purpose: 'fan out bounded native worker lanes while parent integration remains owner.',
-        when: 'Use when the selected route explicitly requires high-scale parallel review or implementation.',
-        evidence: 'agent task graph, worker ledgers, leases, proof evidence, and cleanup artifacts.',
-        fallback: 'Degrade to parent-owned execution with blockers recorded if native lanes are unavailable.'
+        purpose: 'run a Codex official subagent workflow with official agent threads while parent integration remains owner.',
+        when: 'Use when the user explicitly invokes $Naruto or the selected route requires bounded parallel delegation.',
+        workflow: 'Use sks naruto run "<task>" [--agents N] [--max-threads N] [--json]. Automatic fan-out is one by default, two only for an explicit parallel request or independent risk domains, and at most three for critical multi-domain risk; an explicit operator --agents N remains authoritative. The GPT-5.6 Sol Max parent selects the narrow project-scoped custom role whose description matches each defensible slice: GPT-5.6 Luna Max for clear bounded work and exploration, GPT-5.6 Sol Max for complex implementation, UI, debugging, testing, architecture, integration, security, DB, research, release, and other judgment-sensitive work. Read-only roles declare sandbox_mode="read-only"; write roles inherit the parent permission mode. Treat Codex [agents].max_threads as the concurrency authority, keep max_depth=1, avoid duplicate or overlapping write slices, wait for every requested subagent, reuse only bounded TriWiki attention.use_first anchors with on-demand source hydration, treat SubagentStart/SubagentStop as lifecycle-only evidence, require subagent-parent-summary.json with one structured outcome per thread, and let the parent own integration and final judgment.',
+        safety: 'Preserve user-authored content, inherit the parent permission mode, do not spawn nested subagents, do not inject the full pack or the full TriWiki context into every child, and do not fall back to another model, process swarm, custom scheduler, or worker pool. The historical Naruto process runtime is removed; stop with explicit blocker evidence when the official path is unavailable.',
+        cli: 'sks naruto run "<task>" [--agents N] [--max-threads N] [--json]; sks naruto status|subagents|proof [--mission <id>] [--json]',
+        evidence: 'subagent-plan.json, subagent-events.jsonl, subagent-parent-summary.json, subagent-evidence.json, naruto-summary.json, and naruto-gate.json.',
+        fallback: 'Return explicit official-subagent availability blockers and continue parent-owned only when the sealed task still has meaningful in-scope work; never fabricate process, PID, or subagent evidence.'
     },
     {
         id: 'sks-core-qa-loop',
@@ -43,6 +46,7 @@ const CORE_SKILL_DEFINITIONS = [
         route: '$Research',
         purpose: 'run evidence-bound discovery, source ledgers, and synthesis cycles.',
         when: 'Use for discovery, evaluation, external-source claims, or frontier-style research.',
+        workflow: 'Run layered Super Search first and accept only source rows correlated to verified proof, source-ledger, and hydrated-content artifacts. Then run exactly three independent official research_reviewer threads on GPT-5.6 Sol Max using Einstein, von Neumann, and Skeptic composite lenses. Any objection triggers a mission-local research_synthesizer revision and a fresh three-thread review cycle. agent-ledger.json and debate-ledger.json are compatibility projections only; do not launch a removed legacy scheduler or a custom debate pool.',
         evidence: 'research plan, source ledger, cycle record, synthesis, and final review.',
         fallback: 'State source/tool unavailability and avoid unsupported live-accuracy claims.'
     },

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

@@ -49,13 +49,20 @@ async function postcheckCapability(root, state, fixture) {
     return { ...state, after: 'blocked', blockers: [...state.blockers, `unknown_capability:${state.id}`] };
 }
 function postcheckImageGeneration(state, fixture) {
-    if (fixture === 'all-repairable' || state.before === 'verified')
+    if (fixture === 'all-repairable' || (state.before === 'verified'
+        && state.evidence_level === 'real-interaction'
+        && state.real_interaction_verified === true))
         return verified(state);
+    const blocker = state.evidence_level === 'configuration'
+        ? 'codex_imagegen_real_output_unverified'
+        : 'codex_app_builtin_imagegen_capability_missing';
     return {
         ...state,
         after: 'unknown',
+        availability: 'manual-required',
+        repairability: 'manual-required',
         core_blockers: [],
-        route_blockers: mergeStateRouteBlockers(state, 'route-image', ['imagegen_auth_or_codex_app_builtin_missing']),
+        route_blockers: mergeStateRouteBlockers(state, 'route-image', [blocker]),
         blockers: [],
         warnings: [...new Set([...state.warnings, 'image_generation_not_verified_without_real_capability'])]
     };
@@ -69,12 +76,14 @@ async function postcheckImageFollowupEdit(root, state) {
         return routeBlocked(state, 'route-image', ['image_followup_sample_artifact_unwritable']);
     return verified(state);
 }
-function postcheckComputerUse(state, _fixture) {
-    if (syntheticNativeVerificationAllowed(_fixture) && process.env.SKS_COMPUTER_USE_CAPABILITY === 'verified')
+function postcheckComputerUse(state, fixture) {
+    if (fixture === 'all-repairable')
         return verified(state);
     return {
         ...state,
         after: 'unknown',
+        availability: 'manual-required',
+        repairability: 'manual-required',
         core_blockers: [],
         route_blockers: mergeStateRouteBlockers(state, 'route-computer-use', ['computer_use_os_permission_or_capability_unknown']),
         blockers: [],
@@ -82,20 +91,19 @@ function postcheckComputerUse(state, _fixture) {
     };
 }
 function postcheckChromeWebReview(state, fixture) {
-    if (fixture === 'all-repairable' || (syntheticNativeVerificationAllowed(fixture) && process.env.SKS_CHROME_EXTENSION_READY === '1'))
+    if (fixture === 'all-repairable')
         return verified(state);
     return {
         ...state,
         after: 'unknown',
+        availability: 'manual-required',
+        repairability: 'manual-required',
         core_blockers: [],
         route_blockers: mergeStateRouteBlockers(state, 'route-chrome-web-review', ['codex_chrome_extension_readiness_not_verified']),
         blockers: [],
         warnings: [...new Set([...state.warnings, 'manual_chrome_extension_setup_required'])]
     };
 }
-function syntheticNativeVerificationAllowed(fixture) {
-    return fixture === 'all-repairable' || process.env.SKS_NATIVE_CAPABILITY_FIXTURE === '1' || process.env.NODE_ENV === 'test';
-}
 async function postcheckAppScreenshot(root, state) {
     const dir = path.join(root, '.sneakoscope', 'app-screenshots');
     const registry = path.join(dir, 'screenshot-registry.json');