sneakoscope 3.1.4 → 3.1.6

package/README.md

@@ -27,7 +27,7 @@ Sneakoscope Codex (`sks`) is a Codex CLI/App harness that makes repeatable Codex
 
 ![Sneakoscope Codex Trust Layer](docs/assets/sneakoscope-architecture-pipeline.jpg)
 
-## LLM Init Prompt for Hermes / OpenClaw Agent Builders
+## LLM Init Prompt for Codex Native Agent Builders
 
 ```text
 Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-Codex](https://github.com/mandarange/Sneakoscope-Codex)] as the repo reference and [npm i -g sneakoscope] as the recommended global install command, then run the appropriate `sks` setup, doctor, Codex App, and proof checks for this repo. Keep generated SKS state out of source control unless documented, and record every version-facing change in CHANGELOG.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.6** removes external reference branding from user-visible release surfaces and routes Codex-native feature decisions through one broker for Loop, QA, Research, Image, MAD, and Doctor.
 
 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.
 
@@ -292,7 +292,7 @@ sks selftest --mock
 
 ## 🎁 What Sneakoscope Adds
 
-`sks` adds a Zellij-backed Codex CLI runtime, Codex App `$` commands, Team/QA/PPT/Research/DB/GX/Wiki routes, OpenClaw and Hermes skill generation, Context7-gated current docs, TriWiki context packs, DB safety, design SSOT policy, skill dreaming, release checks, and Honest Mode.
+`sks` adds a Zellij-backed Codex CLI runtime, Codex App `$` commands, Codex Native broker routing, Team/QA/PPT/Research/DB/GX/Wiki routes, Context7-gated current docs, TriWiki context packs, DB safety, design SSOT policy, skill dreaming, release checks, and Honest Mode.
 
 ## Report-Only Planning Surfaces
 
@@ -618,43 +618,15 @@ SKS does not install Git pre-commit hooks. Release metadata is changed only by e
 
 TriWiki is intentionally sparse: `sks wiki sweep` records demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim into future prompts. `sks harness fixture` validates the broader Harness Growth Factory contract: deliberate forgetting fixtures, skill card metadata, experiment schema, tool-error taxonomy, permission profiles, MultiAgentV2 defaults, and tmux cockpit view coverage. `sks code-structure scan` flags handwritten files above 1000/2000/3000-line thresholds so new logic can be extracted before command files become harder to maintain.
 
-## 🤖 OpenClaw And Hermes Agent Usage
-
-Sneakoscope can generate an OpenClaw skill package for agents that need to operate SKS-enabled repositories.
+## Codex Native Broker
 
 ```sh
