sneakoscope 3.1.3 → 3.1.4

package/README.md

@@ -35,7 +35,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.1.3** hardens Loop Mesh for production use: fixture workers/gates/final arbiters are test-only, `gpt:final-arbiter` is explicitly finalizer-owned, integration merge uses a strategy ladder, side-effect reports come from loop diffs and mutation ledgers, loop kill interrupts active worker sessions, and global loop concurrency budgets prevent worker/model-call oversubscription. It remains Codex 0.139-aware while bundling @openai/codex-sdk 0.138.0 at this release boundary; see [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md), [docs/codex-0.139-real-probes.md](docs/codex-0.139-real-probes.md), [docs/loop-fixture-policy.md](docs/loop-fixture-policy.md), and [docs/loop-merge-strategy.md](docs/loop-merge-strategy.md).
+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.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.3"
+version = "3.1.4"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.1.3"
+version = "3.1.4"
 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.3"),
+        Some("--version") => println!("sks-rs 3.1.4"),
         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.3",
-  "source_digest": "4a78851e9e9d4b9101b268276b0ed8776e2d41fa0615a6aced9f7371216618ce",
-  "source_file_count": 2448,
-  "built_at_source_time": 1781415222161
+  "package_version": "3.1.4",
+  "source_digest": "47f6028f6b91151c205109059bff2ef5c51d2f084ae930063eca118d1888a8fc",
+  "source_file_count": 2488,
+  "built_at_source_time": 1781425289529
 }

package/dist/bin/sks.js

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

package/dist/commands/codex-app.js

@@ -2,10 +2,35 @@ import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 import { codexAccessTokenStatus, codexAppIntegrationStatus, codexChromeExtensionStatus, codexProductDesignPluginStatus, formatCodexAppStatus, formatCodexProductDesignPluginStatus } from '../core/codex-app.js';
 import { codexAppRemoteControlCommand } from '../cli/codex-app-command.js';
+import { sksRoot } from '../core/fsx.js';
+import { buildCodexAppHarnessMatrix } from '../core/codex-app/codex-app-harness-matrix.js';
+import { syncCodexSksSkills } from '../core/codex-app/codex-skill-sync.js';
+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')
         return codexAppRemoteControlCommand(args.slice(1));
