sneakoscope 6.1.0 → 6.2.0

package/dist/scripts/codex-lb-fast-mode-truth-check.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { run } from '../commands/codex-lb.js';
+import { CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION } from '../core/codex-lb/codex-lb-tool-output-recovery.js';
 const calls = [];
 const home = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-fast-truth-'));
 await fs.mkdir(path.join(home, '.codex'), { recursive: true });
@@ -58,7 +59,16 @@ async function runFastCheck(env) {
     try {
         Object.assign(process.env, env);
         process.exitCode = 0;
-        globalThis.fetch = async (_url, init) => {
+        globalThis.fetch = async (url, init = {}) => {
+            if (new URL(String(url)).pathname === '/health') {
+                return new Response('{}', {
+                    status: 200,
+                    headers: {
+                        'content-type': 'application/json',
+                        'x-app-version': CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION
+                    }
+                });
+            }
             const body = JSON.parse(String(init.body || '{}'));
             calls.push({ body });
             const id = calls.length % 2 === 1 ? 'resp_fast_1' : 'resp_fast_2';

package/dist/scripts/codex-lb-fast-ui-preservation-check.js

@@ -41,8 +41,15 @@ await fs.writeFile(configPath, [
 ].join('\n'));
 await fs.writeFile(envPath, 'export CODEX_LB_BASE_URL="https://lb.example.test/backend-api/codex"\nexport CODEX_LB_API_KEY="sk-test-fast-ui"\n');
 await fs.writeFile(authPath, `${oauthAuth}\n`);
+const toolOutputRecoveryFetch = async () => new Response('{}', {
+    status: 200,
+    headers: {
+        'content-type': 'application/json',
+        'x-app-version': '1.21.0-beta.3'
+    }
+});
 const install = await ensureGlobalCodexFastModeDuringInstall({ home, configPath, forceFastMode: true });
-const firstRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+const firstRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb', toolOutputRecoveryFetch });
 const firstConfig = await fs.readFile(configPath, 'utf8');
 const firstAssert = assertConfig(firstConfig, 'first_use_codex_lb');
 const release = await releaseCodexLbAuthHold({ home, configPath, authPath, backupPath: oauthBackupPath });
@@ -55,7 +62,7 @@ const releaseAssert = {
         ...(hasLegacyFastModeTables(releasedConfig) ? ['legacy_fast_mode_tables_survived_use_oauth'] : [])
     ]
 };
-const secondRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+const secondRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb', toolOutputRecoveryFetch });
 const secondConfig = await fs.readFile(configPath, 'utf8');
 const secondAssert = assertConfig(secondConfig, 'second_use_codex_lb');
 const report = {

package/dist/scripts/codex-lb-gpt56-fast-profile-check.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { codexFastModeDesktopStatus, codexLbConfigPath, configureCodexLb, ensureGlobalCodexFastModeDuringInstall, releaseCodexLbAuthHold, repairCodexLbAuth } from '../cli/install-helpers.js';
 import { repairCodexConfigStructure, splitCodexProjectConfigPolicy } from '../core/codex/codex-project-config-policy.js';
 import { parseCodexConfigToml, validateCodexConfigRoundTrip } from '../core/codex/codex-config-toml.js';
+import { CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION } from '../core/codex-lb/codex-lb-tool-output-recovery.js';
 import { normalizeCodexLbToolCatalog } from '../core/codex-lb/codex-lb-tool-catalog.js';
 const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-gpt56-fast-'));
 const home = path.join(tmp, 'home');
@@ -29,13 +30,14 @@ const setup = await configureCodexLb({
     forceFastMode: true,
     forceCodexLbApiKeyAuth: true,
     authMode: 'codex-lb',
-    shellProfile: 'skip'
+    shellProfile: 'skip',
+    toolOutputRecoveryFetch
 });
 const fastOn = await ensureGlobalCodexFastModeDuringInstall({ home, configPath, forceFastMode: true });
 const first = assertFastProfile(await fs.readFile(configPath, 'utf8'), 'setup_fast_on');
 const release = await releaseCodexLbAuthHold({ home, configPath, authPath, backupPath: oauthBackupPath });
 const afterOauth = assertFastProfile(await fs.readFile(configPath, 'utf8'), 'use_oauth_roundtrip');
-const repair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+const repair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb', toolOutputRecoveryFetch });
 await fs.writeFile(projectConfig, [
     '# SKS managed fixture',
     'default_profile = "sks-fast-high"',
@@ -154,4 +156,13 @@ function codex0144Model(slug) {
         minimal_client_version: '0.144.1'
     };
 }
+async function toolOutputRecoveryFetch() {
+    return new Response('{}', {
+        status: 200,
+        headers: {
+            'content-type': 'application/json',
+            'x-app-version': CODEX_LB_TOOL_OUTPUT_RECOVERY_MIN_VERSION
+        }
+    });
+}
 //# sourceMappingURL=codex-lb-gpt56-fast-profile-check.js.map

package/dist/scripts/codex-native-agent-role-content-check.js

@@ -2,18 +2,38 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { parse } from 'smol-toml';
 import { syncCodexAgentRoles } from '../core/codex-app/codex-agent-role-sync.js';
+import { MANAGED_OFFICIAL_SUBAGENT_ROLES } from '../core/managed-assets/managed-assets-manifest.js';
 const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'sks-agent-role-content-'));
 const codexHome = path.join(root, 'codex-home');
 const report = await syncCodexAgentRoles({ root, codexHome, apply: true, agentTypeSupported: true });
-const checker = await fs.promises.readFile(path.join(codexHome, 'agents', 'sks-checker.toml'), 'utf8');
-const implementer = await fs.promises.readFile(path.join(codexHome, 'agents', 'sks-implementer.toml'), 'utf8');
-for (const token of ['Bounded ownership', 'Maker/checker separation', 'Allowed sandbox', 'Side-effect restrictions', 'Required proof artifacts', 'Final arbiter constraints']) {
-    assertGate(checker.includes(token) && implementer.includes(token), `managed agent role missing:${token}`);
+const expert = await fs.promises.readFile(path.join(root, '.codex', 'agents', 'expert.toml'), 'utf8');
+const worker = await fs.promises.readFile(path.join(root, '.codex', 'agents', 'worker.toml'), 'utf8');
+const implementation = await fs.promises.readFile(path.join(root, '.codex', 'agents', 'implementation-specialist.toml'), 'utf8');
+const browser = await fs.promises.readFile(path.join(root, '.codex', 'agents', 'browser-use-operator.toml'), 'utf8');
+assertGate(expert.includes('model = "gpt-5.6-sol"') && expert.includes('model_reasoning_effort = "max"'), 'expert role must use Sol Max');
+assertGate(worker.includes('model = "gpt-5.6-luna"') && worker.includes('model_reasoning_effort = "max"'), 'worker role must use Luna Max');
+assertGate(implementation.includes('model = "gpt-5.6-sol"') && implementation.includes('model_reasoning_effort = "high"'), 'implementation role must use Sol High');
+assertGate(browser.includes('model = "gpt-5.6-terra"') && browser.includes('model_reasoning_effort = "medium"'), 'browser role must use Terra Medium');
+assertGate(expert.includes('Do not spawn another subagent.') && worker.includes('Do not redesign the task, expand scope, or spawn another subagent.'), 'official roles must prohibit nested delegation');
+for (const role of MANAGED_OFFICIAL_SUBAGENT_ROLES) {
+    const text = await fs.promises.readFile(path.join(root, '.codex', 'agents', role.filename), 'utf8');
+    const doc = parse(text);
+    assertGate(doc.name === role.codex_name && doc.model === role.model && doc.model_reasoning_effort === role.model_reasoning_effort, `official role policy mismatch:${role.codex_name}`);
+    assertGate(Object.hasOwn(doc, 'sandbox_mode') === (role.sandbox === 'read-only'), `official role sandbox inheritance mismatch:${role.codex_name}`);
+    assertGate(doc.sandbox_mode === role.sandbox, `official role sandbox value mismatch:${role.codex_name}`);
 }
-assertGate(checker.includes('sandbox_mode = \"read-only\"') && checker.includes('checker is read-only'), 'checker role must be read-only');
-assertGate(implementer.includes('cannot self-approve'), 'implementer role must not self-approve');
-assertGate(report.strategy === 'agent_type' && report.probe_artifact_path && report.clobbered_user_roles === false, 'agent role report strategy/probe/no-clobber fields missing');
+const distribution = Object.fromEntries(['luna_max_mechanical', 'sol_high_implementation', 'sol_max_judgment', 'terra_medium_context_tools']
+    .map((policy) => [policy, MANAGED_OFFICIAL_SUBAGENT_ROLES.filter((role) => role.model_policy === policy).length]));
+assertGate(JSON.stringify(distribution) === JSON.stringify({
+    luna_max_mechanical: 1,
+    sol_high_implementation: 3,
+    sol_max_judgment: 15,
+    terra_medium_context_tools: 6
+}), 'official role policy distribution mismatch');
+assertGate(!fs.existsSync(path.join(codexHome, 'agents')), 'agent role sync must not create global directive roles');
+assertGate(report.strategy === 'agent_type' && report.probe_artifact_path && report.clobbered_user_roles === false && report.official_roles.length === MANAGED_OFFICIAL_SUBAGENT_ROLES.length, 'agent role report strategy/probe/catalog/no-clobber fields missing');
 emitGate('codex-native:agent-role-content');
 function assertGate(condition, message) {
     if (condition)

package/dist/scripts/codex-native-repair-transaction-check.js

@@ -11,11 +11,13 @@ process.env.CODEX_HOME = path.join(root, 'codex-home');
 try {
     const denied = await repairCodexNativeManagedAssets({ root, requestedBy: 'manual' });
     assertGate(denied.ok === false && denied.blockers.includes('repair_transaction_requires_yes'), 'repair transaction must require --yes before mutation', denied);
-    assertGate(!(await exists(path.join(root, 'codex-home', 'skills'))) && !(await exists(path.join(root, 'codex-home', 'agents'))), 'no-yes repair created managed assets', denied);
+    assertGate(!(await exists(path.join(root, 'codex-home', 'skills'))) && !(await exists(path.join(root, 'codex-home', 'agents'))) && !(await exists(path.join(root, '.codex', 'agents'))), 'no-yes repair created managed assets', denied);
     const report = await repairCodexNativeManagedAssets({ root, requestedBy: 'manual', yes: true });
     assertGate(report.schema === 'sks.codex-native-repair-transaction.v1' && report.repaired.length === 4, 'repair transaction report incomplete', report);
     assertGate(report.confirmed === true && typeof report.mutation_ledger_path === 'string', 'repair transaction missing confirmation/ledger proof', report);
     assertGate(report.repaired.every((row) => row.artifact_path && Array.isArray(row.blockers)), 'repair rows missing artifact/blocker contract', report);
+    assertGate(await exists(path.join(root, '.codex', 'agents', 'worker.toml')) && await exists(path.join(root, '.codex', 'agents', 'expert.toml')), 'repair transaction did not create official project agent roles', report);
+    assertGate(!(await exists(path.join(root, 'codex-home', 'agents'))), 'repair transaction created legacy global agent roles', report);
 }
 finally {
     if (previous === undefined)

package/dist/scripts/codex-sdk-all-pipelines-check.js

@@ -16,12 +16,15 @@ const sources = {
     coreSkill: readText('src/core/skills/core-skill-types.ts')
 };
 const teamCreateRedirectsToNaruto = sources.team.includes('redirectTeamCreateToNaruto') && sources.team.includes('narutoCommand');
-assertGate(teamCreateRedirectsToNaruto, 'Team create must route through Naruto codex-sdk SSOT');
+assertGate(teamCreateRedirectsToNaruto, 'Team create must route through the Naruto official-subagent SSOT');
 assertGate(sources.qa.includes("mock ? 'fake' : 'codex-sdk'"), 'QA must route native agents through codex-sdk');
-assertGate(sources.research.includes("mock ? 'fake' : 'codex-sdk'"), 'Research must route native agents through codex-sdk');
-assertGate(sources.naruto.includes("backend: 'codex-sdk'"), 'Naruto defaults must name codex-sdk');
+assertGate(sources.research.includes("backend: mock ? 'mock' : 'codex-sdk'")
+    && sources.research.includes("reviewer_workflow: 'official_codex_subagent'"), 'Research must use the Codex SDK stage backend plus the official subagent reviewer workflow');
+assertGate(sources.naruto.includes('runOfficialSubagentWorkflow'), 'Naruto must invoke the official Codex subagent runner');
+assertGate(sources.naruto.includes("workflow: 'official_codex_subagent'"), 'Naruto must persist the official subagent workflow contract');
+assertGate(!sources.naruto.includes("backend: 'codex-sdk'"), 'Naruto must not select the legacy codex-sdk backend');
 assertGate(sources.coreSkill.includes("'codex-sdk'"), 'Core skill backend type must include codex-sdk');
 const fixture = await runFakeCodexSdkTaskFixture('all-pipelines');
 assertGate(fixture.result.ok === true, 'all pipeline SDK fixture must pass', fixture.result);
-emitGate('codex-sdk:all-pipelines', { gates: required.length, sdk_thread_id: fixture.result.sdkThreadId });
+emitGate('codex-sdk:all-pipelines', { gates: required.length, naruto_workflow: 'official_codex_subagent', sdk_thread_id: fixture.result.sdkThreadId });
 //# sourceMappingURL=codex-sdk-all-pipelines-check.js.map

package/dist/scripts/codex-sdk-backend-router-check.js

@@ -9,6 +9,7 @@ const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-sdk-router-'));
 const old = snapshotEnv();
 process.env.NODE_ENV = 'test';
 process.env.SKS_CODEX_SDK_FAKE = '1';
+process.env.SKS_CODEX_LB_AUTOBYPASS = '1';
 process.env.SKS_DISABLE_ROUTE_RECURSION = '1';
 process.env.SKS_AGENT_WORKER = '1';
 process.env.SKS_FAST_MODE = '1';
@@ -48,6 +49,7 @@ function snapshotEnv() {
     return {
         NODE_ENV: process.env.NODE_ENV,
         SKS_CODEX_SDK_FAKE: process.env.SKS_CODEX_SDK_FAKE,
+        SKS_CODEX_LB_AUTOBYPASS: process.env.SKS_CODEX_LB_AUTOBYPASS,
         SKS_DISABLE_ROUTE_RECURSION: process.env.SKS_DISABLE_ROUTE_RECURSION,
         SKS_AGENT_WORKER: process.env.SKS_AGENT_WORKER,
         SKS_FAST_MODE: process.env.SKS_FAST_MODE,

package/dist/scripts/codex-sdk-research-pipeline-check.js

@@ -5,21 +5,29 @@ import os from 'node:os';
 import path from 'node:path';
 import { assertGate, emitGate, importDist, readText } from './lib/codex-sdk-gate-lib.js';
 const researchCommand = readText('src/core/commands/research-command.ts');
-assertGate(researchCommand.includes("backend: mock ? 'fake' : 'codex-sdk'"), 'Research pipeline must default native agents to codex-sdk');
-assertGate(researchCommand.includes("flag(args, '--autoresearch') ? '$AutoResearch' : '$Research'"), 'Research/AutoResearch route selection missing');
-assertGate(researchCommand.includes('narutoWorkGraph: researchWorkGraph'), 'Research pipeline must pass the stage-aware Naruto work graph');
-assertGate(researchCommand.includes('readonly: true'), 'Research pipeline must force read-only native orchestration');
+assertGate(researchCommand.includes("backend: mock ? 'mock' : 'codex-sdk'"), 'Research stage cycle must use the Codex SDK only as a bounded source/synthesis adapter');
+assertGate(researchCommand.includes("source_acquisition: 'super-search'"), 'Research must route source acquisition through Super Search');
+assertGate(researchCommand.includes("reviewer_workflow: 'official_codex_subagent'"), 'Research must use the official Codex subagent reviewer workflow');
 assertGate(researchCommand.includes('quality_metrics'), 'Research pipeline JSON output must include quality metrics');
 assertGate(researchCommand.includes('const cycleResult = await runResearchCycle({'), 'Research default path must use runResearchCycle');
-assertGate(researchCommand.includes('--legacy-research-cycle'), 'Legacy final.md loop must be opt-in only');
+for (const removed of ['runNativeAgentOrchestrator', 'SKS_RESEARCH_LEGACY_CYCLE', 'runCodexExec({']) {
+    assertGate(!researchCommand.includes(removed), `Research legacy runtime token must be removed: ${removed}`);
+}
+assertGate(researchCommand.includes('REMOVED_RESEARCH_RUNTIME_FLAGS')
+    && researchCommand.includes('Unsupported legacy Research runtime option:'), 'Research must fail closed on removed runtime options');
+for (const removedFlag of ['--legacy-research-cycle', '--native-proof-only']) {
+    assertGate(researchCommand.includes(removedFlag), `Research removed-option blocker must include ${removedFlag}`);
+}
 const researchCore = readText('src/core/research.ts');
 assertGate(researchCore.includes('readResearchQualityContract'), 'Research gate must read research-quality-contract.json');
 assertGate(researchCore.includes('claim_evidence_matrix_missing'), 'Research gate must require claim-evidence-matrix.json');
 assertGate(researchCore.includes('research_final_review_not_approved'), 'Research gate must require final reviewer approval');
 for (const [file, tokens] of Object.entries({
-    'src/core/research/research-work-graph.ts': ['buildResearchWorkGraph', 'source_shard_academic_literature'],
+    'src/core/research/research-work-graph.ts': ['buildResearchWorkGraph', 'REQUIRED_SOURCE_SHARD_IDS', 'source_shard_${layer.id}'],
     'src/core/research/research-cycle-runner.ts': ['runResearchCycle', 'Promise.race'],
-    'src/core/research/research-final-reviewer.ts': ['runResearchCodexFinalReviewer'],
+    'src/core/research/research-final-reviewer.ts': ['runResearchCodexFinalReviewer', 'research_final_reviewer_static_plus_official_subagents'],
+    'src/core/research/research-adversarial-review.ts': ['runResearchAdversarialReviewLoop', 'official_codex_subagent', 'critical_objections_unresolved'],
+    'src/core/research/research-super-search.ts': ['runResearchSuperSearchShard', 'runSuperSearch'],
     'src/core/research/claim-evidence-matrix.ts': ['claim-evidence-matrix'],
     'src/core/research/implementation-blueprint.ts': ['implementation-blueprint'],
     'src/core/research/research-quality-contract.ts': ['research-quality-contract']
@@ -30,6 +38,8 @@ for (const [file, tokens] of Object.entries({
 }
 const research = await importDist('core/research.js');
 const fsx = await importDist('core/fsx.js');
+const adversarial = await importDist('core/research/research-adversarial-review.js');
+const finalReviewer = await importDist('core/research/research-final-reviewer.js');
 const dirShort = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-short-'));
 const planShort = await research.writeResearchPlan(dirShort, 'codex sdk short rejection fixture', { missionId: 'M-CODEX-SHORT' });
 await fsx.writeTextAtomic(path.join(dirShort, 'research-report.md'), `# Short Report\n\n${Array.from({ length: 300 }, (_unused, index) => `word${index}`).join(' ')}\n`);
@@ -40,7 +50,19 @@ assertGate(shortGate.passed === false, 'codex-sdk research pipeline must reject
 assertGate((shortGate.reasons || []).includes('research_report_too_short'), 'short rejection must include report length reason', shortGate);
 const dirComplete = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-complete-'));
 const planComplete = await research.writeResearchPlan(dirComplete, 'codex sdk complete package fixture', { missionId: 'M-CODEX-COMPLETE' });
-const completeGate = await research.writeMockResearchResult(dirComplete, planComplete);
+await research.writeMockResearchResult(dirComplete, planComplete);
+const adversarialResult = await adversarial.runResearchAdversarialReviewLoop({
+    root: process.cwd(),
+    dir: dirComplete,
+    plan: planComplete,
+    timeoutMs: 1_000,
+    maxCycles: 1,
+    maxThreads: 5,
+    mock: true
+});
+assertGate(adversarialResult.ok === true, 'mock complete package must pass official-subagent adversarial contract', adversarialResult);
+await finalReviewer.runResearchFinalReviewer(dirComplete, { plan: planComplete, root: process.cwd(), mock: true });
+const completeGate = await research.evaluateResearchGate(dirComplete);
 assertGate(completeGate.passed === true, 'codex-sdk research pipeline must pass complete package fixture', completeGate);
 assertGate(completeGate.metrics?.final_review_approved === true, 'complete package must include approved final review', completeGate.metrics);
 emitGate('codex-sdk:research-pipeline', { route: '$Research', short_dir: dirShort, complete_dir: dirComplete });

package/dist/scripts/db-route-materialization-check.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { prepareRoute } from '../core/pipeline-internals/runtime-core.js';
+const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-db-route-materialization-'));
+try {
+    await fsp.writeFile(path.join(root, 'package.json'), `${JSON.stringify({ name: 'sks-db-route-fixture', private: true }, null, 2)}\n`);
+    const prepared = await prepareRoute(root, '$DB inspect the local migration safely', {});
+    const missionId = String(prepared?.mission_id || '');
+    if (!missionId || prepared?.route?.id !== 'DB')
+        throw new Error('DB route did not materialize a mission');
+    const dir = path.join(root, '.sneakoscope', 'missions', missionId);
+    const scan = JSON.parse(await fsp.readFile(path.join(dir, 'db-safety-scan.json'), 'utf8'));
+    const review = JSON.parse(await fsp.readFile(path.join(dir, 'db-review.json'), 'utf8'));
+    if (typeof scan?.ok !== 'boolean')
+        throw new Error('db-safety-scan.json is missing an ok decision');
+    if (typeof review?.scan_ok !== 'boolean' || review?.destructive_operation_zero !== true) {
+        throw new Error('db-review.json is missing the fail-closed safety baseline');
+    }
+    console.log(JSON.stringify({
+        schema: 'sks.db-route-materialization-check.v1',
+        ok: true,
+        route: '$DB',
+        mission_id: missionId,
+        artifacts: ['db-safety-scan.json', 'db-review.json'],
+        legacy_cli_registered: false
+    }, null, 2));
+}
+finally {
+    await fsp.rm(root, { recursive: true, force: true });
+}
+//# sourceMappingURL=db-route-materialization-check.js.map

package/dist/scripts/docs-truthfulness-check.js

@@ -12,6 +12,7 @@ const files = [
     'docs/codex-0.136-compat.md',
     'docs/codex-0.135-compat.md',
     'docs/codex-cli-compat.md',
+    'docs/codex-app.md',
     'docs/official-docs-compat.md',
     'docs/hooks-pat.md',
     'docs/known-gaps.md',
@@ -24,7 +25,8 @@ const required = {
     'docs/codex-lb.md': ['durable_env_file', 'durable_keychain', 'shell_profile', 'process_only_ephemeral', 'base URL only'],
     'docs/codex-0.136-compat.md': ['rust-v0.136.0', 'codex:0.136-compat', 'codex archive', 'codex app-server --stdio', 'CODEX_API_KEY', 'server tokens'],
     'docs/codex-0.135-compat.md': ['rust-v0.135.0', 'codex:0.135-compat', 'named permission profiles'],
-    'docs/codex-cli-compat.md': ['rust-v0.136.0', 'session_archive_restore', 'profile_primary_selector', 'managed_network_proxy_env', 'goals_default_enabled', 'permission_profiles_requirements', 'SubagentStart', 'sks_zero_warning_disallowed', 'strict subset'],
+    'docs/codex-cli-compat.md': ['rust-v0.144.1', 'sks codex 0.144', 'Inherited Codex 0.136 Capabilities', 'session_archive_restore', 'profile_primary_selector', 'managed_network_proxy_env', 'goals_default_enabled', 'permission_profiles_requirements', 'SubagentStart', 'sks_zero_warning_disallowed', 'strict subset'],
+    'docs/codex-app.md': ['rust-v0.144.1', 'sks codex 0.144', 'App Server v2', 'Codex Chrome Extension', 'gpt-image-2'],
     'docs/official-docs-compat.md': ['official-docs-compat-report.js', 'rust-v0.144.1', 'gpt-image-2', 'input_fidelity', 'additionalProperties:false'],
     'docs/hooks-pat.md': ['SubagentStop', 'strict subset', 'zero-warning'],
     'docs/known-gaps.md': ['No P0', 'P1'],

package/dist/scripts/doctor-codex-startup-repair-check.js

@@ -53,20 +53,19 @@ await writeTextAtomic(path.join(codexHome, 'agents', 'sks-checker.toml'), [
     ''
 ].join('\n'));
 const planned = await mod.runDoctorCodexStartupRepair({ root: tmp, codexHome, fix: false });
-assertGate(planned.configs.every((entry) => entry.warnings.some((warning) => warning.includes('agent_config_file_stale'))), 'dry inspect must detect stale agent config_file paths', planned);
+assertGate(planned.configs.every((entry) => !entry.warnings.some((warning) => warning.includes('agent_config_file_stale'))), 'structural startup inspection must ignore preserved legacy agent config_file paths', planned);
 const repaired = await mod.runDoctorCodexStartupRepair({ root: tmp, codexHome, fix: true, includeDefaultNodeReplCandidates: false });
 const projectText = await fs.readFile(path.join(tmp, '.codex', 'config.toml'), 'utf8');
 const globalText = await fs.readFile(path.join(codexHome, 'config.toml'), 'utf8');
 const checkerText = await fs.readFile(path.join(codexHome, 'agents', 'sks-checker.toml'), 'utf8');
-const projectScoutText = await fs.readFile(path.join(tmp, '.codex', 'agents', 'analysis-scout.toml'), 'utf8');
-const globalScoutText = await fs.readFile(path.join(codexHome, 'agents', 'analysis-scout.toml'), 'utf8');
-for (const [scope, text, expectedDir] of [
-    ['project', projectText, path.join(tmp, '.codex', 'agents')],
-    ['global', globalText, path.join(codexHome, 'agents')]
+const projectScoutPresent = await fs.stat(path.join(tmp, '.codex', 'agents', 'analysis-scout.toml')).then(() => true).catch(() => false);
+const globalScoutPresent = await fs.stat(path.join(codexHome, 'agents', 'analysis-scout.toml')).then(() => true).catch(() => false);
+for (const [scope, text] of [
+    ['project', projectText],
+    ['global', globalText]
 ]) {
-    assertGate(!text.includes('/Users/alfredo/'), `${scope} config must drop stale home path`, text);
-    assertGate(text.includes(`config_file = "${path.join(expectedDir, 'analysis-scout.toml').replace(/\\/g, '\\\\')}"`), `${scope} config_file must point at an existing absolute role file`, text);
-    assertGate(text.includes('description = "SKS scout with bounded write capability."'), `${scope} managed agent description must be write-capable`, text);
+    assertGate(text.includes('/Users/alfredo/.codex/agents/analysis-scout.toml'), `${scope} legacy config_file must be preserved`, text);
+    assertGate(text.includes('description = "Read-only SKS scout."'), `${scope} legacy agent description must be preserved`, text);
     assertGate(!text.includes('[mcp_servers.node_repl]'), `${scope} stale node_repl MCP block must be removed`, text);
     assertGate(!text.includes('[mcp_servers.node_repl.env]'), `${scope} stale node_repl child MCP block must be removed`, text);
     assertGate((text.match(/\[mcp_servers\.context7\]/g) || []).length === 1, `${scope} duplicate context7 MCP block must be deduped`, text);
@@ -74,14 +73,12 @@ for (const [scope, text, expectedDir] of [
     assertGate(text.includes('[mcp_servers.supabase_sauron]'), `${scope} optional sauron MCP block must be preserved`, text);
     assertGate(text.includes('[features]') && text.includes('hooks = true'), `${scope} unrelated tables must be preserved`, text);
 }
-for (const [scope, text] of [['project', projectScoutText], ['global', globalScoutText]]) {
-    assertGate(text.includes('sandbox_mode = "workspace-write"'), `${scope} agent role file must be workspace-write`, text);
-    assertGate(!text.includes('Do not edit files.'), `${scope} agent role file must not preserve stale read-only instruction`, text);
-}
-assertGate(!checkerText.includes('message_role_prefix'), 'managed directive agent role must remove unsupported message_role_prefix', checkerText);
+assertGate(projectScoutPresent === false && globalScoutPresent === false, 'structural startup repair must not synthesize legacy role TOMLs', { projectScoutPresent, globalScoutPresent });
+assertGate(checkerText.includes('message_role_prefix'), 'legacy directive role TOMLs must be preserved byte-for-byte', checkerText);
 assertGate(repaired.ok === true, 'startup repair must pass when only optional sauron remains', repaired);
 assertGate(repaired.configs.every((entry) => entry.changed === true && entry.backup_path), 'startup repair must back up changed configs', repaired);
-assertGate(repaired.agent_role_files.created.length >= 10, 'startup repair must create missing project/global role configs', repaired);
+assertGate(repaired.agent_role_files.created.length === 0 && repaired.agent_role_files.sanitized.length === 0, 'startup repair must leave project/global agent role files untouched', repaired);
+assertGate(repaired.configs.every((entry) => entry.agent_config_files_repaired.length === 0), 'startup repair must not rewrite legacy agent config_file references', repaired);
 assertGate(repaired.configs.every((entry) => !entry.warnings.some((warning) => warning.includes('agent_config_file_stale'))), 'startup repair must not keep stale agent config warnings after repair', repaired);
 assertGate(repaired.configs.every((entry) => entry.duplicate_toml_blocks_removed.length === 0), 'valid startup repair fixture must not claim duplicate-invalid TOML repair', repaired);
 const tmpInvalid = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-startup-invalid-'));

package/dist/scripts/doctor-fix-production-blackbox.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
+import fs from 'node:fs/promises';
 import path from 'node:path';
+import { parse } from 'smol-toml';
 import { assertGate, emitGate, makeTempRoot, writeText } from './sks-3-1-8-check-lib.js';
 import { repairCodexStartupConfig } from '../core/doctor/codex-startup-config-repair.js';
 import { repairContext7Mcp } from '../core/doctor/context7-mcp-repair.js';
@@ -7,8 +9,16 @@ import { repairSupabaseMcp } from '../core/doctor/supabase-mcp-repair.js';
 import { runDoctorFixTransaction } from '../core/doctor/doctor-transaction.js';
 import { doctorRepairPostcheck } from '../core/doctor/doctor-repair-postcheck.js';
 const root = await makeTempRoot('sks-doctor-production-');
-await writeText(path.join(root, '.codex', 'config.toml'), '[mcp_servers.context7]\ncommand = "npx"\n\n[mcp_servers.supabase]\nurl = "https://supabase.example/mcp"\nread_only = true\n\n[agents.analysis_scout]\nconfig_file = ".codex/agents/stale.toml"\nmessage_role_prefix = "legacy"\n');
-const startup = await repairCodexStartupConfig({ root, apply: true });
+await writeText(path.join(root, '.codex', 'config.toml'), '# SKS-MANAGED-CODEX-CONFIG\n[mcp_servers.context7]\ncommand = "npx"\n\n[mcp_servers.supabase]\nurl = "https://supabase.example/mcp"\nread_only = true\n\n[agents.analysis_scout]\nconfig_file = ".codex/agents/stale.toml"\nmessage_role_prefix = "legacy"\n');
+const startup = await repairCodexStartupConfig({ root, apply: true, home: path.join(root, 'home'), codexHome: path.join(root, 'codex-home') });
+const startupText = await fs.readFile(path.join(root, '.codex', 'config.toml'), 'utf8');
+const startupConfig = parse(startupText);
+const startupAgents = startupConfig.agents || {};
+const startupAgentFiles = (await fs.readdir(path.join(root, '.codex', 'agents'))).sort();
+assertGate(startup.ok === true, 'doctor production startup repair must pass', startup);
+assertGate(startupAgents.max_threads === 12 && startupAgents.max_depth === 1 && startupAgents.job_max_runtime_seconds === 1200 && startupAgents.interrupt_message === true, 'doctor production startup repair must write official config defaults', startupAgents);
+assertGate(startupAgentFiles.join(',') === 'expert.toml,worker.toml', 'doctor production startup repair must create only official worker/expert TOMLs', startupAgentFiles);
+assertGate(startupText.includes('[agents.analysis_scout]') && startupText.includes('config_file = ".codex/agents/stale.toml"'), 'doctor production startup repair must preserve legacy config tables', startupText);
 const context7 = await repairContext7Mcp({ root, apply: true });
 const supabase = await repairSupabaseMcp({ root, apply: true });
 const tx = await runDoctorFixTransaction({ root, phases: [

package/dist/scripts/doctor-startup-config-repair-blackbox.js

@@ -3,11 +3,17 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { assertGate, emitGate, makeTempRoot, writeText } from './sks-3-1-8-check-lib.js';
 import { repairCodexStartupConfig } from '../core/doctor/codex-startup-config-repair.js';
+import { parse } from 'smol-toml';
 const root = await makeTempRoot('sks-startup-config-blackbox-');
 await writeText(path.join(root, '.codex', 'config.toml'), '# SKS managed Codex config fixture\n[agents.analysis_scout]\nconfig_file = ".codex/agents/stale.toml"\nmessage_role_prefix = "legacy"\n');
-const report = await repairCodexStartupConfig({ root, apply: true });
+const report = await repairCodexStartupConfig({ root, apply: true, home: path.join(root, 'home'), codexHome: path.join(root, 'codex-home') });
 const text = await fs.readFile(path.join(root, '.codex', 'config.toml'), 'utf8');
+const parsed = parse(text);
+const agents = parsed.agents || {};
+const files = (await fs.readdir(path.join(root, '.codex', 'agents'))).sort();
 assertGate(report.ok === true, 'startup config blackbox must pass postcheck', report);
-assertGate(!text.includes('message_role_prefix') && /config_file = "\//.test(text), 'startup config blackbox must rewrite to absolute config paths and remove unsupported fields', { text });
+assertGate(agents.max_threads === 12 && agents.max_depth === 1 && agents.job_max_runtime_seconds === 1200 && agents.interrupt_message === true, 'startup config blackbox must persist official settings', agents);
+assertGate(files.join(',') === 'expert.toml,worker.toml', 'startup config blackbox must create only official worker/expert TOMLs', files);
+assertGate(text.includes('config_file = ".codex/agents/stale.toml"') && text.includes('message_role_prefix = "legacy"'), 'startup config blackbox must preserve legacy compatibility tables', { text });
 emitGate('doctor:startup-config-repair-blackbox');
 //# sourceMappingURL=doctor-startup-config-repair-blackbox.js.map

package/dist/scripts/doctor-startup-config-repair-check.js

@@ -1,10 +1,20 @@
 #!/usr/bin/env node
 import { assertGate, emitGate, makeTempRoot, writeText } from './sks-3-1-8-check-lib.js';
 import { repairCodexStartupConfig } from '../core/doctor/codex-startup-config-repair.js';
+import fs from 'node:fs/promises';
 import path from 'node:path';
+import { parse } from 'smol-toml';
 const root = await makeTempRoot('sks-startup-config-');
 await writeText(path.join(root, '.codex', 'config.toml'), '# SKS managed Codex config fixture\n[agents.analysis_scout]\nconfig_file = ".codex/agents/missing.toml"\nmessage_role_prefix = "legacy"\n');
-const report = await repairCodexStartupConfig({ root, apply: true });
-assertGate(report.ok === true, 'startup config repair must repair stale config_file paths and unsupported fields', report);
+const codexHome = path.join(root, 'codex-home');
+const report = await repairCodexStartupConfig({ root, apply: true, home: path.join(root, 'home'), codexHome });
+const text = await fs.readFile(path.join(root, '.codex', 'config.toml'), 'utf8');
+const parsed = parse(text);
+const agents = parsed.agents || {};
+const files = (await fs.readdir(path.join(root, '.codex', 'agents'))).sort();
+assertGate(report.ok === true, 'startup config repair must install the official project config and agent files', report);
+assertGate(agents.max_threads === 12 && agents.max_depth === 1 && agents.job_max_runtime_seconds === 1200 && agents.interrupt_message === true, 'startup config repair must write official [agents] defaults', agents);
+assertGate(files.length === 2 && files[0] === 'expert.toml' && files[1] === 'worker.toml', 'startup config repair must create only worker/expert TOMLs', files);
+assertGate(text.includes('[agents.analysis_scout]') && text.includes('config_file = ".codex/agents/missing.toml"') && text.includes('message_role_prefix = "legacy"'), 'legacy agent config must be preserved without synthesizing its TOML', text);
 emitGate('doctor:startup-config-repair');
 //# sourceMappingURL=doctor-startup-config-repair-check.js.map

package/dist/scripts/install-update-preserves-config-check.js

@@ -29,6 +29,9 @@ const results = [];
         '',
         '[mcp_servers.custom]',
         'command = "npx"',
+        '',
+        '[agents]',
+        'max_threads = 20',
         ''
     ].join('\n');
     await fs.writeFile(cfg, userConfig);
@@ -41,6 +44,7 @@ const results = [];
         /^model_reasoning_effort = "high"/m.test(after) && // user effort NOT stripped
         /# my hand-tuned Codex config/.test(after) && // user comment preserved
         /\[mcp_servers\.custom\]/.test(after) && // user table preserved
+        /\[agents\][\s\S]*max_threads = 20/.test(after) && // user concurrency preserved
         !/\[profiles\.sks-fast-high\]/.test(after) && // legacy profile table stripped
         !/\[user\.fast_mode\]/.test(after) && // legacy fast UI table stripped
         backups.length >= 1 && // backup created
@@ -59,7 +63,8 @@ const results = [];
         && !/^model\s*=/m.test(topLevel)
         && !/^model_reasoning_effort\s*=/m.test(topLevel)
         && !/^service_tier = "fast"/m.test(topLevel)
-        && /\[features\]/.test(after);
+        && /\[features\]/.test(after)
+        && !/^max_threads\s*=/m.test(after);
     results.push({ case: 'fresh_config_seeds_defaults', ok, status: res.status });
 }
 // --- Case 3: unparseable config is preserved + backed up, NOT overwritten ---

package/dist/scripts/lib/codex-sdk-gate-lib.js

@@ -17,6 +17,9 @@ export async function runFakeCodexSdkTaskFixture(label = 'fixture', extra = {})
     const old = snapshotEnv();
     process.env.NODE_ENV = 'test';
     process.env.SKS_CODEX_SDK_FAKE = '1';
+    // Hermetic fixture runs must not inherit an operator's live codex-lb
+    // selection. The fake adapter exercises control-plane contracts only.
+    process.env.SKS_CODEX_LB_AUTOBYPASS = '1';
     try {
         const result = await mod.runCodexTask({
             route: extra.route || '$Agent',
@@ -78,6 +81,7 @@ function snapshotEnv() {
     return {
         NODE_ENV: process.env.NODE_ENV,
         SKS_CODEX_SDK_FAKE: process.env.SKS_CODEX_SDK_FAKE,
+        SKS_CODEX_LB_AUTOBYPASS: process.env.SKS_CODEX_LB_AUTOBYPASS,
         SKS_CODEX_SDK_FIXTURE: process.env.SKS_CODEX_SDK_FIXTURE
     };
 }

package/dist/scripts/mad-sks-app-ui-no-mutation-check.js

@@ -144,7 +144,6 @@ async function cleanupOwnedSession(sessionName, socketDir, cwd) {
     const blockers = [
         ...(!sessionRemoved ? ['mad_ui_check_zellij_session_still_present'] : []),
         ...(!socketExclusive ? ['mad_ui_check_zellij_socket_not_exclusive'] : []),
-        ...(!ownedProcessTree.server_found ? ['mad_ui_check_zellij_server_not_observed'] : []),
         ...(!processExit.ok ? ['mad_ui_check_owned_processes_still_alive'] : []),
         ...(!socketDirRemoved ? ['mad_ui_check_zellij_socket_dir_not_removed'] : [])
     ];

package/dist/scripts/managed-role-manifest-parity-check.js

@@ -3,9 +3,10 @@
 import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
 const manifest = await importDist('core/managed-assets/managed-assets-manifest.js');
 const agentConfig = await importDist('core/agents/agent-role-config.js');
-const roles = manifest.MANAGED_AGENT_ROLES.map((role) => role.id);
-const files = manifest.MANAGED_AGENT_ROLES.map((role) => role.filename);
-const generated = manifest.MANAGED_AGENT_ROLES.every((role) => agentConfig.managedAgentRoleConfigForRole(role.id)?.file === role.filename);
+const allRoles = [...manifest.MANAGED_OFFICIAL_SUBAGENT_ROLES, ...manifest.MANAGED_AGENT_ROLES];
+const roles = allRoles.map((role) => role.id);
+const files = allRoles.map((role) => role.filename);
+const generated = allRoles.every((role) => agentConfig.managedAgentRoleConfigForRole(role.id)?.file === role.filename);
 const uniqueIds = new Set(roles).size === roles.length;
 const uniqueFiles = new Set(files).size === files.length;
 manifest.assertUniqueManagedAgentRoleFilenames();
@@ -18,6 +19,6 @@ const report = {
     unique_files: uniqueFiles,
     generated
 };
-assertGate(uniqueIds && uniqueFiles && generated && roles.includes('sks-checker') && roles.includes('sks-codex-probe-verifier'), 'managed agent role manifest must be the shared generation/inventory source with unique physical files', report);
+assertGate(uniqueIds && uniqueFiles && generated && roles.includes('sks-official-worker') && roles.includes('sks-official-expert') && roles.includes('sks-checker') && roles.includes('sks-codex-probe-verifier'), 'managed agent role manifest must be the shared generation/inventory source with unique physical files', report);
 emitGate('managed-assets:role-manifest-parity', report);
 //# sourceMappingURL=managed-role-manifest-parity-check.js.map

package/dist/scripts/naruto-codex-e2e-check.js

@@ -30,12 +30,10 @@ const args = [
     realMode ? 'real Codex E2E readonly smoke' : 'hermetic Naruto E2E readonly smoke',
     '--json',
     '--readonly',
-    '--no-open-zellij',
-    '--clones',
+    '--agents',
     realMode ? '2' : '3',
-    '--work-items',
-    realMode ? '2' : '3',
-    ...(realMode ? ['--real'] : ['--mock'])
+    '--max-threads',
+    realMode ? '2' : '3'
 ];
 const run = await runProcess(process.execPath, args, {
     cwd: tempRoot,
@@ -46,11 +44,19 @@ const run = await runProcess(process.execPath, args, {
         SKS_CODEX_ALLOW_NON_GIT: realMode ? '1' : process.env.SKS_CODEX_ALLOW_NON_GIT || '',
         SKS_DISABLE_NETWORK: realMode ? process.env.SKS_DISABLE_NETWORK || '' : '1',
         SKS_DISABLE_UPDATE_CHECK: '1',
-        SKS_NARUTO_PRE_RUN_SMOKE: '1'
+        SKS_NARUTO_STANDALONE_CLI: realMode ? '1' : '0',
+        SKS_NARUTO_APP_SESSION: realMode ? '0' : '1',
+        CODEX_THREAD_ID: realMode ? process.env.CODEX_THREAD_ID || '' : `naruto-e2e-${path.basename(tempRoot)}`
     }
 });
 const parsed = parseJsonObjectFromStdout(run.stdout);
-const ok = run.code === 0 && parsed?.ok === true && parsed?.mode === 'NARUTO';
+const ok = realMode
+    ? run.code === 0 && parsed?.ok === true && parsed?.route === '$Naruto' && parsed?.status === 'completed'
+    : run.code === 0
+        && parsed?.ok === false
+        && parsed?.route === '$Naruto'
+        && parsed?.status === 'delegation_context_ready'
+        && parsed?.app_session === true;
 assertGate(ok || (realMode && !requireReal), `${mode} Naruto E2E failed`, {
     code: run.code,
     parsed,
@@ -63,6 +69,7 @@ emitGate(realMode ? 'naruto:e2e-real-codex' : 'naruto:e2e-hermetic', {
     temp_root: tempRoot,
     mission_id: parsed?.mission_id || null,
     readonly: true,
+    preparation_only: !realMode,
     real_required: requireReal
 });
 function readOption(args, name, fallback = null) {