sneakoscope 6.0.1 → 6.0.2

package/dist/core/commands/basic-cli.js

@@ -187,6 +187,8 @@ export async function updateCommand(sub = 'now', args = []) {
         process.exitCode = 1;
 }
 export async function setupCommand(args = []) {
+    if (flag(args, '--help') || flag(args, '-h'))
+        return usageCommand(['setup']);
     const root = await projectRoot();
     const installScope = installScopeFromArgs(args);
     let res = null;
@@ -221,9 +223,13 @@ export async function setupCommand(args = []) {
         console.log(`- ${file}`);
 }
 export async function bootstrapCommand(args = []) {
+    if (flag(args, '--help') || flag(args, '-h'))
+        return usageCommand(['bootstrap']);
     return setupCommand(['--local-only', ...args]);
 }
 export async function initCommand(args = []) {
+    if (flag(args, '--help') || flag(args, '-h'))
+        return usageCommand(['init']);
     return setupCommand(args);
 }
 export async function fixPathCommand(args = []) {

package/dist/core/commands/loop-command.js

@@ -77,7 +77,7 @@ async function loopRun(args) {
         console.log(`Loop plan blocked: ${plan.blockers.join(', ')}`);
         return;
     }
-    const parallelism = normalizeParallelism(readFlagValue(args, '--parallelism', 'balanced'));
+    const parallelism = normalizeParallelism(readFlagValue(args, '--parallelism', 'safe'));
     const result = await runLoopPlan({ root, plan, parallelism });
     await setCurrent(root, { mission_id: missionId, mode: 'LOOP', route: 'Loop', route_command: '$Loop', phase: result.ok ? 'LOOP_COMPLETED' : 'LOOP_BLOCKED', stop_gate: 'loop-graph-proof.json' });
     if (flag(args, '--json'))
@@ -165,7 +165,7 @@ async function loopResume(args) {
     const existingProofs = await Promise.all(plan.graph.nodes.map((node) => readJson(loopProofPath(root, missionId, node.loop_id), null)));
     const completed = new Set(existingProofs.filter((proof) => proof !== null && proof.status === 'completed').map((proof) => proof.loop_id));
     const runnable = rerunCompleted ? plan.graph.nodes : plan.graph.nodes.filter((node) => !completed.has(node.loop_id));
-    const schedule = scheduleLoopGraph(runnable, normalizeParallelism(readFlagValue(args, '--parallelism', 'balanced')));
+    const schedule = scheduleLoopGraph(runnable, normalizeParallelism(readFlagValue(args, '--parallelism', 'safe')));
     const started = Date.now();
     const resumedProofs = [];
     for (const batch of schedule.batches) {

package/dist/core/commands/naruto-command.js

@@ -219,9 +219,8 @@ async function narutoRun(parsed) {
         backend: schedulerBackend,
         parallelismMode: parsed.parallelism
     });
-    const backendMinimum = schedulerBackend === 'fake' ? roster.agent_count : Math.min(roster.agent_count, 2);
-    const activeCap = parsed.parallelism === 'safe' ? safe.cap : MAX_NARUTO_AGENT_COUNT;
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), activeCap));
+    const activeCap = Math.min(safe.cap, governor.safe_active_workers);
+    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || activeCap, activeCap));
     const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
     const runPreRunSmoke = parsed.smoke === true || process.env.SKS_NARUTO_PRE_RUN_SMOKE === '1';
     const realActivePoolSmoke = runPreRunSmoke
@@ -257,9 +256,6 @@ async function narutoRun(parsed) {
         };
     const verificationCommand = resolveNarutoVerificationCommand(root);
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root, command: verificationCommand });
-    const verificationDagRunPromise = verificationDag.configured && verificationDag.tasks.length > 0
-        ? runNarutoVerificationPool(verificationDag, governor, { cwd: root, logDir: path.join(mission.dir, 'agents', 'verification-logs') })
-        : Promise.resolve(null);
     const gptFinalPack = buildNarutoGptFinalPack({
         missionId: mission.id,
         graph: workGraph,
@@ -443,7 +439,11 @@ async function narutoRun(parsed) {
     // skipped the proof precisely when it mattered most — real execution.
     const parallelRuntimeOk = parsed.mock || roster.agent_count < 16 || (parallelRuntime?.passed === true
         && Number(parallelRuntime.max_observed_active_workers || 0) >= Math.min(16, activeSlots));
-    const verificationDagResult = await verificationDagRunPromise;
+    // Verification starts only after clone workers finish so two process pools do
+    // not compete for CPU, memory, and disk at the same time.
+    const verificationDagResult = verificationDag.configured && verificationDag.tasks.length > 0
+        ? await runNarutoVerificationPool(verificationDag, governor, { cwd: root, logDir: path.join(mission.dir, 'agents', 'verification-logs') })
+        : null;
     if (verificationDagResult)
         await writeJsonAtomic(path.join(mission.dir, 'naruto-verification-dag-result.json'), verificationDagResult);
     const verificationDagOk = !verificationDag.configured || verificationDagResult === null ? true : verificationDagResult.ok === true;
@@ -1009,7 +1009,7 @@ function parseNarutoArgs(args = []) {
     // Computed early (normally derived further down) so an explicit --clones/
     // --agents can still override this exactly as before, but the *default*
     // scales with apparent task size instead of unconditionally requesting
-    // DEFAULT_NARUTO_CLONES (32) for every run, including a one-line typo fix
+    // DEFAULT_NARUTO_CLONES for every run, including a one-line typo fix
     // (20차 P2-3). --work-items defaults to clones*2 below, so this alone
     // scales that down proportionally too.
     const promptSizingValueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--max-write-agents', '--service-tier', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism', '--messages', '--tournament']);
@@ -1062,17 +1062,17 @@ function parseNarutoArgs(args = []) {
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
     const attach = hasFlag(args, '--attach');
     const smoke = hasFlag(args, '--smoke');
-    const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'extreme'));
+    const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'safe'));
     const messages = normalizeMessages(readOption(args, '--messages', '8'));
     const tournament = normalizeTournament(readOption(args, '--tournament', '0'));
     const prompt = promptForSizing || 'Naruto shadow clone swarm run';
     return { action, prompt, clones, workItems, workItemsExplicit, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, json, missionId, noOpenZellij, attach, smoke, parallelism, messages, tournament };
 }
 function normalizeParallelism(value) {
-    const text = String(value || 'extreme').toLowerCase();
+    const text = String(value || 'safe').toLowerCase();
     if (text === 'safe' || text === 'balanced' || text === 'extreme')
         return text;
-    return 'extreme';
+    return 'safe';
 }
 function normalizeMessages(value) {
     const parsed = Number(value);

package/dist/core/commands/profile-command.js

@@ -1,18 +1,27 @@
 import path from 'node:path';
 import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
-import { DEFAULT_CODEX_REASONING_EFFORT, REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
+import { DEFAULT_CODEX_REASONING_EFFORT } from '../codex-model-guard.js';
 import { ALLOWED_REASONING_EFFORTS } from '../routes.js';
 export async function profileCommand(sub, args = []) {
     const root = await sksRoot();
     if (sub === 'show')
-        return console.log(JSON.stringify(await readJson(path.join(root, '.sneakoscope', 'model', 'current.json'), { model: REQUIRED_CODEX_MODEL, reasoning_effort: DEFAULT_CODEX_REASONING_EFFORT }), null, 2));
+        return console.log(JSON.stringify(await readJson(path.join(root, '.sneakoscope', 'model', 'current.json'), { model: null, model_policy: 'inherit_codex_selection', reasoning_effort: DEFAULT_CODEX_REASONING_EFFORT }), null, 2));
     if (sub === 'set') {
         const effort = args[0] || DEFAULT_CODEX_REASONING_EFFORT;
         if (!ALLOWED_REASONING_EFFORTS.has(effort))
             throw new Error(`unsupported reasoning effort: ${effort}; use ${[...ALLOWED_REASONING_EFFORTS].join(', ')}`);
-        await writeJsonAtomic(path.join(root, '.sneakoscope', 'model', 'current.json'), { model: REQUIRED_CODEX_MODEL, reasoning_effort: effort, set_at: new Date().toISOString() });
-        return console.log(`Model profile set: ${REQUIRED_CODEX_MODEL} ${effort}`);
+        const modelIndex = args.indexOf('--model');
+        const model = modelIndex >= 0 ? String(args[modelIndex + 1] || '').trim() : '';
+        if (modelIndex >= 0 && !model)
+            throw new Error('--model requires a Codex model identifier');
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'model', 'current.json'), {
+            model: model || null,
+            model_policy: model ? 'explicit' : 'inherit_codex_selection',
+            reasoning_effort: effort,
+            set_at: new Date().toISOString()
+        });
+        return console.log(`Model profile set: ${model || 'Codex-selected model'} ${effort}`);
     }
-    console.error(`Usage: sks profile show|set <${[...ALLOWED_REASONING_EFFORTS].join('|')}>`);
+    console.error(`Usage: sks profile show|set <${[...ALLOWED_REASONING_EFFORTS].join('|')}> [--model <codex-model-id>]`);
 }
 //# sourceMappingURL=profile-command.js.map

