sneakoscope 6.0.3 → 6.1.2

package/dist/scripts/codex-0144-capability-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { CODEX_0144_FEATURE_KEYS, detectCodex0144Capability, writeCodex0144CapabilityArtifacts } from '../core/codex-control/codex-0144-capability.js';
+const requireReal = process.argv.includes('--require-real') || process.env.SKS_REQUIRE_CODEX_0144 === '1';
+if (!requireReal)
+    process.env.SKS_CODEX_0144_FAKE = '1';
+const cap = await detectCodex0144Capability({ requireReal });
+assertGate(cap.ok === true, 'Codex 0.144.1 capability probe must pass', cap);
+assertGate(Object.keys(cap.feature_states).length === CODEX_0144_FEATURE_KEYS.length, 'Codex 0.144.1 feature count mismatch', cap);
+assertGate(Object.values(cap.feature_states).every((state) => String(state.certainty) !== 'assumed_by_version'), 'Codex 0.144.1 capability must not use assumed_by_version evidence', cap);
+if (requireReal) {
+    assertGate(cap.probe_mode === 'real-schema', 'Codex 0.144.1 require-real must use generated schema evidence', cap);
+    assertGate(cap.release_authorizing === true, 'Codex 0.144.1 require-real must be release-authorizing', cap);
+    await writeCodex0144CapabilityArtifacts(process.cwd(), { requireReal: true });
+}
+emitGate('codex:0144:capability', {
+    features: CODEX_0144_FEATURE_KEYS.length,
+    probe_mode: cap.probe_mode,
+    release_authorizing: cap.release_authorizing
+});
+//# sourceMappingURL=codex-0144-capability-check.js.map

package/dist/scripts/{codex-0139-real-probes-check.js → codex-0144-core-real-probes-check.js}

@@ -1,28 +1,42 @@
 #!/usr/bin/env node
 // @ts-nocheck
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+import { emitGate, importDist, root } from './sks-1-18-gate-lib.js';
 const args = process.argv.slice(2);
 const requireReal = args.includes('--require-real');
 const allowNetwork = args.includes('--allow-network');
 const allowDesktop = args.includes('--allow-desktop');
 const json = args.includes('--json');
-const timeoutMs = Number(readArg('--timeout-ms') || process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 120000);
+const timeoutMs = Number(readArg('--timeout-ms')
+    || process.env.SKS_CODEX_0144_CORE_REAL_PROBE_TIMEOUT_MS
+    || process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS
+    || 120000);
 const missionId = readArg('--mission-id') || process.env.SKS_MISSION_ID || process.env.SNEAKOSCOPE_MISSION_ID || null;
 const probes = readRepeated('--probe');
 const mod = await importDist('core/codex-control/codex-0139-probe-runner.js');
 const writer = await importDist('core/codex-control/codex-0139-real-probes.js');
 const result = await mod.runCodex0139RealProbes({ root, missionId, requireReal, allowNetwork, allowDesktop, timeoutMs, probes });
 const artifacts = await writer.writeCodex0139RealProbeResult(root, result, { missionId, writeDist: true });