-sks openclaw install
-sks openclaw path
+sks codex-native status --json
+sks codex-native invocation-plan --route '$Loop' --capability agent-role --json
+sks codex-native init-deep --apply --directory-local --json
 ```
 
-By default this writes `~/.openclaw/skills/sneakoscope-codex/` with `manifest.yaml`, `SKILL.md`, a README, and `openclaw-agent-config.example.yaml`. Set `OPENCLAW_HOME` or pass `--dir` for a custom location. Attach the skill with the built-in `shell` tool enabled and set `SKS_OPENCLAW=1` so SKS can auto-approve update/install prompts that would otherwise wait for `Y/n`.
-
-```sh
-SKS_OPENCLAW=1 sks root
-SKS_OPENCLAW=1 sks commands
-SKS_OPENCLAW=1 sks dollar-commands
-SKS_OPENCLAW=1 sks deps check
-SKS_OPENCLAW=1 sks proof-field scan --intent "small CLI change" --changed src/cli/main.ts
-```
-
-If OpenClaw runs in a sandbox, grant shell execution only for trusted workspaces. Database, migration, and destructive work still follows SKS safety routes.
-
-Sneakoscope can also generate a Hermes Agent skill package for the Hermes `/skills` surface.
-
-```sh
-sks hermes install
-sks hermes status --json
-sks hermes path
-```
-
-By default this writes `~/.hermes/skills/sneakoscope-codex/` with `SKILL.md`, a README, `hermes-config.example.yaml`, and `skill-bundle.example.yaml`. Set `HERMES_HOME` or pass `--dir` for a custom location. Hermes agents should invoke `/sneakoscope-codex` with the terminal toolset enabled and run shell commands with `SKS_HERMES=1`; this enables non-interactive dependency/update prompts while leaving SKS DB, migration, and destructive-operation safety routes intact. If you use Hermes `skills.external_dirs`, remember writable external directories can be updated by Hermes, so protect shared skill folders with filesystem permissions when needed.
-
-```sh
-SKS_HERMES=1 sks root --json
-SKS_HERMES=1 sks commands --json
-SKS_HERMES=1 sks dollar-commands --json
-SKS_HERMES=1 sks status --json
-```
+The broker records Codex-native feature availability, invocation defaults, neutral pattern evidence, and managed memory setup without exposing reference implementation branding in user-facing artifacts.
 
 ## 💬 Prompt `$` Commands
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.1.4"
+version = "3.1.6"
 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.6"),
         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.6",
+  "source_digest": "98f9f4c6a64ddd6b1d43f757e16358768f24b27cd9c3285eab0bdacce7cbf5d6",
+  "source_file_count": 2543,
+  "built_at_source_time": 1781450666248
 }

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.6';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/command-registry.js

@@ -97,11 +97,10 @@ export const COMMANDS = {
     postinstall: entry('stable', 'Run postinstall bootstrap', 'dist/core/commands/basic-cli.js', basicArgs('postinstallCommand')),
     codex: entry('beta', 'Check Codex CLI compatibility and vendored hook schemas', 'dist/commands/codex.js', directCommand(() => import('../commands/codex.js'), 'dist/commands/codex.js')),
     'codex-app': entry('beta', 'Check Codex App readiness', 'dist/commands/codex-app.js', directCommand(() => import('../commands/codex-app.js'), 'dist/commands/codex-app.js')),
+    'codex-native': entry('beta', 'Inspect Codex Native broker and routing readiness', 'dist/commands/codex-native.js', directCommand(() => import('../commands/codex-native.js'), 'dist/commands/codex-native.js')),
     'codex-lb': entry('beta', 'Inspect codex-lb status and circuit health', 'dist/commands/codex-lb.js', directCommand(() => import('../commands/codex-lb.js'), 'dist/commands/codex-lb.js')),
     auth: entry('beta', 'Alias for codex-lb auth commands', 'dist/commands/codex-lb.js', directCommand(() => import('../commands/codex-lb.js'), 'dist/commands/codex-lb.js')),
     hooks: entry('beta', 'Explain and inspect Codex hooks', 'dist/commands/hooks.js', directCommand(() => import('../commands/hooks.js'), 'dist/commands/hooks.js')),
-    openclaw: entry('labs', 'Create OpenClaw skill package', 'dist/commands/openclaw.js', directCommand(() => import('../commands/openclaw.js'), 'dist/commands/openclaw.js')),
-    hermes: entry('labs', 'Create Hermes Agent skill package', 'dist/commands/hermes.js', directCommand(() => import('../commands/hermes.js'), 'dist/commands/hermes.js')),
     tmux: entry('beta', 'Show removed-runtime migration notice', 'dist/commands/tmux.js', directCommand(() => import('../commands/tmux.js'), 'dist/commands/tmux.js')),
     'zellij-lane': entry('beta', 'Render a Zellij lane frame for SKS sessions', 'dist/commands/zellij-lane.js', directCommand(() => import('../commands/zellij-lane.js'), 'dist/commands/zellij-lane.js')),
     'zellij-slot-pane': entry('beta', 'Render a compact Zellij worker slot pane', 'dist/commands/zellij-slot-pane.js', directCommand(() => import('../commands/zellij-slot-pane.js'), 'dist/commands/zellij-slot-pane.js')),

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-app.js

@@ -9,7 +9,6 @@ import { syncCodexAgentRoles } from '../core/codex-app/codex-agent-role-sync.js'
 import { runCodexInitDeep } from '../core/codex-app/codex-init-deep.js';
 import { buildCodexHookLifecycle } from '../core/codex-app/codex-hook-lifecycle.js';
 import { resolveCodexAppExecutionProfile } from '../core/codex-app/codex-app-execution-profile.js';
-import { buildLazyCodexInteropPolicy } from '../core/codex-app/lazycodex-interop-policy.js';
 export async function run(_command, args = []) {
     const action = args[0] || 'check';
     if (action === 'remote-control' || action === 'remote')
@@ -26,11 +25,6 @@ export async function run(_command, args = []) {
         return printCodexAppResult(args, await buildCodexHookLifecycle({ root: await sksRoot(), apply: flag(args, '--apply') || flag(args, '--fix') }));
     if (action === 'execution-profile')
         return printCodexAppResult(args, await resolveCodexAppExecutionProfile({ root: await sksRoot() }));
-    if (action === 'interop' && args[1] === 'lazycodex') {
-        const modeArg = readOption(args, '--mode', 'coexist');
-        const mode = modeArg === 'sks-primary' || modeArg === 'handoff-to-omo' ? modeArg : 'coexist';
-        return printCodexAppResult(args, await buildLazyCodexInteropPolicy({ root: await sksRoot(), mode }));
-    }
     if (action === 'product-design' || action === 'design-product' || action === 'ensure-product-design') {
         const checkOnly = flag(args, '--check-only') || flag(args, '--no-install');
         const status = await codexProductDesignPluginStatus({
@@ -91,7 +85,7 @@ export async function run(_command, args = []) {
             process.exitCode = 1;
         return;
     }
-    console.error('Usage: sks codex-app check|status|harness-matrix|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|interop lazycodex [--mode coexist]|product-design [--check-only]|ensure-product-design|chrome-extension|pat status|remote-control [--json]');
+    console.error('Usage: sks codex-app check|status|harness-matrix|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|product-design [--check-only]|ensure-product-design|chrome-extension|pat status|remote-control [--json]');
     process.exitCode = 1;
 }
 function printCodexAppResult(args = [], result) {
@@ -109,8 +103,4 @@ function printCodexAppResult(args = [], result) {
     if (result?.ok === false)
         process.exitCode = 1;
 }
-function readOption(args = [], name, fallback) {
-    const index = args.indexOf(name);
-    return index >= 0 && args[index + 1] ? String(args[index + 1]) : fallback;
-}
 //# sourceMappingURL=codex-app.js.map

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/commands/codex-native.js

@@ -0,0 +1,68 @@
+import { flag } from '../cli/args.js';
+import { printJson } from '../cli/output.js';
+import { sksRoot } from '../core/fsx.js';
+import { syncCodexAgentRoles } from '../core/codex-app/codex-agent-role-sync.js';
+import { resolveCodexAppExecutionProfile } from '../core/codex-app/codex-app-execution-profile.js';
+import { buildCodexAppHarnessMatrix } from '../core/codex-app/codex-app-harness-matrix.js';
+import { buildCodexHookLifecycle } from '../core/codex-app/codex-hook-lifecycle.js';
+import { runCodexInitDeep } from '../core/codex-app/codex-init-deep.js';
+import { syncCodexSksSkills } from '../core/codex-app/codex-skill-sync.js';
+import { buildCodexNativeFeatureMatrix } from '../core/codex-native/codex-native-feature-broker.js';
+import { resolveCodexNativeInvocationPlan } from '../core/codex-native/codex-native-invocation-router.js';
+import { buildCodexNativeInteropPolicy } from '../core/codex-native/codex-native-interop-policy.js';
+import { analyzeCodexNativeReferenceSource } from '../core/codex-native/codex-native-reference-evidence.js';
+import { writeCodexNativePatternAnalysis } from '../core/codex-native/codex-native-pattern-analysis.js';
+export async function run(_command, args = []) {
+    const root = await sksRoot();
+    const action = String(args[0] || 'status');
+    if (action === 'status' || action === 'check' || action === 'feature-broker' || action === 'feature-matrix') {
+        return printCodexNativeResult(args, await buildCodexNativeFeatureMatrix({ root, applyRepairs: flag(args, '--fix') || flag(args, '--apply') }));
+    }
+    if (action === 'harness-matrix' || action === 'harness-compat') {
+        return printCodexNativeResult(args, await buildCodexAppHarnessMatrix({ root, applyRepairs: flag(args, '--fix') || flag(args, '--apply') }));
+    }
+    if (action === 'skill-sync')
+        return printCodexNativeResult(args, await syncCodexSksSkills({ root, apply: flag(args, '--apply') || flag(args, '--fix') }));
+    if (action === 'agent-role-sync')
+        return printCodexNativeResult(args, await syncCodexAgentRoles({ root, apply: flag(args, '--apply') || flag(args, '--fix') }));
+    if (action === 'init-deep')
+        return printCodexNativeResult(args, await runCodexInitDeep({ root, apply: flag(args, '--apply') || flag(args, '--fix'), directoryLocal: flag(args, '--directory-local') }));
+    if (action === 'hook-lifecycle')
+        return printCodexNativeResult(args, await buildCodexHookLifecycle({ root, apply: flag(args, '--apply') || flag(args, '--fix') }));
+    if (action === 'execution-profile')
+        return printCodexNativeResult(args, await resolveCodexAppExecutionProfile({ root }));
+    if (action === 'interop-policy')
+        return printCodexNativeResult(args, await buildCodexNativeInteropPolicy({ root }));
+    if (action === 'reference-evidence')
+        return printCodexNativeResult(args, await analyzeCodexNativeReferenceSource({ root, writeReport: true }));
+    if (action === 'pattern-analysis')
+        return printCodexNativeResult(args, await writeCodexNativePatternAnalysis(root));
+    if (action === 'route' || action === 'invocation-plan') {
+        const route = readOption(args, '--route', '$Loop');
+        const desiredCapability = readOption(args, '--capability', 'agent-role');
+        const missionId = readOption(args, '--mission', null);
+        return printCodexNativeResult(args, await resolveCodexNativeInvocationPlan({ root, missionId, route, desiredCapability }));
+    }
+    console.error('Usage: sks codex-native status|feature-broker|harness-compat|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|interop-policy|reference-evidence|pattern-analysis|invocation-plan [--json]');
+    process.exitCode = 1;
+}
+function printCodexNativeResult(args = [], result) {
+    if (flag(args, '--json')) {
+        printJson(result);
+        if (result?.ok === false)
+            process.exitCode = 1;
+        return;
+    }
+    console.log(`${result?.schema || 'sks.codex-native-result'}: ${result?.ok === false ? 'blocked' : 'ok'}`);
+    for (const blocker of result?.blockers || [])
+        console.log(`- blocker: ${blocker}`);
+    for (const warning of result?.warnings || [])
+        console.log(`- warning: ${warning}`);
+    if (result?.ok === false)
+        process.exitCode = 1;
+}
+function readOption(args = [], name, fallback) {
+    const index = args.indexOf(name);
+    return index >= 0 && args[index + 1] ? String(args[index + 1]) : fallback;
+}
+//# sourceMappingURL=codex-native.js.map

package/dist/commands/doctor.js

@@ -25,6 +25,7 @@ import { writeCodexPluginInventoryArtifacts, pluginAppTemplatePolicy } from '../
 import { writeMcpPluginInventoryArtifacts } from '../core/mcp/mcp-plugin-inventory.js';
 import { runDoctorZellijRepair, doctorZellijRepairConsoleLine } from '../core/doctor/doctor-zellij-repair.js';
 import { buildCodexAppHarnessMatrix } from '../core/codex-app/codex-app-harness-matrix.js';
+import { buildCodexNativeFeatureMatrix } from '../core/codex-native/codex-native-feature-broker.js';
 export async function run(_command, args = []) {
     const doctorFix = flag(args, '--fix');
     let setupRepair = null;
@@ -206,6 +207,22 @@ export async function run(_command, args = []) {
         blockers: [err?.message || String(err)],
         warnings: []
     }));
+    const codexNativeFeatureMatrix = await buildCodexNativeFeatureMatrix({ root, applyRepairs: doctorFix }).catch((err) => ({
+        schema: 'sks.codex-native-feature-matrix.v1',
+        ok: false,
+        codex_cli: { available: Boolean(codex.bin), version: codex.version || null, bin: codex.bin || null },
+        features: {},
+        invocation_defaults: {
+            loop_worker_role_strategy: 'message-role',
+            qa_visual_review_strategy: 'blocked',
+            research_source_strategy: 'local-files',
+            image_followup_strategy: 'blocked',
+            hook_evidence_policy: 'unknown-do-not-count',
+            skill_bridge_strategy: 'cli-only'
+        },
+        blockers: [err?.message || String(err)],
+        warnings: []
+    }));
     const pkgBytes = await dirSize(root).catch(() => 0);
     const ready = await writeDoctorReadinessMatrix(root, {
         codex,
@@ -232,6 +249,7 @@ export async function run(_command, args = []) {
         ]
     });
     const zellijReadiness = buildZellijReadiness(root, zellij, ready);
+    const runtimeReadiness = buildRuntimeReadiness(zellijReadiness, codexNativeFeatureMatrix);
     const result = {
         schema: 'sks.doctor-status.v1',
         ok: ready.ready && (!sksUpdate || sksUpdate.ok !== false),
@@ -265,6 +283,8 @@ export async function run(_command, args = []) {
             mcp_plugin_inventory: mcpPluginInventory?.candidates || null
         },
         codex_app_harness_matrix: codexAppHarnessMatrix,
+        codex_native_feature_matrix: codexNativeFeatureMatrix,
+        runtime_readiness: runtimeReadiness,
         ready,
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
@@ -298,6 +318,14 @@ export async function run(_command, args = []) {
     console.log(`  codex doctor:    ${codexDoctor.available ? (codexDoctor.exit_code === 0 ? 'ok' : 'warning') : 'unavailable'}`);
     console.log(`Rust acc.: ${rust.mode || (rust.available ? 'rust_accelerated' : 'js_fallback')} ${rust.version || rust.status || ''}`);
     console.log(`Codex App: ${ready.codex_app_ready ? 'ok' : 'optional_missing'}`);
+    console.log('SKS Runtime Readiness:');
+    console.log(`  Zellij: ${runtimeReadiness.zellij}`);
+    console.log(`  Codex Native: ${runtimeReadiness.codex_native}`);
+    console.log(`  Loop Mesh: ${runtimeReadiness.loop_mesh}`);
+    console.log(`  QA Visual: ${runtimeReadiness.qa_visual}`);
+    console.log(`  Research Sources: ${runtimeReadiness.research_sources}`);
+    for (const action of runtimeReadiness.repair_actions)
+        console.log(`  Repair: ${action}`);
     console.log('Codex App Harness:');
     console.log(`  plugins: ${codexAppHarnessMatrix.app_features?.plugin_json ? 'ok' : 'degraded'}`);
     console.log(`  hook approval: ${codexAppHarnessMatrix.app_features?.hook_approval_state_detectable ? 'ok' : 'unknown'}`);
@@ -385,6 +413,42 @@ export async function run(_command, args = []) {
     if (!result.ok)
         process.exitCode = 1;
 }
+function buildRuntimeReadiness(zellijReadiness, matrix) {
+    const defaults = matrix?.invocation_defaults || {};
+    const hookPolicy = defaults.hook_evidence_policy || 'unknown-do-not-count';
+    const agentStrategy = defaults.loop_worker_role_strategy || 'message-role';
+    const zellijStatus = zellijReadiness?.status === 'ok'
+        ? 'ok'
+        : zellijReadiness?.cli_ready ? 'headless_available' : 'repair_required';
+    const codexNative = matrix?.ok === true
+        ? 'ok'
+        : matrix?.codex_cli?.available ? 'degraded' : 'blocked';
+    const repairActions = [];
+    if (zellijStatus === 'repair_required')
+        repairActions.push('sks doctor --fix --yes');
+    if (codexNative !== 'ok')
+        repairActions.push('sks doctor --fix --repair-codex-native --yes');
+    if (matrix?.features?.project_memory?.ok !== true)
+        repairActions.push('sks codex-native init-deep --apply --directory-local');
+    if (hookPolicy !== 'approved-only')
+        repairActions.push('hook-derived evidence will not count until Codex hook approval is approved');
+    return {
+        schema: 'sks.runtime-readiness-story.v1',
+        zellij: zellijStatus,
+        codex_native: codexNative,
+        loop_mesh: agentStrategy === 'agent_type' ? 'ok' : 'fallback',
+        qa_visual: defaults.qa_visual_review_strategy || 'blocked',
+        research_sources: defaults.research_source_strategy || 'local-files',
+        hook_evidence_policy: hookPolicy,
+        agent_role_strategy: agentStrategy,
+        notes: [
+            ...(zellijStatus === 'headless_available' ? ['MAD can run with --headless; live panes require repair'] : []),
+            ...(hookPolicy !== 'approved-only' ? ['hook-derived evidence will not count'] : []),
+            ...(agentStrategy !== 'agent_type' ? ['message-role fallback active'] : [])
+        ],
+        repair_actions: repairActions
+    };
+}
 // Assemble the explicit Zellij readiness block for `doctor --json` from the
 // capability probe + readiness matrix. Proof statuses are availability-derived:
 // `verified` is reserved for a real environment run (SKS_REQUIRE_ZELLIJ=1 gates);