package/dist/core/commands/qa-loop-command.js

@@ -160,7 +160,7 @@ async function qaLoopRun(args) {
     const fallbackCycles = Number.parseInt(contract.answers?.MAX_QA_CYCLES, 10) || DEFAULT_QA_MAX_CYCLES;
     const maxCycles = readMaxCycles(args, fallbackCycles);
     const requestedAgents = readBoundedIntegerFlag(args, '--agents', 3, 1, 20);
-    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', requestedAgents, 1, 20);
+    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', Math.min(requestedAgents, 4), 1, 4);
     const desiredWorkItemCount = readBoundedIntegerFlag(args, '--work-items', targetActiveSlots, 1, 200);
     const minimumWorkItems = readBoundedIntegerFlag(args, '--minimum-work-items', targetActiveSlots, 1, 200);
     const maxQueueExpansion = readBoundedIntegerFlag(args, '--max-queue-expansion', 10, 0, 200);
@@ -322,7 +322,7 @@ async function qaLoopRun(args) {
         emitStreamEvent('progress', { mission_id: id, type: 'qaloop.run.started', max_cycles: maxCycles, mock });
     const nativeAgentPlan = await readJson(path.join(dir, 'qa-agent-plan.json'), null);
     const nativeRoster = requestedAgents === 3 ? nativeAgentPlan : null;
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !(applyPatches && writeMode !== 'off'), profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: nativeRoster, routeCommand: 'sks qa-loop run', routeBlackboxKind: 'actual_qa_command', env: { SKS_CODEX_APP_EXECUTION_PROFILE: executionProfile?.mode || 'unknown', SKS_CODEX_AGENT_ROLE_STRATEGY: executionProfile?.agent_role_strategy || 'message-role' } });
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 4), readonly: !(applyPatches && writeMode !== 'off'), profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: nativeRoster, routeCommand: 'sks qa-loop run', routeBlackboxKind: 'actual_qa_command', env: { SKS_CODEX_APP_EXECUTION_PROFILE: executionProfile?.mode || 'unknown', SKS_CODEX_AGENT_ROLE_STRATEGY: executionProfile?.agent_role_strategy || 'message-role' } });
     await writeJsonAtomic(path.join(dir, 'qa-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (stream)

package/dist/core/commands/research-command.js

@@ -158,7 +158,7 @@ async function researchRun(args) {
     }
     const maxCycles = readMaxCycles(args, RESEARCH_DEFAULT_MAX_CYCLES);
     const requestedAgents = readBoundedIntegerFlag(args, '--agents', plan.native_agent_plan?.session_count || 5, 1, 20);
-    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', requestedAgents, 1, 20);
+    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', Math.min(requestedAgents, 4), 1, 4);
     const desiredWorkItemCount = readBoundedIntegerFlag(args, '--work-items', targetActiveSlots, 1, 200);
     const minimumWorkItems = readBoundedIntegerFlag(args, '--minimum-work-items', targetActiveSlots, 1, 200);
     const maxQueueExpansion = readBoundedIntegerFlag(args, '--max-queue-expansion', 10, 0, 200);
@@ -181,7 +181,7 @@ async function researchRun(args) {
     await runResearchCycle(dir, researchWorkGraph, { cycle: 0, status: mock ? 'mock_native_orchestrator_planned' : 'native_orchestrator_planned' });
     await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_RUNNING_NO_QUESTIONS', questions_allowed: false, implementation_allowed: false, research_real_run_required: !mock, research_cycle_timeout_minutes: cycleTimeoutMinutes });
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.run.started', maxCycles, mock, cycleTimeoutMinutes, real_run_required: !mock });
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount: effectiveDesiredWorkItemCount, minimumWorkItems: effectiveMinimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !applyPatches, profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command', narutoWorkGraph: researchWorkGraph });
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount: effectiveDesiredWorkItemCount, minimumWorkItems: effectiveMinimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 4), readonly: !applyPatches, profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command', narutoWorkGraph: researchWorkGraph });
     await writeJsonAtomic(path.join(dir, 'research-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (!nativeAgentRun.ok) {

package/dist/core/doctor/doctor-codex-startup-repair.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { REQUIRED_CODEX_MODEL, DEFAULT_CODEX_REASONING_EFFORT } from '../codex-model-guard.js';
 import { ensureDir, exists, nowIso, readText, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { isUnmanagedProjectCodexConfig, writeCodexConfigGuarded } from '../codex/codex-config-guard.js';
 export const DOCTOR_CODEX_STARTUP_REPAIR_SCHEMA = 'sks.doctor-codex-startup-repair.v1';
@@ -486,8 +485,6 @@ function roleConfigToml(name, description, sandbox) {
     return [
         `name = "${name}"`,
         `description = "${description}"`,
-        `model = "${REQUIRED_CODEX_MODEL}"`,
-        `model_reasoning_effort = "${DEFAULT_CODEX_REASONING_EFFORT}"`,
         `sandbox_mode = "${sandbox}"`,
         'approval_policy = "never"',
         'developer_instructions = """',

package/dist/core/evaluation.js

@@ -67,7 +67,7 @@ export const PERMISSION_PROFILES = Object.freeze({
     dangerous_full_access: { filesystem: 'full-access', network: 'controlled', purpose: 'Never default. Requires explicit reason and review.' }
 });
 export const DEFAULT_MULTIAGENT_V2 = Object.freeze({
-    max_threads: 6,
+    max_threads: 4,
     max_depth: 1,
     job_max_runtime_seconds: 1800,
     wait_control: 'bounded_wait_then_structured_summary',

package/dist/core/feature-fixtures.js

@@ -216,8 +216,8 @@ const FIXTURES = Object.freeze({
     'route-commit-and-push': fixture('mock', '$Commit-And-Push git route', ['completion-proof.json'], 'pass', {
         reason: 'Dollar-command alias of cli-commit-and-push; dispatches to the same simpleGitCommitCommand() that performs a real commit and `git push` with no working --dry-run mode. Left as documented mock alongside cli-commit-and-push.'
     }),
-    'route-release-review': fixture('execute_and_validate_artifacts', 'sks agent run "release audit" --route "$Release-Review" --agents 10 --concurrency 5 --mock --json', ['release-review-native-agent-plan.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass', { timeout_ms: 90000 }),
-    'route-native-agent-intake': fixture('execute_and_validate_artifacts', 'sks agent run "fixture" --route "$Team" --agents 5 --concurrency 5 --mock --json', ['agents/agent-central-ledger.json', 'agents/agent-task-board.json', 'agents/agent-leases.json', 'agents/agent-no-overlap-proof.json', 'agents/agent-session-cleanup.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass', { timeout_ms: 90000 }),
+    'route-release-review': fixture('execute_and_validate_artifacts', 'sks agent run "release audit" --route "$Release-Review" --agents 10 --concurrency 4 --mock --json', ['release-review-native-agent-plan.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass', { timeout_ms: 90000 }),
+    'route-native-agent-intake': fixture('execute_and_validate_artifacts', 'sks agent run "fixture" --route "$Team" --agents 5 --concurrency 4 --mock --json', ['agents/agent-central-ledger.json', 'agents/agent-task-board.json', 'agents/agent-leases.json', 'agents/agent-no-overlap-proof.json', 'agents/agent-session-cleanup.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass', { timeout_ms: 90000 }),
     'proof-agent-evidence': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['naruto-gate.json', 'agents/agent-proof-evidence.json'], 'pass', { timeout_ms: 240000 })
 });
 const STATIC_CONTRACT_FEATURES = new Set([

package/dist/core/feature-registry.js

@@ -668,7 +668,7 @@ function routeFeature(route) {
 function nativeAgentIntakeFeature() {
     return baseFeature({
         id: 'route-native-agent-intake',
-        commands: ['sks agent run "task" --route "$Team" --agents 5 --concurrency 5 --mock --json'],
+        commands: ['sks agent run "task" --route "$Team" --agents 5 --concurrency 4 --mock --json'],
         aliases: ['sks team "task" [executor:5 reviewer:6 user:1]'],
         category: 'proof-route',
         maturity: 'stable',

package/dist/core/hooks-runtime.js

@@ -10,7 +10,6 @@ import { classifyMadSksShellCommand } from './mad-sks/write-guard.js';
 import { activeRouteContext, evaluateStop, prepareRoute, promptPipelineContext as routePipelineContext, recordContext7Evidence, recordSubagentEvidence, routePrompt } from './pipeline.js';
 import { localizedFinalizationReason } from './language-preference.js';
 import { classifyToolError } from './evaluation.js';
-import { REQUIRED_CODEX_MODEL, SUPPORTED_CODEX_MODELS, isForbiddenCodexModel } from './codex-model-guard.js';
 import { dollarCommand, routeRequiresSubagents, stripVisibleDecisionAnswerBlocks } from './routes.js';
 import { leanEngineeringCompactText } from './lean-engineering-policy.js';
 import { appendMissionStatus } from './recallpulse.js';
@@ -188,9 +187,6 @@ export async function evaluateHookPayload(name, payload = {}, opts = {}) {
     const state = { ...loadedState, _session_key: loadedState?._session_key || sessionKey };
     const noQuestion = isNoQuestionRunning(state);
     if (name === 'user-prompt-submit') {
-        const modelBlock = blockForbiddenClientModel(payload);
-        if (modelBlock)
-            return modelBlock;
         return hookUserPrompt(root, state, payload, noQuestion, sessionKey);
     }
     if (name === 'pre-tool')
@@ -208,20 +204,14 @@ export async function evaluateHookPayload(name, payload = {}, opts = {}) {
 async function hookSubagentStart(root, state, sessionKey = null) {
     void sessionKey;
     const active = await activeRouteContext(root, state).catch(() => '');
-    const additionalContext = [leanEngineeringCompactText(), active].filter(Boolean).join('\n\n');
+    const resourceGuard = [
+        'SKS resource guard: keep at most 4 active subagents in this session.',
+        'Subagents must not spawn nested subagents or duplicate an already assigned audit lane.',
+        'Queue additional independent work instead of increasing active fan-out.'
+    ].join(' ');
+    const additionalContext = [leanEngineeringCompactText(), resourceGuard, active].filter(Boolean).join('\n\n');
     return { continue: true, additionalContext };
 }
-function blockForbiddenClientModel(payload = {}) {
-    const model = forbiddenClientModelFromPayload(payload);
-    if (!model || !isForbiddenCodexModel(model))
-        return null;
-    if (looksLikeCodexUiSettingsEvent(payload))
-        return null;
-    return {
-        decision: 'block',
-        reason: `SKS requires one of [${SUPPORTED_CODEX_MODELS.join(', ')}]; client payload requested ${model}. Switch the Codex client/session model to ${REQUIRED_CODEX_MODEL} (default) or another supported model and retry.`
-    };
-}
 function looksLikeCodexUiSettingsEvent(payload = {}) {
     const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
     const haystack = [
@@ -247,34 +237,6 @@ function looksLikeCodexUiSettingsEvent(payload = {}) {
     ].filter(Boolean).join(' ');
     return !prompt && /\b(?:settings|preferences|profile|speed|fast[_\s-]*mode|reasoning|model[_\s-]*select|codex[_\s-]*app)\b/i.test(haystack);
 }
-function forbiddenClientModelFromPayload(payload = {}) {
-    const candidates = [
-        payload.model,
-        payload.model_id,
-        payload.modelId,
-        payload.client_model,
-        payload.clientModel,
-        ...clientModelCandidates(payload.client),
-        ...clientModelCandidates(payload.metadata),
-        ...clientModelCandidates(payload.context),
-        ...clientModelCandidates(payload.thread),
-        ...clientModelCandidates(payload.session)
-    ];
-    return candidates.find((value) => typeof value === 'string' && isForbiddenCodexModel(value)) || '';
-}
-function clientModelCandidates(value, depth = 0) {
-    if (!value || typeof value !== 'object' || depth > 4)
-        return [];
-    const out = [];
-    for (const key of ['model', 'model_id', 'modelId', 'client_model', 'clientModel']) {
-        if (typeof value[key] === 'string')
-            out.push(value[key]);
-    }
-    for (const key of ['client', 'metadata', 'context', 'thread', 'session']) {
-        out.push(...clientModelCandidates(value[key], depth + 1));
-    }
-    return out;
-}
 async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = null) {
     if (looksLikeCodexGitAction(payload)) {
         await armCodexGitActionStopBypass(root, payload).catch(() => null);
@@ -1111,7 +1073,7 @@ export async function selftestCodexCommitHooks() {
         throw new Error(`selftest failed: metadata-light commit-push stop ${metadataLightStop.code}: ${metadataLightStop.stderr}`);
     if (JSON.parse(metadataLightStop.stdout).decision === 'block')
         throw new Error('selftest failed: metadata-light commit-push stop bypass');
-    const settingsHook = await runHook('user-prompt-submit', { model: 'gpt-5.0-forbidden', metadata: { source: 'codex_app_settings', feature: 'speed profile' } });
+    const settingsHook = await runHook('user-prompt-submit', { model: 'future-codex-catalog-model', metadata: { source: 'codex_app_settings', feature: 'speed profile' } });
     if (settingsHook.code !== 0)
         throw new Error(`selftest failed: settings hook ${settingsHook.code}: ${settingsHook.stderr}`);
     const settingsJson = JSON.parse(settingsHook.stdout);

package/dist/core/image-ux-review/imagegen-adapter.js

@@ -9,7 +9,6 @@ import { withResponsesRetry } from '../responses-retry-policy.js';
 import { discoverCodexAppGeneratedImage } from './codex-app-generated-image-discovery.js';
 import { writeImageArtifactPathContract } from '../image/image-artifact-path-contract.js';
 import { registerImageArtifact } from '../image/image-artifact-registry.js';
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 const DEFAULT_OPENAI_IMAGE_EDITS_ENDPOINT = 'https://api.openai.com/v1/images/edits';
 export function buildCalloutPrompt(sourceScreenId, context = {}) {
     return [
@@ -376,6 +375,22 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                 await writeJsonAtomic(responseArtifact, blocked);
                 return { ok: false, status: 'blocked', generated_image_path: null, output_id: null, blocker: auth.blocker, provider: 'openai_images_api', request_artifact: requestArtifact, response_artifact: responseArtifact, latency_ms: Date.now() - started };
             }
+            if (useResponsesImageTool && !responsesImagegenModel(opts)) {
+                const blocker = 'imagegen_responses_model_missing';
+                await writeJsonAtomic(responseArtifact, {
+                    schema: 'sks.image-ux-gpt-image-2-response.v1',
+                    created_at: nowIso(),
+                    provider: 'openai_responses_image_generation',
+                    evidence_class: 'non_codex_api_fallback',
+                    model: 'gpt-image-2',
+                    ok: false,
+                    status: 'blocked',
+                    blocker,
+                    setup_guidance: 'Set SKS_IMAGEGEN_RESPONSES_MODEL to a model available through the configured Responses provider; SKS does not hardcode a text model.',
+                    local_only: true
+                });
+                return { ok: false, status: 'blocked', generated_image_path: null, output_id: null, blocker, provider: 'openai_responses_image_generation', request_artifact: requestArtifact, response_artifact: responseArtifact, latency_ms: Date.now() - started };
+            }
             try {
                 if (useResponsesImageTool) {
                     const imageDataUrl = `data:${mimeForPath(sourcePath)};base64,${await fsp.readFile(sourcePath, 'base64')}`;
@@ -630,7 +645,7 @@ function responsesEndpoint(baseUrl = '') {
     return /\/responses$/i.test(base) ? base : `${base}/responses`;
 }
 function responsesImagegenModel(opts = {}) {
-    return String(opts.responsesModel || process.env.SKS_IMAGEGEN_RESPONSES_MODEL || process.env.OPENAI_MODEL || REQUIRED_CODEX_MODEL);
+    return String(opts.responsesModel || process.env.SKS_IMAGEGEN_RESPONSES_MODEL || process.env.OPENAI_MODEL || '').trim();
 }
 function imagegenFetchTimeoutMs(opts = {}) {
     const value = Number(opts.fetchTimeoutMs || process.env.SKS_IMAGEGEN_FETCH_TIMEOUT_MS || 90000);

package/dist/core/init/skills.js

@@ -7,7 +7,6 @@ import { syncCoreSkillsIntegrity } from '../codex-native/core-skill-integrity.js
 import { dbSafetyGuardSkillText, madDbSkillText } from '../mad-db/mad-db-policy.js';
 import { SKILL_DREAM_POLICY, skillDreamPolicyText } from '../skill-forge.js';
 import { AWESOME_DESIGN_MD_REFERENCE, CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_EVIDENCE_SOURCE, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, DEFAULT_CODEX_APP_PLUGINS, DESIGN_SYSTEM_SSOT, DOLLAR_COMMANDS, DOLLAR_SKILL_NAMES, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, GETDESIGN_REFERENCE, IMAGEGEN_SOCIAL_SOURCE_POLICY, OPENAI_CHATGPT_IMAGES_2_DOC_URL, OPENAI_GPT_IMAGE_2_MODEL_DOC_URL, OPENAI_IMAGE_GENERATION_DOC_URL, PPT_CONDITIONAL_SKILL_ALLOWLIST, PPT_PIPELINE_MCP_ALLOWLIST, PPT_PIPELINE_SKILL_ALLOWLIST, RECOMMENDED_SKILLS, RESERVED_CODEX_PLUGIN_SKILL_NAMES, SOLUTION_SCOUT_SKILL_NAME, chatCaptureIntakeText, context7ConfigToml, getdesignReferencePolicyText, imageUxReviewPipelinePolicyText, leanEngineeringCompactText, outcomeRubricPolicyText, pptPipelineAllowlistPolicyText, productDesignPluginPolicyText, solutionScoutPolicyText, speedLanePolicyText, stackCurrentDocsPolicyText, triwikiContextTrackingText, triwikiStagePolicyText } from '../routes.js';
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 const SKS_SKILL_MANIFEST_FILE = '.sks-generated.json';
 const PACKAGED_SKILLS_MANIFEST_SCHEMA = 'sks.skills-manifest.v1';
 const GENERATED_PRUNE_POLICY = 'remove_previous_sks_generated_paths_absent_from_current_manifest';
@@ -543,12 +542,12 @@ async function removeDirIfEmpty(dir) {
 }
 export async function installCodexAgents(root) {
     const agents = {
-        'analysis-scout.toml': `name = "analysis_scout"\ndescription = "SKS analysis scout with bounded write capability retained for stale Codex agent-role config repair."\nmodel = "${REQUIRED_CODEX_MODEL}"\nmodel_reasoning_effort = "low"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS analysis scout.\nOnly edit bounded files assigned by the parent orchestrator; otherwise inspect only and return concise source-backed findings.\n"""\n`,
-        'native-agent-intake.toml': `name = "native_agent"\ndescription = "Team native agent with bounded write capability. Maps one independent repo/docs/tests/API/risk/user-friction slice and can produce patch-envelope work when assigned."\nmodel = "${REQUIRED_CODEX_MODEL}"\nmodel_reasoning_effort = "low"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team native agent.\nOnly edit bounded files assigned by the parent orchestrator.\nOwn exactly one investigation or implementation slice assigned by the parent orchestrator.\nUse the mission roster or worker inbox model and model_reasoning_effort when the host exposes it: simple bounded work may use gpt-5.4-mini, ordinary tool work uses ${REQUIRED_CODEX_MODEL} low, and knowledge/research/safety/release work uses ${REQUIRED_CODEX_MODEL} high.\nMap relevant source files, docs, tests, APIs, DB or safety risks, UX friction, and likely implementation boundaries.\nReturn concise source-backed claims suitable for team-analysis.md and TriWiki ingestion: claim, source path, evidence hash or quoted anchor, risk, confidence, and recommended implementation slice.\nDo not debate the final plan. Implement only when the assigned slice includes write paths.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
-        'team-consensus.toml': `name = "team_consensus"\ndescription = "Planning and debate specialist for SKS Team mode with bounded write capability. Maps options, constraints, role-persona risks, and proposes the agreed objective before implementation starts."\nmodel = "${REQUIRED_CODEX_MODEL}"\nmodel_reasoning_effort = "high"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are the SKS Team consensus specialist.\nOnly edit bounded files assigned by the parent orchestrator.\nUse the mission roster model and model_reasoning_effort when the host exposes them; planning normally uses ${REQUIRED_CODEX_MODEL} low or high depending on risk.\nMap the affected code paths, viable approaches, constraints, risks, and acceptance criteria.\nRun the debate as role-persona synthesis: final users are low-context, self-interested, stubborn, and inconvenience-averse; executors are capable developers; reviewers are strict.\nArgue for the smallest coherent objective that can be handed to a fresh executor_N development team.\nPlan for at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final.\nReturn: recommended objective, rejected alternatives, implementation slices, required reviewers, user-friction risks, and unresolved risks.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
-        'implementation-worker.toml': `name = "implementation_worker"\ndescription = "Implementation specialist for SKS Team mode. Owns one bounded write set and coordinates with other executor_N workers."\nmodel = "${REQUIRED_CODEX_MODEL}"\nmodel_reasoning_effort = "medium"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team executor/developer in the fresh development bundle.\nYou are not alone in the codebase. Other executor_N workers may be editing disjoint files.\nUse the mission roster or worker inbox reasoning_effort when the host exposes it; simple bounded changes can use low, tool-heavy implementation medium, and safety/release/DB work high.\nOnly edit the files or module slice assigned to you.\nDo not revert or overwrite edits made by others.\nRead local patterns first, make the smallest correct change, avoid adding user friction, run focused verification for your slice, and report changed paths plus evidence.\nDo not create fallback implementation code, substitute behavior, mock behavior, or compatibility shims unless the user or sealed decision contract explicitly requested them.\nRespect all SKS hooks, DB safety rules, no-question run rules, and H-Proof completion gates.\nAlso return concise LIVE_EVENT lines for started, blocked, changed files, verification, and final result so the parent can record them.\n"""\n`,
-        'db-safety-reviewer.toml': `name = "db_safety_reviewer"\ndescription = "Database safety reviewer with bounded write capability for SQL, migrations, Supabase, RLS, destructive-operation risk, and rollback safety."\nmodel = "${REQUIRED_CODEX_MODEL}"\nmodel_reasoning_effort = "high"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are a database safety reviewer.\nOnly edit bounded files assigned by the parent orchestrator. Never execute destructive commands.\nReview migrations, SQL, Supabase RLS, transaction boundaries, rollback safety, and MCP database tool usage.\nBlock DROP, TRUNCATE, mass DELETE/UPDATE, db reset, db push, project deletion, branch reset/merge/delete, RLS disabling, and live execute_sql writes.\nReturn concrete risks, exact file references, and required fixes.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
-        'qa-reviewer.toml': `name = "qa_reviewer"\ndescription = "Strict verification reviewer with bounded write capability for correctness, regressions, missing tests, user friction, and final evidence."\nmodel = "${REQUIRED_CODEX_MODEL}"\nmodel_reasoning_effort = "high"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team strict reviewer.\nOnly edit bounded files assigned by the parent orchestrator.\nReview correctness, edge cases, regression risk, missing tests, unsupported claims, and whether the final evidence proves the claimed outcome.\nTeam review must cover at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final; flag missing review lane evidence.\nAlso evaluate practical friction from the viewpoint of a stubborn, low-context final user who dislikes inconvenience.\nPrioritize concrete findings with file references and focused verification suggestions.\nFlag any unrequested fallback implementation code, substitute behavior, mock behavior, or compatibility shim as a blocking finding unless the user or sealed decision contract explicitly requested it.\nReturn no findings if the implementation is sound, and clearly list residual test gaps.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`
+        'analysis-scout.toml': `name = "analysis_scout"\ndescription = "SKS analysis scout with bounded write capability retained for stale Codex agent-role config repair."\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS analysis scout.\nInherit the model and reasoning level selected by Codex; never replace or constrain its model catalog.\nOnly edit bounded files assigned by the parent orchestrator; otherwise inspect only and return concise source-backed findings.\n"""\n`,
+        'native-agent-intake.toml': `name = "native_agent"\ndescription = "Team native agent with bounded write capability. Maps one independent repo/docs/tests/API/risk/user-friction slice and can produce patch-envelope work when assigned."\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team native agent.\nInherit the model and reasoning level selected by Codex; never replace or constrain its model catalog.\nOnly edit bounded files assigned by the parent orchestrator.\nOwn exactly one investigation or implementation slice assigned by the parent orchestrator.\nUse a capability-advertised reasoning level when the runtime supplies a per-task override; otherwise keep the current Codex selection.\nMap relevant source files, docs, tests, APIs, DB or safety risks, UX friction, and likely implementation boundaries.\nReturn concise source-backed claims suitable for team-analysis.md and TriWiki ingestion: claim, source path, evidence hash or quoted anchor, risk, confidence, and recommended implementation slice.\nDo not debate the final plan. Implement only when the assigned slice includes write paths.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
+        'team-consensus.toml': `name = "team_consensus"\ndescription = "Planning and debate specialist for SKS Team mode with bounded write capability. Maps options, constraints, role-persona risks, and proposes the agreed objective before implementation starts."\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are the SKS Team consensus specialist.\nInherit the model and reasoning level selected by Codex; never replace or constrain its model catalog.\nOnly edit bounded files assigned by the parent orchestrator.\nUse a capability-advertised reasoning level when the runtime supplies a per-task override; otherwise keep the current Codex selection.\nMap the affected code paths, viable approaches, constraints, risks, and acceptance criteria.\nRun the debate as role-persona synthesis: final users are low-context, self-interested, stubborn, and inconvenience-averse; executors are capable developers; reviewers are strict.\nArgue for the smallest coherent objective that can be handed to a fresh executor_N development team.\nPlan for at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final.\nReturn: recommended objective, rejected alternatives, implementation slices, required reviewers, user-friction risks, and unresolved risks.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
+        'implementation-worker.toml': `name = "implementation_worker"\ndescription = "Implementation specialist for SKS Team mode. Owns one bounded write set and coordinates with other executor_N workers."\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team executor/developer in the fresh development bundle.\nInherit the model and reasoning level selected by Codex; never replace or constrain its model catalog.\nYou are not alone in the codebase. Other executor_N workers may be editing disjoint files.\nUse a capability-advertised reasoning level when the runtime supplies a per-task override; otherwise keep the current Codex selection.\nOnly edit the files or module slice assigned to you.\nDo not revert or overwrite edits made by others.\nRead local patterns first, make the smallest correct change, avoid adding user friction, run focused verification for your slice, and report changed paths plus evidence.\nDo not create fallback implementation code, substitute behavior, mock behavior, or compatibility shims unless the user or sealed decision contract explicitly requested them.\nRespect all SKS hooks, DB safety rules, no-question run rules, and H-Proof completion gates.\nAlso return concise LIVE_EVENT lines for started, blocked, changed files, verification, and final result so the parent can record them.\n"""\n`,
+        'db-safety-reviewer.toml': `name = "db_safety_reviewer"\ndescription = "Database safety reviewer with bounded write capability for SQL, migrations, Supabase, RLS, destructive-operation risk, and rollback safety."\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are a database safety reviewer.\nInherit the model and reasoning level selected by Codex; never replace or constrain its model catalog.\nOnly edit bounded files assigned by the parent orchestrator. Never execute destructive commands.\nReview migrations, SQL, Supabase RLS, transaction boundaries, rollback safety, and MCP database tool usage.\nBlock DROP, TRUNCATE, mass DELETE/UPDATE, db reset, db push, project deletion, branch reset/merge/delete, RLS disabling, and live execute_sql writes.\nReturn concrete risks, exact file references, and required fixes.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
+        'qa-reviewer.toml': `name = "qa_reviewer"\ndescription = "Strict verification reviewer with bounded write capability for correctness, regressions, missing tests, user friction, and final evidence."\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team strict reviewer.\nInherit the model and reasoning level selected by Codex; never replace or constrain its model catalog.\nOnly edit bounded files assigned by the parent orchestrator.\nReview correctness, edge cases, regression risk, missing tests, unsupported claims, and whether the final evidence proves the claimed outcome.\nTeam review must cover at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final; flag missing review lane evidence.\nAlso evaluate practical friction from the viewpoint of a stubborn, low-context final user who dislikes inconvenience.\nPrioritize concrete findings with file references and focused verification suggestions.\nFlag any unrequested fallback implementation code, substitute behavior, mock behavior, or compatibility shim as a blocking finding unless the user or sealed decision contract explicitly requested it.\nReturn no findings if the implementation is sound, and clearly list residual test gaps.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`
     };
     const dir = path.join(root, '.codex', 'agents');
     await ensureDir(dir);

package/dist/core/init.js

@@ -2,7 +2,6 @@ import path from 'node:path';
 import fsp from 'node:fs/promises';
 import { ensureDir, readJson, readText, writeJsonAtomic, writeTextAtomic, mergeManagedBlock, nowIso, PACKAGE_VERSION, exists } from './fsx.js';
 import { DEFAULT_RETENTION_POLICY } from './retention.js';
-import { REQUIRED_CODEX_MODEL } from './codex-model-guard.js';
 import { DEFAULT_DB_SAFETY_POLICY } from './db-safety.js';
 import { isHarnessSourceProject, writeHarnessGuardPolicy } from './harness-guard.js';
 import { repairSksGeneratedArtifacts } from './harness-conflicts.js';
@@ -548,7 +547,7 @@ export async function initProject(root, opts = {}) {
                 block_other_codex_harnesses: true,
                 hard_blockers: ['OMX', 'DCodex'],
                 cleanup_prompt_command: `${commandPrefix} conflicts prompt`,
-                cleanup_model: REQUIRED_CODEX_MODEL,
+                cleanup_model_policy: 'inherit_codex_selection',
                 cleanup_reasoning_effort: 'high',
                 human_approval_required: true
             },
@@ -583,12 +582,9 @@ export async function initProject(root, opts = {}) {
         'tool_suggest', 'plugins', 'codex_hooks'
     ];
     function mergeManagedCodexConfigToml(existingContent = '') {
-        let next = removeLegacyTopLevelCodexModeLocks(String(existingContent || '').trimEnd());
+        let next = String(existingContent || '').trimEnd();
         next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
         next = removeTomlTableKey(next, 'features', 'codex_hooks');
-        // The current Codex config sample uses the canonical top-level model alias.
-        // Set it only when absent so user-selected models are preserved.
-        next = upsertTopLevelTomlStringIfAbsent(next, 'model', REQUIRED_CODEX_MODEL);
         next = upsertTopLevelTomlBooleanIfAbsent(next, 'suppress_unstable_features_warning', true);
         // Codex App feature flags: SET-IF-ABSENT only (see note above); flags the
         // 2026-07 renewal removed from the schema are stripped.
@@ -600,7 +596,10 @@ export async function initProject(root, opts = {}) {
         }
         next = removeWholeTomlTable(next, 'user.fast_mode');
         next = removeWholeTomlTable(next, 'profiles.sks-fast-high');
-        next = upsertTomlTableKeyIfAbsent(next, 'agents', 'max_threads = 6');
+        if (process.env.SKS_ALLOW_HIGH_AGENT_CONCURRENCY !== '1') {
+            next = upsertTomlTableKey(next, 'agents', 'max_threads = 4');
+        }
+        next = removeWholeTomlTable(next, 'features.multi_agent_v2');
         next = upsertTomlTableKeyIfAbsent(next, 'agents', 'max_depth = 1');
         for (const block of managedCodexConfigBlocks()) {
             if (block.preserveExisting === true && hasTomlTable(next, block.table))
@@ -711,16 +710,6 @@ export async function initProject(root, opts = {}) {
         }
         return lines.filter((_, index) => index < start || index >= end).join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n');
     }
-    function removeLegacyTopLevelCodexModeLocks(text = '') {
-        const lines = String(text || '').split('\n');
-        const firstTable = lines.findIndex((x) => /^\s*\[.+\]\s*$/.test(x));
-        const end = firstTable === -1 ? lines.length : firstTable;
-        return lines.filter((line, index) => {
-            if (index >= end)
-                return true;
-            return !/^\s*(?:model|model_reasoning_effort)\s*=/.test(line);
-        }).join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n');
-    }
     function removeTopLevelTomlKeyIfValue(text = '', key = '', value = '') {
         const lines = String(text || '').split('\n');
         const firstTable = lines.findIndex((x) => /^\s*\[.+\]\s*$/.test(x));
@@ -766,9 +755,6 @@ export async function initProject(root, opts = {}) {
                 return true;
         return false;
     }
-    function upsertTopLevelTomlStringIfAbsent(text, key, value) {
-        return hasTopLevelTomlKey(text, key) ? String(text || '') : upsertTopLevelTomlString(text, key, value);
-    }
     function upsertTopLevelTomlBooleanIfAbsent(text, key, value) {
         return hasTopLevelTomlKey(text, key) ? String(text || '') : upsertTopLevelTomlBoolean(text, key, value);
     }

package/dist/core/loops/loop-concurrency-budget.js

@@ -8,13 +8,15 @@ export function computeLoopConcurrencyBudget(input) {
         ? 'codex-0140-usage'
         : 'sks-local-estimate';
     const cores = Math.max(1, os.cpus().length || 1);
-    const requestedLoops = input.parallelism === 'safe' ? 2 : input.parallelism === 'extreme' ? Math.min(16, cores) : Math.min(8, cores);
+    const requestedLoops = input.parallelism === 'safe' ? 1 : input.parallelism === 'extreme' ? Math.min(4, cores) : Math.min(2, cores);
     const envLoops = positiveInt(env.SKS_LOOP_MAX_ACTIVE_LOOPS);
     const envWorkers = positiveInt(env.SKS_LOOP_MAX_ACTIVE_WORKERS);
     const envModelCalls = positiveInt(env.SKS_LOOP_MAX_MODEL_CALLS);
-    const maxActiveLoops = envLoops || requestedLoops;
-    const maxActiveWorkers = envWorkers || (input.parallelism === 'safe' ? Math.min(8, cores) : input.parallelism === 'extreme' ? Math.min(32, Math.max(4, cores * 2)) : Math.min(16, Math.max(4, cores)));
-    const maxModelCalls = envModelCalls || Math.max(1, Math.min(maxActiveWorkers, input.plan.global_budget.max_model_calls || maxActiveWorkers));
+    const maxActiveLoops = Math.min(requestedLoops, envLoops || requestedLoops);
+    const requestedWorkers = input.parallelism === 'safe' ? Math.min(2, cores) : input.parallelism === 'extreme' ? Math.min(4, cores) : Math.min(3, cores);
+    const maxActiveWorkers = Math.min(requestedWorkers, envWorkers || requestedWorkers);
+    const requestedModelCalls = Math.max(1, Math.min(maxActiveWorkers, input.plan.global_budget.max_model_calls || maxActiveWorkers));
+    const maxModelCalls = Math.min(requestedModelCalls, envModelCalls || requestedModelCalls);
     let remainingWorkers = maxActiveWorkers;
     let remainingModelCalls = maxModelCalls;
     const perLoop = input.plan.graph.nodes.map((node) => {

package/dist/core/loops/loop-planner.js

@@ -7,7 +7,7 @@ import { classifyLoopRisk } from './loop-risk-classifier.js';
 import { defaultLoopBudget, validateLoopPlan } from './loop-schema.js';
 import { readInitDeepMemory, readInitDeepMemoryHints } from '../codex-app/codex-init-deep.js';
 export async function planLoopsFromRequest(input) {
-    const parallelism = input.parallelism || 'balanced';
+    const parallelism = input.parallelism || 'safe';
     const maxLoops = Math.max(1, Math.min(32, input.maxLoops || 8));
     const allDomains = decomposeRequestIntoLoopDomains(input.request);
     const domains = allDomains.slice(0, maxLoops);

package/dist/core/loops/loop-runtime.js

@@ -12,9 +12,9 @@ import { runLoopCheckerWorkers, runLoopMakerWorkers } from './loop-worker-runtim
 import { allocateLoopWorktree, computeLoopDiff } from './loop-worktree-runtime.js';
 export async function runLoopPlan(input) {
     const started = Date.now();
-    const concurrencyBudget = computeLoopConcurrencyBudget({ plan: input.plan, parallelism: input.parallelism || 'balanced' });
+    const concurrencyBudget = computeLoopConcurrencyBudget({ plan: input.plan, parallelism: input.parallelism || 'safe' });
     await writeLoopConcurrencyBudget(input.root, concurrencyBudget);
-    const schedule = scheduleLoopGraph(input.plan.graph.nodes, input.parallelism || 'balanced', concurrencyBudget);
+    const schedule = scheduleLoopGraph(input.plan.graph.nodes, input.parallelism || 'safe', concurrencyBudget);
     const proofs = [];
     for (const batch of schedule.batches) {
         if (await shouldKillLoop(input.root, input.plan.mission_id, 'all'))

package/dist/core/loops/loop-scheduler.js

@@ -1,5 +1,5 @@
 import os from 'node:os';
-export function scheduleLoopGraph(nodes, parallelism = 'balanced', budget) {
+export function scheduleLoopGraph(nodes, parallelism = 'safe', budget) {
     const pending = new Map(nodes.map((node) => [node.loop_id, node]));
     const completed = new Set();
     const batches = [];
@@ -23,21 +23,21 @@ export function scheduleLoopGraph(nodes, parallelism = 'balanced', budget) {
     }
     return { ok: blockers.length === 0, batches, max_active_loops: Math.max(0, ...batches.map((batch) => batch.length)), blockers };
 }
-export function maxConcurrentLoops(nodes, parallelism = 'balanced') {
+export function maxConcurrentLoops(nodes, parallelism = 'safe') {
     const cores = Math.max(1, os.cpus().length || 1);
-    const base = parallelism === 'safe' ? 2 : parallelism === 'extreme' ? Math.min(16, cores) : Math.min(8, cores);
+    const base = parallelism === 'safe' ? 1 : parallelism === 'extreme' ? Math.min(4, cores) : Math.min(2, cores);
     return Math.max(1, Math.min(base, riskAwareLoopCap(nodes, parallelism, cores)));
 }
 function riskAwareLoopCap(nodes, parallelism, cores) {
     if (parallelism === 'extreme')
-        return Math.min(16, cores);
+        return Math.min(4, cores);
     const hasCritical = nodes.some((node) => node.risk.level === 'critical');
     const hasHigh = nodes.some((node) => node.risk.level === 'high');
     if (hasCritical)
-        return parallelism === 'safe' ? 1 : Math.max(2, Math.floor(cores / 4));
+        return 1;
     if (hasHigh)
-        return parallelism === 'safe' ? 2 : Math.max(4, Math.floor(cores / 2));
-    return parallelism === 'safe' ? 2 : Math.min(8, cores);
+        return parallelism === 'safe' ? 1 : Math.min(2, cores);
+    return parallelism === 'safe' ? 1 : parallelism === 'balanced' ? Math.min(2, cores) : Math.min(4, cores);
 }
 export function graphProofFromLoopProofs(input) {
     const selected = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.selected_gates))];

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -1,4 +1,3 @@
-import { REQUIRED_CODEX_MODEL, DEFAULT_CODEX_REASONING_EFFORT } from '../codex-model-guard.js';
 export const MANAGED_ASSET_SCHEMA_VERSION = 1;
 export const MANAGED_ASSET_VERSION = '4.8.1';
 export const MANAGED_ASSET_MARKER = 'SKS-MANAGED-ASSET';
@@ -63,8 +62,6 @@ export function managedAgentRoleContent(role) {
         `# sks_managed_version = "${MANAGED_ASSET_VERSION}"`,
         `name = "${role.codex_name}"`,
         `description = "${role.description}"`,
-        `model = "${REQUIRED_CODEX_MODEL}"`,
-        `model_reasoning_effort = "${DEFAULT_CODEX_REASONING_EFFORT}"`,
         `sandbox_mode = "${role.sandbox}"`,
         `permission_profile = "${role.permission_profile}"`,
         `legacy_sandbox_projection = "${role.legacy_sandbox_projection}"`,
@@ -83,7 +80,7 @@ export function managedAgentRoleOwnsText(text, role) {
         && text.includes(`sandbox_mode = "${role.sandbox}"`);
     const legacyCompatible = text.includes(`name = "${role.codex_name}"`)
         && text.includes(`sandbox_mode = "${role.sandbox}"`)
-        && text.includes(`model = "${REQUIRED_CODEX_MODEL}"`);
+        && text.includes('developer_instructions = """');
     return hasManagedMarker || legacyCompatible;
 }
 export function normalizeRoleName(name) {