-assertGate(result.overall_ok === true || !requireReal, requireReal ? 'codex:0139-real-probes:require-real failed' : 'codex:0139-real-probes optional probe runner failed', result);
-emitGate(requireReal ? 'codex:0139-real-probes:require-real' : 'codex:0139-real-probes', {
+const ok = requireReal ? result.release_authorizing === true : result.overall_ok === true;
+emitGate(requireReal ? 'codex:0144-core-real-probes:require-real' : 'codex:0144-core-real-probes', {
+    ok,
     overall_ok: result.overall_ok,
+    release_authorizing: result.release_authorizing,
+    target_version: result.target_version,
+    compatibility_origin: result.compatibility_origin,
+    compatibility_authority: result.compatibility_authority,
     parsed_version: result.parsed_version,
+    requested_probes: result.requested_probes,
     skipped: result.skipped,
     blockers: result.blockers,
+    warnings: result.warnings,
+    external_integration_status: result.external_integration_status,
+    temp_cleanup: result.temp_cleanup,
     artifact: '.sneakoscope/codex-0139-real-probes.json',
     mission_artifact: artifacts.mission_artifact ? `.sneakoscope/missions/${missionId}/codex-0139-real-probes.json` : null,
     ...(json ? { result } : {})
 });
+if (!ok)
+    process.exitCode = 1;
 function readArg(name) {
     const idx = args.indexOf(name);
     return idx >= 0 ? args[idx + 1] : null;
@@ -34,4 +48,4 @@ function readRepeated(name) {
             out.push(args[i + 1]);
     return out;
 }
-//# sourceMappingURL=codex-0139-real-probes-check.js.map
+//# sourceMappingURL=codex-0144-core-real-probes-check.js.map

package/dist/scripts/{codex-0142-doctor-wiring-check.js → codex-0144-doctor-wiring-check.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-process.env.SKS_CODEX_0142_FAKE = '1';
+process.env.SKS_CODEX_0144_FAKE = '1';
 process.env.SKS_CODEX_0138_FAKE = '1';
 process.env.SKS_CODEX_0139_FAKE = '1';
 process.env.SKS_CODEX_0140_FAKE = '1';
@@ -8,14 +8,14 @@ process.env.SKS_CODEX_PLUGIN_JSON_FAKE = '1';
 const { buildCodexNativeFeatureMatrix } = await importDist('core/codex-native/codex-native-feature-broker.js');
 const matrix = await buildCodexNativeFeatureMatrix({ root: process.cwd(), mode: 'read-only' });
 const report = {
-    schema: 'sks.codex-0142-doctor-wiring-check.v1',
-    codex_0142: matrix.features.codex_0142?.ok,
+    schema: 'sks.codex-0144-doctor-wiring-check.v1',
+    codex_0144: matrix.features.codex_0144?.ok,
     multi_agent_mode: matrix.features.multi_agent_mode?.ok,
     rollout_budget: matrix.features.rollout_budget?.ok,
     indexed_web_search: matrix.features.indexed_web_search?.ok,
     current_time_read: matrix.features.current_time_read?.ok,
     invocation_defaults: matrix.invocation_defaults
 };
-assertGate(report.codex_0142 === true && report.multi_agent_mode === true && report.rollout_budget === true && report.indexed_web_search === true && report.current_time_read === true, 'Codex 0.142 capability must feed Doctor/native runtime feature matrix', report);
-emitGate('codex-native:0142-doctor-wiring', report);
-//# sourceMappingURL=codex-0142-doctor-wiring-check.js.map
+assertGate(report.codex_0144 === true && report.multi_agent_mode === true && report.rollout_budget === true && report.indexed_web_search === true && report.current_time_read === true, 'Codex 0.144.1 capability must feed Doctor/native runtime feature matrix', report);
+emitGate('codex-native:0144-doctor-wiring', report);
+//# sourceMappingURL=codex-0144-doctor-wiring-check.js.map

package/dist/scripts/{codex-0142-manifest-check.js → codex-0144-manifest-check.js}

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
 import { codexReleaseManifestParity } from '../core/codex-compat/codex-release-manifest.js';
+import { detectCodex0144Capability } from '../core/codex-control/codex-0144-capability.js';
 const parity = await codexReleaseManifestParity(root);
+const shippedCapability = await detectCodex0144Capability({ root });
 const pkg = readJson('package.json');
 const lock = readJson('package-lock.json');
 const manifest = parity.manifest;
@@ -14,9 +16,15 @@ assertGate(dep === manifest.sdkVersion, 'package.json must pin @openai/codex-sdk
 assertGate(lockSdk === manifest.sdkVersion, 'package-lock must resolve @openai/codex-sdk to manifest sdkVersion', { lockSdk, sdkVersion: manifest.sdkVersion });
 assertGate(lockCli === manifest.requiredCliVersion, 'package-lock must resolve @openai/codex to manifest requiredCliVersion', { lockCli, requiredCliVersion: manifest.requiredCliVersion });
 assertGate(pkg.version === lockRootVersion, 'package version must match package-lock root version', { version: pkg.version, lockRootVersion });
-emitGate('codex:0142:manifest', {
+assertGate(shippedCapability.generated_schema_sha256 === manifest.generatedSchemaSha256, 'shipped App Server schema digest must match manifest generatedSchemaSha256', {
+    shippedSchemaSha256: shippedCapability.generated_schema_sha256,
+    manifestSchemaSha256: manifest.generatedSchemaSha256,
+    probeMode: shippedCapability.probe_mode
+});
+emitGate('codex:0144:manifest', {
     manifest_sha256: parity.manifest_sha256,
     target_tag: manifest.targetTag,
-    sdk_version: manifest.sdkVersion
+    sdk_version: manifest.sdkVersion,
+    generated_schema_sha256: shippedCapability.generated_schema_sha256
 });
-//# sourceMappingURL=codex-0142-manifest-check.js.map
+//# sourceMappingURL=codex-0144-manifest-check.js.map

package/dist/scripts/{codex-0142-policy-check.js → codex-0144-policy-check.js}

@@ -23,10 +23,10 @@ for (const key of ['AWS_SECRET_ACCESS_KEY', 'GITHUB_TOKEN', 'SLACK_BOT_TOKEN'])
     assertGate(!(key in env.env), `secret env must not be inherited: ${key}`, env.proof);
 }
 assertGate(policy.network === 'disabled' && policy.approval === 'on-request' && policy.gitRepoCheck === 'required', 'default Codex execution policy must be conservative', policy);
-emitGate('codex:0142:policy', {
+emitGate('codex:0144:policy', {
     inherited_key_count: env.proof.inherited_key_count,
     blocked_sensitive_host_env_key_count: env.proof.blocked_sensitive_host_env_key_count,
     network: policy.network,
     approval: policy.approval
 });
-//# sourceMappingURL=codex-0142-policy-check.js.map
+//# sourceMappingURL=codex-0144-policy-check.js.map

package/dist/scripts/{codex-0142-thread-store-check.js → codex-0144-thread-store-check.js}

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 import { readCodexThreadRegistry, recordCodexThread } from '../core/codex-control/codex-thread-registry.js';
-const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-codex-0142-thread-store-'));
+const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-codex-0144-thread-store-'));
 try {
     await Promise.all(Array.from({ length: 100 }, async (_, index) => {
         await recordCodexThread(tmp, {
@@ -33,7 +33,7 @@ try {
     await recordCodexThread(tmp, { thread_id: 'after-corruption', session_id: 'session-b', work_item_id: 'work-corrupt' });
     const repaired = await readCodexThreadRegistry(tmp);
     assertGate(repaired?.corruption?.preserved_path, 'thread registry corruption must be preserved with evidence', repaired);
-    emitGate('codex:0142:thread-store', {
+    emitGate('codex:0144:thread-store', {
         concurrent_writes: 100,
         storage_mode: registry.storage_mode,
         corruption_preserved: true
@@ -51,4 +51,4 @@ async function exists(file) {
         return false;
     }
 }
-//# sourceMappingURL=codex-0142-thread-store-check.js.map
+//# sourceMappingURL=codex-0144-thread-store-check.js.map

package/dist/scripts/codex-app-provider-model-ui-check.js

@@ -14,30 +14,44 @@ const missing = await codexProviderModelUiStatus({ home, cwd, env: { HOME: home
 const missingText = formatCodexAppStatus(statusFixture(missing));
 await fs.writeFile(path.join(home, '.codex', 'config.toml'), readyConfig(), 'utf8');
 await fs.writeFile(path.join(home, '.codex', 'sks-codex-lb.env'), "export CODEX_LB_BASE_URL='https://lb.example.test/backend-api/codex'\nexport CODEX_LB_API_KEY='sk-codex-lb-fixture'\n", 'utf8');
+const readyCatalog = {
+    schema: 'sks.codex-lb-model-catalog.v1',
+    ok: true,
+    status: 'ready',
+    models: ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'],
+    model_efforts: {
+        'gpt-5.6-sol': ['xhigh', 'max', 'ultra'],
+        'gpt-5.6-terra': ['xhigh', 'max', 'ultra'],
+        'gpt-5.6-luna': ['xhigh', 'max']
+    },
+    blockers: []
+};
 const ready = await codexProviderModelUiStatus({
     home,
     cwd,
     env: { HOME: home, OPENROUTER_API_KEY: 'sk-or-fixture' },
-    codexLbModelCatalog: {
-        schema: 'sks.codex-lb-model-catalog.v1',
-        ok: true,
-        status: 'ready',
-        models: ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'],
-        model_efforts: {
-            'gpt-5.6-sol': ['xhigh', 'max', 'ultra'],
-            'gpt-5.6-terra': ['xhigh', 'max', 'ultra'],
-            'gpt-5.6-luna': ['xhigh', 'max']
-        },
-        blockers: []
-    }
+    codexLbModelCatalog: readyCatalog
 });
 const readyText = formatCodexAppStatus(statusFixture(ready));
-const ok = missing.ok === false
+await fs.writeFile(path.join(home, '.codex', 'config.toml'), codexLbOnlyConfig(), 'utf8');
+const selectedCodexLb = await codexProviderModelUiStatus({
+    home,
+    cwd,
+    env: { HOME: home },
+    codexLbModelCatalog: readyCatalog
+});
+const ok = missing.ok === true
+    && missing.status === 'ready'
+    && missing.selected_provider === 'oauth'
+    && missing.blockers.length === 0
+    && missing.optional_provider_status === 'setup_available'
+    && missing.optional_provider_blockers.includes('glm_openrouter_provider_missing')
+    && missing.optional_provider_blockers.includes('codex_lb_provider_missing')
     && missing.glm.exposed === false
     && missing.codex_lb.key_entry_visible === true
     && missing.ui_actions.includes('sks codex-app set-openrouter-key --api-key-stdin')
     && missing.ui_actions.includes('sks codex-lb setup --host <domain> --api-key-stdin --yes')
-    && /Provider UI:\s*setup/.test(missingText)
+    && /Provider UI:\s*oauth ready, optional providers can be configured/.test(missingText)
     && /GLM Model:\s*setup/.test(missingText)
     && /codex-lb Key:\s*missing \(input: sks codex-lb setup/.test(missingText)
     && ready.ok === true
@@ -48,17 +62,24 @@ const ok = missing.ok === false
     && ready.codex_lb.key_present === true
     && ready.codex_lb.model_catalog_ok === true
     && ready.codex_lb.expected_models_present === true
-    && /Provider UI:\s*config\/catalog ready/.test(readyText)
+    && /Provider UI:\s*oauth ready/.test(readyText)
     && ready.desktop_picker_verified === false
     && readyText.includes(`GLM Model:  ok ${GLM_52_OPENROUTER_MODEL}`)
     && /codex-lb Key:\s*configured/.test(readyText)
-    && !JSON.stringify({ missing, ready, missingText, readyText }).includes('sk-codex-lb-fixture');
+    && selectedCodexLb.ok === true
+    && selectedCodexLb.status === 'ready'
+    && selectedCodexLb.selected_provider === 'codex-lb'
+    && selectedCodexLb.selected_provider_blockers.length === 0
+    && selectedCodexLb.blockers.length === 0
+    && selectedCodexLb.optional_provider_blockers.includes('glm_openrouter_provider_missing')
+    && !JSON.stringify({ missing, ready, selectedCodexLb, missingText, readyText }).includes('sk-codex-lb-fixture');
 emit({
     schema: 'sks.codex-app-provider-model-ui-check.v1',
     ok,
     missing,
     ready,
-    secret_safe: !JSON.stringify({ missing, ready, missingText, readyText }).includes('sk-codex-lb-fixture'),
+    selected_codex_lb: selectedCodexLb,
+    secret_safe: !JSON.stringify({ missing, ready, selectedCodexLb, missingText, readyText }).includes('sk-codex-lb-fixture'),
     blockers: ok ? [] : ['codex_app_provider_model_ui_check_failed']
 });
 function readyConfig() {
@@ -89,12 +110,25 @@ function readyConfig() {
         ''
     ].join('\n');
 }
+function codexLbOnlyConfig() {
+    return [
+        'model_provider = "codex-lb"',
+        '[model_providers.codex-lb]',
+        'name = "openai"',
+        'base_url = "https://lb.example.test/backend-api/codex"',
+        'wire_api = "responses"',
+        'env_key = "CODEX_LB_API_KEY"',
+        'supports_websockets = true',
+        'requires_openai_auth = true',
+        ''
+    ].join('\n');
+}
 function statusFixture(providerModelUi) {
     return {
         ok: providerModelUi.ok,
         app: { installed: true, path: '/Applications/Codex.app' },
-        codex_cli: { ok: true, version: '0.142.0' },
-        remote_control: { ok: true, min_version: '0.130.0', codex_cli: { version_number: '0.142.0' } },
+        codex_cli: { ok: true, version: '0.144.1' },
+        remote_control: { ok: true, min_version: '0.130.0', codex_cli: { version_number: '0.144.1' } },
         features: {
             checked: true,
             required_flags_ok: true,

package/dist/scripts/codex-app-ui-preservation-check.js

@@ -34,13 +34,14 @@ delete process.env.SKS_MANAGE_CODEX_APP_PLUGINS;
     const ok = featureValue(out, 'hooks') === 'false' && featureValue(out, 'multi_agent') === 'false';
     results.push({ case: 'preserves_disabled_features', ok, hooks: featureValue(out, 'hooks') });
 }
-// 1b) Removed legacy feature flags are stripped instead of preserved.
+// 1b) Stable host capabilities preserve an explicit user false; only a
+// genuinely removed SKS stamp is stripped.
 {
     const out = normalize('[features]\nguardian_approval = false\nbrowser_use_external = false\nfast_mode_ui = true\n');
-    const ok = featureValue(out, 'guardian_approval') === undefined
-        && featureValue(out, 'browser_use_external') === undefined
+    const ok = featureValue(out, 'guardian_approval') === 'false'
+        && featureValue(out, 'browser_use_external') === 'false'
         && featureValue(out, 'fast_mode_ui') === undefined;
-    results.push({ case: 'strips_removed_feature_flags', ok });
+    results.push({ case: 'preserves_stable_and_strips_removed_flags', ok });
 }
 // 2) Default install must NOT auto-enable any marketplace plugins.
 {
@@ -66,11 +67,41 @@ delete process.env.SKS_MANAGE_CODEX_APP_PLUGINS;
         && featureValue(out, 'hooks') === 'true'
         && featureValue(out, 'multi_agent') === 'true'
         && featureValue(out, 'fast_mode') === 'true'
+        && featureValue(out, 'computer_use') === 'true'
+        && featureValue(out, 'browser_use') === 'true'
+        && featureValue(out, 'browser_use_external') === 'true'
+        && featureValue(out, 'image_generation') === 'true'
+        && featureValue(out, 'in_app_browser') === 'true'
+        && featureValue(out, 'tool_suggest') === 'true'
+        && featureValue(out, 'plugins') === 'true'
         && !/\[user\.fast_mode\]/.test(out)
         && !/\[profiles\.sks-fast-high\]/.test(out)
         && !/^model\s*=/m.test(out);
     results.push({ case: 'fresh_config_seeds_defaults', ok });
 }
+// 7) A blank-separated SKS migration block must release only its own native
+// model/reasoning locks. The documented service tier and an unrelated user
+// model selection remain untouched.
+{
+    const migrated = normalize([
+        '# SKS moved machine-local Codex config from .codex/config.toml at 2026-07-11T00:00:00Z',
+        '',
+        'service_tier = "fast"',
+        'model = "gpt-5.6-sol"',
+        'model_reasoning_effort = "ultra"',
+        '',
+        '[features]',
+        'fast_mode = true',
+        ''
+    ].join('\n'));
+    const user = normalize('model = "user-selected-model"\nmodel_reasoning_effort = "low"\nservice_tier = "fast"\n');
+    const ok = !/^model\s*=/m.test(migrated.split(/\n\s*\[/)[0] || '')
+        && !/^model_reasoning_effort\s*=/m.test(migrated.split(/\n\s*\[/)[0] || '')
+        && /^service_tier\s*=\s*"fast"/m.test(migrated)
+        && /^model\s*=\s*"user-selected-model"/m.test(user)
+        && /^model_reasoning_effort\s*=\s*"low"/m.test(user);
+    results.push({ case: 'bounded_sks_mode_lock_provenance', ok });
+}
 // 6) Opt-in enables plugins on a fresh config, but still preserves a user-disabled one.
 {
     process.env.SKS_MANAGE_CODEX_APP_PLUGINS = '1';

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

@@ -12,6 +12,7 @@ const sources = {
     team: readText('src/core/commands/team-command.ts'),
     qa: readText('src/core/commands/qa-loop-command.ts'),
     research: readText('src/core/commands/research-command.ts'),
+    researchStage: readText('src/core/research/research-stage-runner.ts'),
     naruto: readText('src/core/commands/naruto-command.ts'),
     dfix: readText('src/core/commands/dfix-command.ts'),
     workerRouter: readText('src/core/agents/native-worker-backend-router.ts')
@@ -19,11 +20,14 @@ const sources = {
 const teamCreateRedirectsToNaruto = sources.team.includes('redirectTeamCreateToNaruto') && sources.team.includes('narutoCommand');
 assertGate(teamCreateRedirectsToNaruto, 'Team create must route through Naruto codex control backend SSOT');
 assertGate(sources.qa.includes("mock ? 'fake' : 'codex-sdk'"), 'QA must route native agents through codex control backend');
-assertGate(sources.research.includes("mock ? 'fake' : 'codex-sdk'"), 'Research must route native agents through codex control backend');
-assertGate(sources.naruto.includes("backend: 'codex-sdk'"), 'Naruto defaults must name codex-sdk control backend');
+assertGate(sources.research.includes("backend: mock ? 'mock' : 'codex-sdk'")
+    && sources.researchStage.includes('runCodexTask({'), 'Research must route real stages through the Codex control backend');
+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 fall back to the legacy codex-sdk backend selector');
 assertGate(sources.workerRouter.includes('runCodexTask({'), 'native worker router must call runCodexTask');
 const fixture = await runFakeCodexSdkTaskFixture('control-all-pipelines');
 assertGate(fixture.result.ok === true, 'all pipeline control fixture must pass', fixture.result);
 assertGate(fixture.proof.reliability_shield?.ok === true, 'all pipeline fixture must include reliability shield proof', fixture.proof);
-emitGate('codex-control:all-pipelines', { gates: required.length, sdk_thread_id: fixture.result.sdkThreadId });
+emitGate('codex-control:all-pipelines', { gates: required.length, naruto_workflow: 'official_codex_subagent', sdk_thread_id: fixture.result.sdkThreadId });
 //# sourceMappingURL=codex-control-all-pipelines-check.js.map

package/dist/scripts/codex-control-side-effect-scope-check.js

@@ -13,12 +13,12 @@ const base = {
     mutationLedgerRoot: process.cwd()
 };
 const readOnly = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'read-only', requestedScopeContract: { read_only: true } });
-const workspaceMissing = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'workspace-write', requestedScopeContract: { read_only: false, allowed_paths: [], write_paths: [] } });
+const emptyWriteScope = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'workspace-write', requestedScopeContract: { read_only: false, allowed_paths: [], write_paths: [] } });
 const workspaceScoped = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'workspace-write', requestedScopeContract: { read_only: false, allowed_paths: ['src/core'], write_paths: ['src/core'] } });
 const fullBlocked = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'full-access', requestedScopeContract: { read_only: false, user_confirmed_full_access: true, mad_sks_authorized: false } });
 const fullMad = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'full-access', requestedScopeContract: { read_only: false, user_confirmed_full_access: true, mad_sks_authorized: true } });
 assertGate(readOnly.ok && readOnly.sandboxMode === 'read-only', 'read-only sandbox mapping failed', readOnly);
-assertGate(!workspaceMissing.ok && workspaceMissing.blockers.includes('codex_sdk_workspace_write_scope_contract_missing'), 'workspace-write must require scoped paths', workspaceMissing);
+assertGate(emptyWriteScope.ok && emptyWriteScope.sandboxMode === 'read-only', 'workspace-write without scoped paths must downgrade to read-only', emptyWriteScope);
 assertGate(workspaceScoped.ok && workspaceScoped.sandboxMode === 'workspace-write', 'workspace-write scoped mapping failed', workspaceScoped);
 assertGate(!fullBlocked.ok && fullBlocked.blockers.includes('codex_sdk_full_access_requires_explicit_mad_scope'), 'full-access must require explicit MAD scope', fullBlocked);
 assertGate(fullMad.ok && fullMad.sandboxMode === 'danger-full-access', 'MAD-scoped full access must map to danger-full-access', fullMad);

package/dist/scripts/codex-control-tool-output-continuity-audit-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-reliability-shield.js');
+const audit = mod.auditToolOutputContinuity([
+    { type: 'thread.started' },
+    { type: 'item.completed', item: { id: 'call-1', call_id: 'call-1', type: 'custom_tool_call', name: 'fixture' } },
+    { type: 'item.completed', item: { id: 'call-2', call_id: 'call-2', type: 'custom_tool_call', name: 'fixture' } },
+    { type: 'item.completed', item: { call_id: 'call-1', type: 'custom_tool_call_output', output: 'ok' } }
+]);
+assertGate(audit.missingToolResultCount === 1, 'one missing custom tool output must be detected', audit);
+assertGate(audit.missingToolCallIds.includes('call-2'), 'missing custom tool call id not reported', audit);
+assertGate(!audit.events.some((event) => event.type === 'tool_result.stubbed'), 'continuity audit must never fabricate a tool output', audit);
+const rolloutAudit = mod.auditToolOutputContinuity([
+    { type: 'response_item', payload: { type: 'custom_tool_call', call_id: 'rollout-call-1', name: 'fixture' } },
+    { type: 'rollout_record', response_item: { payload: { type: 'custom_tool_call', call_id: 'rollout-call-2', name: 'fixture' } } },
+    { type: 'response_item', payload: { type: 'custom_tool_call_output', call_id: 'rollout-call-1', output: 'ok' } }
+]);
+assertGate(rolloutAudit.missingToolResultCount === 1, 'persisted response_item rollout envelopes must be audited', rolloutAudit);
+assertGate(rolloutAudit.missingToolCallIds.includes('rollout-call-2'), 'rollout envelope missing call id not reported', rolloutAudit);
+emitGate('codex-control:tool-output-continuity-audit', {
+    status: 'fail_closed_audit',
+    fabricated_tool_result_count: 0,
+    missing_tool_result_count: audit.missingToolResultCount,
+    rollout_missing_tool_result_count: rolloutAudit.missingToolResultCount
+});
+//# sourceMappingURL=codex-control-tool-output-continuity-audit-check.js.map

package/dist/scripts/codex-effort-auto-discovery-check.js

@@ -4,7 +4,7 @@ import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
 process.env.SKS_CODEX_MODEL_METADATA_FAKE = '1';
 process.env.SKS_CODEX_MODEL_EFFORTS = 'low,medium,high,xhigh';
 const mod = await importDist('core/codex-control/codex-model-capabilities.js');
-const capability = await mod.resolveCodexModelEffortCapability({ model: 'gpt-5.5' });
+const capability = await mod.resolveCodexModelEffortCapability({ model: 'gpt-5.6-terra' });
 assertGate(capability.metadata_source === 'app-server' && capability.advertised_efforts.join(',') === 'low,medium,high,xhigh', 'effort capability must auto-discover model advertised effort order');
 delete process.env.SKS_CODEX_MODEL_METADATA_FAKE;
 delete process.env.SKS_CODEX_MODEL_EFFORTS;

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

@@ -7,6 +7,7 @@ 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 });
 await fs.writeFile(path.join(home, '.codex', 'config.toml'), [
+    'model = "gpt-5.6-sol"',
     'model_provider = "codex-lb"',
     'service_tier = "fast"',
     '',

package/dist/scripts/{codex-lb-gpt55-fast-profile-check.js → codex-lb-gpt56-fast-profile-check.js}

@@ -5,7 +5,8 @@ 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';
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-gpt55-fast-'));
+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');
 const root = path.join(tmp, 'project');
 const codexHome = path.join(home, '.codex');
@@ -52,6 +53,7 @@ await fs.writeFile(projectConfig, [
 const split = await splitCodexProjectConfigPolicy(root, { apply: true, codexHome, configPath: projectConfig, writeReport: false });
 const structure = await repairCodexConfigStructure(configPath, { apply: true });
 const final = assertFastProfile(await fs.readFile(configPath, 'utf8'), 'after_rewriters');
+const toolCatalog = assertGpt56ToolCatalogContract();
 const ok = setup.ok !== false
     && !['failed', 'skipped_unsafe_rewrite', 'unparseable_config_preserved'].includes(String(fastOn.status))
     && release.status !== 'failed'
@@ -60,9 +62,10 @@ const ok = setup.ok !== false
     && structure.ok === true
     && first.ok
     && afterOauth.ok
-    && final.ok;
+    && final.ok
+    && toolCatalog.ok;
 const report = {
-    schema: 'sks.codex-lb-gpt55-fast-profile-check.v1',
+    schema: 'sks.codex-lb-gpt56-fast-profile-check.v1',
     ok,
     setup_status: setup.status,
     fast_on_status: fastOn.status,
@@ -71,7 +74,8 @@ const report = {
     split_status: split.status || null,
     structure_status: structure.status,
     assertions: [first, afterOauth, final],
-    blockers: [first, afterOauth, final].flatMap((item) => item.blockers)
+    tool_catalog: toolCatalog,
+    blockers: [...[first, afterOauth, final].flatMap((item) => item.blockers), ...toolCatalog.blockers]
 };
 console.log(JSON.stringify(report, null, 2));
 if (!report.ok)
@@ -103,4 +107,51 @@ function assertFastProfile(text, label) {
         blockers
     };
 }
-//# sourceMappingURL=codex-lb-gpt55-fast-profile-check.js.map
+function assertGpt56ToolCatalogContract() {
+    const normalized = normalizeCodexLbToolCatalog({
+        models: ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'].map(codex0144Model)
+    });
+    const models = normalized.catalog.models.filter((model) => String(model.slug).startsWith('gpt-5.6-'));
+    const blockers = [
+        ...normalized.blockers,
+        ...(normalized.schema === 'sks.codex-lb-tool-catalog.v1' ? [] : ['codex_lb_gpt56_catalog_schema_mismatch']),
+        ...(normalized.tools_transport === 'full_responses' ? [] : ['codex_lb_gpt56_native_tool_transport_not_full_responses']),
+        ...(normalized.patched_models.join(',') === 'gpt-5.6-luna,gpt-5.6-sol,gpt-5.6-terra' ? [] : ['codex_lb_gpt56_catalog_patch_set_incomplete']),
+        ...(models.length === 3 ? [] : ['codex_lb_gpt56_catalog_model_set_incomplete']),
+        ...(models.every((model) => model.use_responses_lite === false) ? [] : ['codex_lb_gpt56_responses_lite_not_disabled']),
+        ...(models.every((model) => model.tool_mode === 'code_mode_only') ? [] : ['codex_lb_gpt56_native_tool_mode_not_preserved']),
+        ...(models.every((model) => model.supports_parallel_tool_calls === true) ? [] : ['codex_lb_gpt56_parallel_tool_calls_not_preserved']),
+        ...(models.every((model) => model.minimal_client_version === '0.144.1') ? [] : ['codex_lb_gpt56_codex_0144_contract_missing'])
+    ];
+    return {
+        schema: normalized.schema,
+        ok: blockers.length === 0,
+        codex_cli_contract: '0.144.1',
+        models: normalized.gpt56_models,
+        patched_models: normalized.patched_models,
+        tools_transport: normalized.tools_transport,
+        native_tool_mode: 'code_mode_only',
+        blockers
+    };
+}
+function codex0144Model(slug) {
+    return {
+        slug,
+        display_name: slug.replace('gpt-', 'GPT-').replaceAll('-', ' '),
+        supported_reasoning_levels: [{ effort: 'max', description: 'Maximum' }],
+        shell_type: 'shell_command',
+        visibility: 'list',
+        supported_in_api: true,
+        priority: 1,
+        base_instructions: 'You are Codex.',
+        supports_reasoning_summaries: true,
+        support_verbosity: true,
+        truncation_policy: { mode: 'tokens', limit: 10_000 },
+        supports_parallel_tool_calls: true,
+        experimental_supported_tools: [],
+        tool_mode: 'code_mode_only',
+        use_responses_lite: true,
+        minimal_client_version: '0.144.1'
+    };
+}
+//# sourceMappingURL=codex-lb-gpt56-fast-profile-check.js.map

package/dist/scripts/codex-model-metadata-check.js

@@ -4,7 +4,7 @@ import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
 process.env.SKS_CODEX_MODEL_METADATA_FAKE = '1';
 process.env.SKS_CODEX_MODEL_EFFORTS = 'low,medium,high,xhigh';
 const mod = await importDist('core/codex-control/codex-model-metadata.js');
-const metadata = await mod.collectCodexModelMetadata({ model: 'gpt-5.5' });
+const metadata = await mod.collectCodexModelMetadata({ model: 'gpt-5.6-terra' });
 assertGate(metadata.source === 'app-server' && metadata.advertised_efforts.includes('xhigh'), 'Codex model metadata collector must expose advertised efforts');
 emitGate('codex:model-metadata', { source: metadata.source, efforts: metadata.advertised_efforts });
 //# sourceMappingURL=codex-model-metadata-check.js.map

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

@@ -2,18 +2,26 @@
 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');
+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(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 === 'max', `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');
+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)