sneakoscope 3.1.3 → 3.1.5

package/README.md

@@ -35,7 +35,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.1.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.5** productionizes the Codex App harness with typed probe surfaces, dry-run Zellij self-heal planning, hook approval and `agent_type` evidence, LazyCodex live-source analysis, init-deep directory memory hints, and execution profile routing across Loop, QA, Research, and Naruto artifacts.
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

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

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

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

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "3.1.3",
-  "source_digest": "4a78851e9e9d4b9101b268276b0ed8776e2d41fa0615a6aced9f7371216618ce",
-  "source_file_count": 2448,
-  "built_at_source_time": 1781415222161
+  "package_version": "3.1.5",
+  "source_digest": "89b81e91ec4d82c33320922ae0dc33bd6562ccf37c58171858e7f703d7767e4b",
+  "source_file_count": 2518,
+  "built_at_source_time": 1781439913355
 }

package/dist/bin/sks.js

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

package/dist/cli/install-helpers.js

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

package/dist/commands/codex-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/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/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,119 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { nowIso, writeJsonAtomic, writeTextAtomic, ensureDir } from '../fsx.js';
+import { repairAgentRoleConfigs } from '../agents/agent-role-config.js';
+import { agentRolePayloadFor, probeCodexAgentTypeSupport } from './codex-agent-type-probe.js';
+const DIRECTIVE_ROLES = [
+    'sks-explorer',
+    'sks-planner',
+    '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 env = input.env || process.env;
+    const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    const targetDir = path.join(codexHome, 'agents');
+    const baseRepair = await repairAgentRoleConfigs({
+        root,
+        apply: input.apply === true,
+        codexHome,
+        reportPath: path.join(root, '.sneakoscope', 'reports', 'agent-role-config-repair.json')
+    }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
+    const agentTypeProbe = input.agentTypeSupported === undefined
+        ? await probeCodexAgentTypeSupport(root, { env }).catch((err) => ({
+            schema: 'sks.codex-agent-type-probe.v1',
+            generated_at: nowIso(),
+            ok: false,
+            supported: false,
+            source: 'unknown',
+            spawn_tool_name: 'unknown',
+            schema_path: null,
+            evidence: [],
+            blockers: [messageOf(err)],
+            warnings: ['agent_type_probe_failed_message_role_fallback']
+        }))
+        : {
+            schema: 'sks.codex-agent-type-probe.v1',
+            generated_at: nowIso(),
+            ok: true,
+            supported: input.agentTypeSupported,
+            source: 'fixture',
+            spawn_tool_name: input.agentTypeSupported ? 'spawn_agent' : 'unknown',
+            schema_path: input.agentTypeSupported ? 'input.agentTypeSupported' : null,
+            evidence: [`input.agentTypeSupported=${input.agentTypeSupported}`],
+            blockers: [],
+            warnings: []
+        };
+    const rolePayloads = Object.fromEntries(DIRECTIVE_ROLES.map((role) => [role, agentRolePayloadFor(role, agentTypeProbe)]));
+    const created = [];
+    if (input.apply === true) {
+        await ensureDir(targetDir);
+        for (const role of DIRECTIVE_ROLES) {
+            const file = path.join(targetDir, `${role}.toml`);
+            const current = await fs.readFile(file, 'utf8').catch(() => '');
+            if (current && !current.includes('SKS managed 3.1.4 directive role') && !current.includes('SKS managed 3.1.5 directive role'))
+                continue;
+            await writeTextAtomic(file, roleToml(role, rolePayloads[role]));
+            created.push(file);
+        }
+    }
+    const report = {
+        schema: 'sks.codex-agent-role-sync.v1',
+        generated_at: nowIso(),
+        ok: recordOk(baseRepair) !== false && agentTypeProbe.ok !== false,
+        apply: input.apply === true,
+        agent_type_supported: agentTypeProbe.supported,
+        fallback: agentTypeProbe.supported ? 'agent_type' : 'message-role',
+        codex_home: codexHome,
+        directive_roles: DIRECTIVE_ROLES,
+        role_payloads: rolePayloads,
+        agent_type_probe: agentTypeProbe,
+        created,
+        base_repair: baseRepair,
+        blockers: blockersOf(baseRepair)
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-agent-role-sync.json'), report).catch(() => undefined);
+    return report;
+}
+function roleToml(role, payload) {
+    const strategyLine = payload?.strategy === 'agent_type'
+        ? `agent_type = "${payload.agent_type || role}"`
+        : `message_role_prefix = "${escapeToml(payload?.message_role_prefix || `Role: ${role}.`)}"`;
+    return [
+        `name = "${role}"`,
+        `description = "SKS managed 3.1.5 directive role: ${role}"`,
+        strategyLine,
+        'model_reasoning_effort = "medium"',
+        role.includes('implementer') ? 'sandbox_mode = "workspace-write"' : 'sandbox_mode = "read-only"',
+        'approval_policy = "never"',
+        'developer_instructions = """',
+        `You are ${role}. SKS managed 3.1.5 directive role.`,
+        'Use the assigned scope only, cite concrete repo evidence, keep mutation surfaces bounded, and never clobber user files.',
+        'Report blockers as evidence-backed findings and write route artifacts before claiming completion.',
+        `Execution role strategy: ${payload?.strategy || 'message-role'}. Probe: ${payload?.probe_artifact_path || '.sneakoscope/reports/codex-agent-type-probe.json'}.`,
+        '"""',
+        ''
+    ].join('\n');
+}
+function blockersOf(value) {
+    return Boolean(value) && typeof value === 'object' && Array.isArray(value.blockers)
+        ? (value.blockers).map((item) => String(item)).filter(Boolean)
+        : [];
+}
+function recordOk(value) {
+    return Boolean(value) && typeof value === 'object' && typeof value.ok === 'boolean'
+        ? value.ok
+        : undefined;
+}
+function escapeToml(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=codex-agent-role-sync.js.map