+    if (action === 'harness-matrix')
+        return printCodexAppResult(args, await buildCodexAppHarnessMatrix({ root: await sksRoot(), applyRepairs: flag(args, '--fix') || flag(args, '--apply') }));
+    if (action === 'skill-sync')
+        return printCodexAppResult(args, await syncCodexSksSkills({ root: await sksRoot(), apply: flag(args, '--apply') || flag(args, '--fix') }));
+    if (action === 'agent-role-sync')
+        return printCodexAppResult(args, await syncCodexAgentRoles({ root: await sksRoot(), apply: flag(args, '--apply') || flag(args, '--fix') }));
+    if (action === 'init-deep')
+        return printCodexAppResult(args, await runCodexInitDeep({ root: await sksRoot(), apply: !flag(args, '--check-only') && !flag(args, '--dry-run') }));
+    if (action === 'hook-lifecycle')
+        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({
@@ -66,7 +91,26 @@ export async function run(_command, args = []) {
             process.exitCode = 1;
         return;
     }
-    console.error('Usage: sks codex-app check|status|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|interop lazycodex [--mode coexist]|product-design [--check-only]|ensure-product-design|chrome-extension|pat status|remote-control [--json]');
     process.exitCode = 1;
 }
+function printCodexAppResult(args = [], result) {
+    if (flag(args, '--json')) {
+        printJson(result);
+        if (result?.ok === false)
+            process.exitCode = 1;
+        return;
+    }
+    console.log(`${result?.schema || 'sks.codex-app-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-app.js.map

package/dist/commands/doctor.js

@@ -23,6 +23,8 @@ import { writeCodex0138CapabilityArtifacts } from '../core/codex-control/codex-0
 import { runCodex0138Doctor } from '../core/doctor/codex-0138-doctor.js';
 import { writeCodexPluginInventoryArtifacts, pluginAppTemplatePolicy } from '../core/codex-plugins/codex-plugin-json.js';
 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';
 export async function run(_command, args = []) {
     const doctorFix = flag(args, '--fix');
     let setupRepair = null;
@@ -149,6 +151,23 @@ export async function run(_command, args = []) {
             blockers: [err?.message || String(err)]
         }))
         : codexAppUiPlan;
+    const zellijRepair = await runDoctorZellijRepair({ root, args, doctorFix }).catch((err) => ({
+        schema: 'sks.zellij-self-heal.v1',
+        ok: false,
+        requested_by: 'doctor --fix',
+        fix_requested: doctorFix,
+        auto_approved: flag(args, '--yes') || flag(args, '-y'),
+        install_homebrew_allowed: false,
+        before: { status: 'unknown', version: null, bin: null },
+        latest_version: null,
+        strategy: 'failed',
+        command: 'sks doctor --fix --yes',
+        after: { status: 'unknown', version: null, bin: null },
+        mutation_guard_artifact: null,
+        homebrew: { present: false, bin: null, install_attempted: false, install_allowed: false },
+        blockers: [err?.message || String(err)],
+        warnings: []
+    }));
     const zellij = await checkZellijCapability({ root, require: process.env.SKS_REQUIRE_ZELLIJ === '1' });
     const localModel = await readLocalModelConfig().catch(() => null);
     const permissionProfiles = await inventoryCodexPermissionProfiles(root, { writeReport: true });
@@ -178,6 +197,15 @@ export async function run(_command, args = []) {
     const mcpPluginInventory = pluginInventory?.report
         ? await writeMcpPluginInventoryArtifacts(root, { inventory: pluginInventory.report }).catch((err) => ({ error: err?.message || String(err), candidates: null }))
         : null;
+    const codexAppHarnessMatrix = await buildCodexAppHarnessMatrix({ root, applyRepairs: doctorFix }).catch((err) => ({
+        schema: 'sks.codex-app-harness-matrix.v1',
+        ok: false,
+        codex_cli: { available: false, version: null },
+        app_features: {},
+        sks_integrations: {},
+        blockers: [err?.message || String(err)],
+        warnings: []
+    }));
     const pkgBytes = await dirSize(root).catch(() => 0);
     const ready = await writeDoctorReadinessMatrix(root, {
         codex,
@@ -194,10 +222,12 @@ export async function run(_command, args = []) {
         codex_0138_doctor: codex0138Doctor,
         codex_plugin_inventory: pluginInventory?.report || null,
         codex_plugin_app_template_policy: pluginPolicy,
+        codex_app_harness_matrix: codexAppHarnessMatrix,
         require_codex_cli_config_load: flag(args, '--fix') || flag(args, '--require-actual-codex'),
         operator_actions: [
             ...(codexConfig.operator_actions || []),
             ...(configRepair?.operator_actions || []),
+            ...(zellijRepair && !zellijRepair.ok && zellijRepair.command ? [`Run: ${zellijRepair.command}`] : []),
             ...(pluginPolicy?.doctor_warnings || [])
         ]
     });
@@ -217,6 +247,7 @@ export async function run(_command, args = []) {
         codex_doctor: codexDoctor,
         codex_doctor_diff: codexDoctorDiff,
         zellij,
+        zellij_repair: zellijRepair,
         local_model: localModel,
         agent_role_config: agentRoleConfigRepair,
         zellij_readiness: zellijReadiness,
@@ -233,10 +264,11 @@ export async function run(_command, args = []) {
             plugin_app_template_policy: pluginPolicy,
             mcp_plugin_inventory: mcpPluginInventory?.candidates || null
         },
+        codex_app_harness_matrix: codexAppHarnessMatrix,
         ready,
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
-        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair }
+        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair }
     };
     if (flag(args, '--json')) {
         printJson(result);
@@ -260,9 +292,20 @@ export async function run(_command, args = []) {
     console.log(`  pane proof:  ${zellijReadiness.pane_proof}`);
     console.log(`  screen proof:${zellijReadiness.screen_proof}`);
     console.log(`  tmux:        ${zellijReadiness.tmux_removed_runtime ? 'removed_runtime' : 'present'}`);
+    const zellijRepairLine = doctorZellijRepairConsoleLine(zellijRepair);
+    if (zellijRepairLine)
+        console.log(zellijRepairLine);
     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('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'}`);
+    console.log(`  skills: ${codexAppHarnessMatrix.sks_integrations?.dollar_skills_synced ? 'ok' : 'degraded'}`);
+    console.log(`  agent roles: ${codexAppHarnessMatrix.sks_integrations?.agent_roles_synced ? 'ok' : 'degraded'}`);
+    console.log(`  native agent_type: ${codexAppHarnessMatrix.app_features?.agent_type_supported ? 'ok' : 'fallback message-role'}`);
+    console.log(`  init-deep memory: ${codexAppHarnessMatrix.sks_integrations?.init_deep_available ? 'available' : 'missing'}`);
+    console.log(`  loop mesh app profile: ${codexAppHarnessMatrix.sks_integrations?.loop_mesh_app_profile_available ? 'available' : 'missing'}`);
     console.log('Codex App UI:');
     console.log(`  fast selector: ${codexAppUi.fast_selector || 'unknown'}`);
     console.log(`  provider selector: ${codexAppUi.provider_selector || 'unknown'}`);

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

@@ -0,0 +1,67 @@
+// @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';
+const DIRECTIVE_ROLES = [
+    'sks-explorer',
+    'sks-planner',
+    'sks-implementer',
+    'sks-checker',
+    'sks-release-verifier',
+    'sks-zellij-ui-verifier',
+    'sks-codex-probe-verifier'
+];
+export async function syncCodexAgentRoles(input) {
+    const root = path.resolve(input.root);
+    const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    const targetDir = path.join(codexHome, 'agents');
+    const baseRepair = await repairAgentRoleConfigs({
+        root,
+        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)] }));
+    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'))
+                continue;
+            await writeTextAtomic(file, roleToml(role));
+            created.push(file);
+        }
+    }
+    const report = {
+        schema: 'sks.codex-agent-role-sync.v1',
+        generated_at: nowIso(),
+        ok: baseRepair.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',
+        codex_home: codexHome,
+        directive_roles: DIRECTIVE_ROLES,
+        created,
+        base_repair: baseRepair,
+        blockers: baseRepair.blockers || []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-agent-role-sync.json'), report).catch(() => undefined);
+    return report;
+}
+function roleToml(role) {
+    return [
+        `name = "${role}"`,
+        `description = "SKS managed 3.1.4 directive role: ${role}"`,
+        '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.`,
+        '"""',
+        ''
+    ].join('\n');
+}
+//# sourceMappingURL=codex-agent-role-sync.js.map

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

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { buildCodexAppHarnessMatrix } from './codex-app-harness-matrix.js';
+export async function resolveCodexAppExecutionProfile(input = { root: process.cwd() }) {
+    const root = path.resolve(input.root || process.cwd());
+    const matrix = input.matrix || await buildCodexAppHarnessMatrix({ root }).catch(() => null);
+    const mode = !matrix?.codex_cli?.available
+        ? 'degraded-no-app'
+        : matrix.app_features?.app_handoff_ready && matrix.app_features?.agent_type_supported
+            ? 'codex-app-native'
+            : matrix.codex_cli.available
+                ? 'codex-cli-headless'
+                : 'sks-loop-headless';
+    const profile = {
+        schema: 'sks.codex-app-execution-profile.v1',
+        generated_at: nowIso(),
+        ok: mode !== 'degraded-no-app',
+        mode,
+        agent_role_strategy: matrix?.app_features?.agent_type_supported ? 'agent_type' : 'message-role',
+        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,
+        loop_mesh_app_profile_available: true,
+        blockers: mode === 'degraded-no-app' ? ['codex_cli_missing'] : [],
+        warnings: matrix?.warnings || []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-app-execution-profile.json'), profile).catch(() => undefined);
+    return profile;
+}
+//# sourceMappingURL=codex-app-execution-profile.js.map

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

@@ -0,0 +1,75 @@
+// @ts-nocheck
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { codexAppIntegrationStatus } from '../codex-app.js';
+import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
+import { detectCodex0139Capability } from '../codex-control/codex-0139-capability.js';
+import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
+import { readCodexHookActualState } from '../codex-hooks/codex-hook-actual-discovery.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+import { repairAgentRoleConfigs } from '../agents/agent-role-config.js';
+import { buildLazyCodexInteropPolicy } from './lazycodex-interop-policy.js';
+export async function buildCodexAppHarnessMatrix(input = { root: process.cwd() }) {
+    const root = path.resolve(input.root || process.cwd());
+    const codexBin = await findCodexBinary().catch(() => null);
+    const version = codexBin ? await codexVersion(codexBin) : null;
+    const cap0138 = await detectCodex0138Capability({ codexBin }).catch((err) => ({ blockers: [err?.message || String(err)] }));
+    const cap0139 = await detectCodex0139Capability({ codexBin }).catch((err) => ({ blockers: [err?.message || String(err)] }));
+    const app = await codexAppIntegrationStatus({ codex: { bin: codexBin, version, available: Boolean(codexBin) } }).catch((err) => ({ ok: false, blockers: [err?.message || String(err)] }));
+    const plugins = await buildCodexPluginInventory().catch((err) => ({ plugins: [], marketplace_available: false, blockers: [err?.message || String(err)] }));
+    const hooks = await readCodexHookActualState(root).catch((err) => ({ ok: false, entries: [], blockers: [err?.message || String(err)] }));
+    const agents = await repairAgentRoleConfigs({ root, apply: input.applyRepairs === true, reportPath: path.join(root, '.sneakoscope', 'reports', 'codex-agent-role-sync.json') }).catch((err) => ({ ok: false, blockers: [err?.message || String(err)] }));
+    const interop = await buildLazyCodexInteropPolicy({ root, inventory: plugins }).catch(() => null);
+    const hasSkills = app?.required_skills?.ok === true || app?.skills?.ok === true || app?.skill_shadows?.ok !== false;
+    const hookApprovalKnown = false;
+    const matrix = {
+        schema: 'sks.codex-app-harness-matrix.v1',
+        generated_at: nowIso(),
+        ok: Boolean(codexBin) && cap0138.supports_plugin_json !== false && agents.ok !== false,
+        codex_cli: { available: Boolean(codexBin), version },
+        app_features: {
+            plugin_json: cap0138.supports_plugin_json === true,
+            marketplace_add: cap0139.supports_marketplace_source_field === true || plugins.marketplace_available === true,
+            marketplace_upgrade: cap0139.supports_marketplace_source_field === true,
+            startup_review_detectable: hookApprovalKnown,
+            hook_approval_state_detectable: hookApprovalKnown,
+            skill_picker_ready: Boolean(hasSkills),
+            agent_type_supported: process.env.SKS_CODEX_AGENT_TYPE_SUPPORTED === '1',
+            mcp_inventory_ready: Array.isArray(plugins.plugins),
+            app_handoff_ready: cap0138.supports_app_handoff === true,
+            image_path_exposure_ready: cap0138.supports_image_path_exposure === true
+        },
+        sks_integrations: {
+            dollar_skills_synced: Boolean(hasSkills),
+            agent_roles_synced: agents.ok !== false,
+            hooks_synced: hooks.ok !== false && (hooks.entries || []).length > 0,
+            init_deep_available: true,
+            loop_mesh_app_profile_available: true
+        },
+        blockers: [
+            ...(!codexBin ? ['codex_cli_missing'] : []),
+            ...(cap0138.blockers || []),
+            ...(plugins.blockers || []),
+            ...(agents.blockers || [])
+        ],
+        warnings: [
+            ...(cap0139.blockers || []).map((b) => `codex_0139:${b}`),
+            ...(hooks.blockers || []).map((b) => `hooks:${b}`),
+            ...(!hookApprovalKnown ? ['hook_approval_state_unknown'] : []),
+            ...(interop?.lazycodex_detected ? ['lazycodex_detected_coexist_mode'] : [])
+        ]
+    };
+    matrix.ok = matrix.blockers.length === 0;
+    await writeCodexAppHarnessMatrix(root, matrix, input.missionDir);
+    return matrix;
+}
+export async function writeCodexAppHarnessMatrix(root, matrix, missionDir) {
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-app-harness-matrix.json'), matrix);
+    if (missionDir)
+        await writeJsonAtomic(path.join(missionDir, 'codex-app-harness-matrix.json'), matrix).catch(() => undefined);
+}
+async function codexVersion(bin) {
+    const run = await runProcess(bin, ['--version'], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch(() => null);
+    return run?.code === 0 ? `${run.stdout || run.stderr || ''}`.trim() || null : null;
+}
+//# sourceMappingURL=codex-app-harness-matrix.js.map

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

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { readCodexHookActualState } from '../codex-hooks/codex-hook-actual-discovery.js';
+import { installManagedCodexHooks } from '../codex-hooks/codex-hook-managed-install.js';
+export async function buildCodexHookLifecycle(input = {}) {
+    const root = path.resolve(input.root || process.cwd());
+    const install = input.apply === true
+        ? await installManagedCodexHooks(root).catch((err) => ({ ok: false, blockers: [err?.message || String(err)] }))
+        : null;
+    const actual = await readCodexHookActualState(root).catch((err) => ({ ok: false, entries: [], blockers: [err?.message || String(err)] }));
+    const events = {
+        UserPromptSubmit: ['route_classifier', 'goal_to_loop_compiler', 'permission_profile_badge'],
+        PreToolUse: ['requested_scope_guard', 'mad_db_priority_resolver', 'side_effect_zero_gate'],
+        PostToolUse: ['evidence_ledger', 'mutation_ledger', 'side_effect_scanner', 'context7_native_session_updates'],
+        Stop: ['continuation_enforcer', 'final_proof_check', 'loop_resume_hint'],
+        Notification: ['operator_status', 'zellij_anchor', 'codex_app_status']
+    };
+    const installedEvents = new Set((actual.entries || []).map((entry) => entry.event));
+    const report = {
+        schema: 'sks.codex-hook-lifecycle.v1',
+        generated_at: nowIso(),
+        ok: actual.ok !== false,
+        apply: input.apply === true,
+        approval_state: 'unknown',
+        approval_state_detectable: false,
+        lifecycle: Object.fromEntries(Object.entries(events).map(([event, actions]) => [event, {
+                actions,
+                installed: installedEvents.has(event),
+                approval_state: 'unknown'
+            }])),
+        actual_state: actual,
+        install,
+        blockers: actual.blockers || [],
+        warnings: ['hook_approval_state_unknown']
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-hook-lifecycle.json'), report).catch(() => undefined);
+    return report;
+}
+//# sourceMappingURL=codex-hook-lifecycle.js.map

package/dist/core/codex-app/codex-init-deep.js

@@ -0,0 +1,87 @@
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+export async function runCodexInitDeep(input = {}) {
+    const root = path.resolve(input.root || process.cwd());
+    const dirs = await scoreDirectories(root);
+    const selected = dirs.filter((row) => row.score >= 4).slice(0, 12);
+    const contextDir = path.join(root, '.sneakoscope', 'context');
+    const generatedPath = path.join(contextDir, 'AGENTS.generated.md');
+    const markdown = renderGeneratedAgents(selected);
+    if (input.apply === true) {
+        await ensureDir(contextDir);
+        await writeTextAtomic(generatedPath, markdown);
+    }
+    const report = {
+        schema: 'sks.codex-init-deep.v1',
+        generated_at: nowIso(),
+        ok: true,
+        apply: input.apply === true,
+        root,
+        generated_path: path.relative(root, generatedPath),
+        root_agents_preserved: true,
+        directory_guidance: selected,
+        blockers: []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-init-deep.json'), report).catch(() => undefined);
+    return report;
+}
+export async function readInitDeepMemory(root) {
+    const file = path.join(root, '.sneakoscope', 'context', 'AGENTS.generated.md');
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    return text.trim() ? { path: file, text } : null;
+}
+async function scoreDirectories(root) {
+    const counts = new Map();
+    await walk(path.join(root, 'src'), root, counts);
+    await walk(path.join(root, 'docs'), root, counts);
+    const highRisk = [/src\/core\/zellij/, /src\/core\/loops/, /src\/core\/codex-app/, /src\/commands/];
+    return [...counts.entries()].map(([dir, value]) => {
+        const risky = highRisk.some((re) => re.test(dir));
+        const score = Math.min(10, Math.ceil(value.file_count / 6) + value.langs.size + (risky ? 3 : 0));
+        return {
+            dir,
+            file_count: value.file_count,
+            languages: [...value.langs].sort(),
+            score,
+            guidance: risky ? 'High-risk SKS runtime area; hydrate TriWiki/current source before edits.' : 'Use local source conventions and keep changes owner-scoped.'
+        };
+    }).sort((a, b) => b.score - a.score || a.dir.localeCompare(b.dir));
+}
+async function walk(dir, root, counts, depth = 0) {
+    if (depth > 3)
+        return;
+    const rows = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const row of rows) {
+        const full = path.join(dir, row.name);
+        if (row.isDirectory()) {
+            if (!['node_modules', 'dist', '.git'].includes(row.name))
+                await walk(full, root, counts, depth + 1);
+        }
+        else if (row.isFile()) {
+            const relDir = path.relative(root, path.dirname(full)).split(path.sep).join('/');
+            const entry = counts.get(relDir) || { file_count: 0, langs: new Set() };
+            entry.file_count += 1;
+            entry.langs.add(path.extname(row.name).replace(/^\./, '') || 'text');
+            counts.set(relDir, entry);
+        }
+    }
+}
+function renderGeneratedAgents(rows) {
+    return [
+        '# SKS Init-Deep Generated Context',
+        '',
+        'This file is generated under `.sneakoscope/context` so user-authored `AGENTS.md` files are preserved.',
+        '',
+        ...rows.flatMap((row) => [
+            `## ${row.dir}`,
+            '',
+            `- Files: ${row.file_count}`,
+            `- Languages: ${row.languages.join(', ') || 'unknown'}`,
+            `- Guidance: ${row.guidance}`,
+            ''
+        ])
+    ].join('\n');
+}
+//# sourceMappingURL=codex-init-deep.js.map

package/dist/core/codex-app/codex-skill-sync.js

@@ -0,0 +1,92 @@
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+const SKS_SKILLS = [
+    '$Loop',
+    '$Naruto',
+    '$QA-LOOP',
+    '$Research',
+    '$DFix',
+    '$Image-UX-Review',
+    '$Computer-Use',
+    '$Init-Deep'
+];
+const LAZYCODEX_RESERVED = new Set(['ulw-loop', 'ulw-plan', 'start-work']);
+export async function syncCodexSksSkills(input) {
+    const root = path.resolve(input.root);
+    const skillsRoot = input.skillsRoot || path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'skills');
+    const existing = await listSkillNames(skillsRoot);
+    const collisions = existing.filter((name) => LAZYCODEX_RESERVED.has(name));
+    const desired = SKS_SKILLS.map((skill) => skillName(skill));
+    const created = [];
+    const skipped = [];
+    if (input.apply === true) {
+        await ensureDir(skillsRoot);
+        for (const name of desired) {
+            if (LAZYCODEX_RESERVED.has(name)) {
+                skipped.push(name);
+                continue;
+            }
+            const dir = path.join(skillsRoot, name);
+            const file = path.join(dir, 'SKILL.md');
+            const content = skillContent(name);
+            const current = await fs.readFile(file, 'utf8').catch(() => '');
+            if (current && !current.includes('BEGIN SKS MANAGED SKILL')) {
+                skipped.push(name);
+                continue;
+            }
+            await ensureDir(dir);
+            await writeTextAtomic(file, content);
+            created.push(file);
+        }
+    }
+    const report = {
+        schema: 'sks.codex-skill-sync.v1',
+        generated_at: nowIso(),
+        ok: true,
+        apply: input.apply === true,
+        skills_root: skillsRoot,
+        desired_skills: desired,
+        existing_skills: existing,
+        created,
+        skipped,
+        lazycodex_reserved_present: collisions,
+        interop: {
+            mode: 'coexist',
+            clobbered_lazycodex: false,
+            clobbered_user_skills: false
+        },
+        blockers: []
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-skill-sync.json'), report).catch(() => undefined);
+    return report;
+}
+async function listSkillNames(root) {
+    const rows = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    return rows.filter((row) => row.isDirectory()).map((row) => row.name).sort();
+}
+function skillName(value) {
+    return value.replace(/^\$/, '').toLowerCase();
+}
+function skillContent(name) {
+    const body = [
+        '---',
+        `name: ${name}`,
+        `description: SKS managed Codex App route bridge for $${name}.`,
+        '---',
+        '',
+        '<!-- BEGIN SKS MANAGED SKILL -->',
+        `Invoke the matching SKS route for $${name}. Do not overwrite user or LazyCodex/OmO skills.`,
+        `checksum: ${hash(name)}`,
+        '<!-- END SKS MANAGED SKILL -->',
+        ''
+    ].join('\n');
+    return body;
+}
+function hash(value) {
+    return crypto.createHash('sha256').update(`sks-skill:${value}`).digest('hex').slice(0, 12);
+}
+//# sourceMappingURL=codex-skill-sync.js.map