sneakoscope 6.1.0 → 6.2.0

package/dist/core/agents/agent-effort-policy.js

@@ -1,6 +1,7 @@
 import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
 import { GLM_52_OPENROUTER_MODEL } from '../providers/glm/glm-52-settings.js';
-import { isNarutoGpt56Model, routeNarutoGpt56Model } from '../provider/model-router.js';
+import { isNarutoGpt56Model } from '../provider/model-router.js';
+import { decideSubagentModel } from '../subagents/model-policy.js';
 const XHIGH_SIGNAL_RE = /(frontier|autoresearch|novelty|hypothesis|falsif|forensic|from-chat-img|image\s*work\s*order|새로운\s*연구|가설|포렌식)/i;
 const HIGH_SIGNAL_RE = /(database|supabase|sql|migration|security|permission|mad|release|publish|deploy|architecture|policy|schema|hook|rollback|db|보안|배포|마이그레이션|데이터베이스|권한|릴리즈)/i;
 const MEDIUM_SIGNAL_RE = /(tmux|terminal|cli|tool(?:\s|-)?call|router|routing|orchestrat|pipeline|multi[-\s]?session|multi[-\s]?agent|lease|ledger|proof|검증|파이프라인|오케스트레이션|병렬|에이전트)/i;
@@ -61,21 +62,31 @@ export function decideAgentEffort(input = {}) {
         ]
     };
 }
-// $Naruto workers use the codex-lb GPT-5.6 family only. Model and effort are
-// selected by the actual work kind; the removed low/medium cap must never be
-// reintroduced through tool-count or read-only heuristics.
-export function decideNarutoCloneEffort(input = {}) {
+// Official Codex subagents use one of four fixed profiles: Luna Max for tiny
+// mechanical work, Sol High for ordinary implementation, Sol Max for
+// judgment, and Terra Medium for long-context or Codex-tool execution.
+export function decideOfficialSubagentModel(input = {}) {
     const persona = input.persona || {};
     const prompt = String(input.prompt || '');
     const role = String(persona.role || '');
-    const agentId = String(input.agentId || persona.id || 'naruto_clone');
-    const taskText = [role, agentId, persona.naruto_role].join(' ');
-    const riskText = [prompt, persona.risk_focus, persona.write_policy].join(' ');
-    const routed = routeNarutoGpt56Model({ taskText, riskText });
-    const effort = routed.reasoning;
+    const agentId = String(input.agentId || persona.id || 'subagent');
+    const routingRole = [agentId, persona.naruto_role, persona.work_kind, role].filter(Boolean).join(' ');
+    const taskClass = /(?:implementation_specialist|ui_implementer|native_app_specialist)/i.test(routingRole)
+        ? 'implementation'
+        : /(?:explorer|docs_maintainer|long_context_analyst|computer_use_operator|browser_use_operator|image_generation_operator)/i.test(routingRole)
+            ? 'context_tools'
+            : undefined;
+    const routed = decideSubagentModel({
+        title: routingRole,
+        description: [prompt, persona.risk_focus, persona.write_policy].filter(Boolean).join(' '),
+        role,
+        expectedOutput: (persona.output_expectations || []).join(' '),
+        ...(taskClass ? { taskClass } : {})
+    });
+    const effort = routed.modelReasoningEffort;
     const modelCapability = codexModelEffortCapability({
         model: routed.model,
-        advertisedEfforts: narutoAdvertisedEfforts(routed.model),
+        advertisedEfforts: [effort],
         defaultEffort: effort
     });
     return {
@@ -87,24 +98,27 @@ export function decideNarutoCloneEffort(input = {}) {
         reasoning_effort: effort,
         model_reasoning_effort: effort,
         model_tier: `${routed.model}-${effort}`,
-        model_profile: `sks-naruto-${safeProfileSegment(routed.model)}-${effort}-fast`,
-        model_selection_reason: narutoSelectionReason(routed.model, effort),
+        model_profile: `sks-official-subagent-${safeProfileSegment(routed.model)}-${effort}-fast`,
+        model_selection_reason: routed.reason,
         model_effort_capability: modelCapability,
         reasoning_profile: reasoningProfileName(effort),
         service_tier: 'fast',
-        reason: narutoSelectionReason(routed.model, effort),
+        reason: routed.reason,
         dynamic: true,
         escalation_triggers: [
-            'complex or high-risk Terra work escalates from xhigh to max',
-            'complex E2E, browser, Computer Use, or forensic Luna verification escalates from xhigh to max',
-            'refactoring, architecture, planning, strategy, and integration select Sol at max'
+            'review, debugging, planning, architecture, integration, security, database, research, release, or ambiguity selects Sol Max',
+            'mixed tool-and-judgment work is split; an unsplittable slice selects Sol Max',
+            'requested model/effort profile unavailable blocks instead of silently falling back'
         ],
         downshift_triggers: [
-            'ordinary coding stays on Terra xhigh',
-            'ordinary E2E, browser, Computer Use, and GUI verification stays on Luna xhigh'
+            'ordinary UI, logic, backend, or native implementation selects Sol High',
+            'long-context, Browser/Chrome, Computer Use, or image-generation execution selects Terra Medium',
+            'tiny short-context mechanical work selects Luna Max'
         ]
     };
 }
+/** @deprecated since 6.1.1. Use decideOfficialSubagentModel. */
+export const decideNarutoCloneEffort = decideOfficialSubagentModel;
 export function buildAgentEffortPolicy(roster = {}) {
     const decisions = Array.isArray(roster.roster) ? roster.roster.map((agent) => ({
         agent_id: agent.id,
@@ -126,19 +140,20 @@ export function buildAgentEffortPolicy(roster = {}) {
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        model_catalog_policy: narutoFamilyOnly ? 'naruto_gpt_5_6_family_dynamic' : 'codex_catalog_passthrough',
+        model_catalog_policy: narutoFamilyOnly ? 'official_subagent_four_profile_matrix' : 'codex_catalog_passthrough',
         model_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'] : null,
+        explicit_compatibility_models: null,
         model_tiers: narutoFamilyOnly
-            ? ['gpt-5.6-luna-xhigh', 'gpt-5.6-luna-max', 'gpt-5.6-terra-xhigh', 'gpt-5.6-terra-max', 'gpt-5.6-sol-max']
+            ? ['gpt-5.6-luna-max', 'gpt-5.6-sol-high', 'gpt-5.6-sol-max', 'gpt-5.6-terra-medium']
             : ['codex-selected-low', 'codex-selected-medium', 'codex-selected-high', 'codex-selected-xhigh', 'glm-5.2-minimal', 'glm-5.2-low', 'glm-5.2-high', 'glm-5.2-xhigh'],
-        allowed_efforts: narutoFamilyOnly ? ['xhigh', 'max'] : codexModelEffortCapability().advertised_efforts,
+        allowed_efforts: narutoFamilyOnly ? ['medium', 'high', 'max'] : codexModelEffortCapability().advertised_efforts,
         model_effort_capability: codexModelEffortCapability(),
         max_agents: roster.max_agents || 20,
         agent_count: roster.agent_count || decisions.length,
         concurrency: roster.concurrency || decisions.length,
         decisions,
         rule: narutoFamilyOnly
-            ? 'Naruto workers use only GPT-5.6 Luna/Terra/Sol: Terra xhigh/max for coding, Sol max for refactoring/planning/strategy/integration, and Luna xhigh/max for E2E/browser/Computer Use/GUI verification.'
+            ? 'Official Naruto subagents use GPT-5.6 Luna Max only for tiny short-context mechanical work, GPT-5.6 Sol High for ordinary implementation, GPT-5.6 Sol Max for judgment-heavy work, and GPT-5.6 Terra Medium for long-context or Browser/Chrome, Computer Use, and image-generation execution. Judgment wins when one slice cannot be safely split.'
             : 'Codex/OpenAI workers inherit the current Codex-selected model, including future catalog entries; SKS changes only advertised reasoning effort. Explicit non-Codex provider modes retain their provider model.'
     };
 }
@@ -165,18 +180,6 @@ function effortReason(effort) {
         return 'simple_bounded_slice';
     return 'default_orchestration_slice';
 }
-function narutoAdvertisedEfforts(model) {
-    return model === 'gpt-5.6-luna'
-        ? ['low', 'medium', 'high', 'xhigh', 'max']
-        : ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
-}
-function narutoSelectionReason(model, effort) {
-    if (model === 'gpt-5.6-sol')
-        return `naruto_refactor_plan_strategy_sol_${effort}`;
-    if (model === 'gpt-5.6-luna')
-        return `naruto_e2e_browser_computer_use_luna_${effort}`;
-    return `naruto_coding_terra_${effort}`;
-}
 export function decideAgentWorkerModel(input = {}) {
     const mainModel = String(input.mainModel || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
     const glmMain = isGlmWorkerMode(mainModel);

package/dist/core/agents/agent-plan.js

@@ -1,44 +1,123 @@
-import { AGENT_INTAKE_STAGE_ID, DEFAULT_AGENT_COUNT } from './agent-schema.js';
-const AGENT_REQUIRED_ROUTE_KEYS = new Set([
-    'team', '$team', 'naruto', '$naruto', 'shadowclone', '$shadowclone', 'shadow-clone', '$shadow-clone', 'kagebunshin', '$kagebunshin', 'kage-bunshin', '$kage-bunshin',
-    'research', '$research', 'autoresearch', '$autoresearch', 'qa-loop', '$qa-loop', 'review', '$review', 'release-review', '$release-review'
+import { AGENT_INTAKE_STAGE_ID } from './agent-schema.js';
+import { classifyTaskProfile, isTaskProfile } from '../runtime/task-profile.js';
+import { DEFAULT_NARUTO_MAX_THREADS, DEFAULT_NARUTO_REQUESTED_SUBAGENTS, resolveSubagentThreadBudget } from '../subagents/thread-budget.js';
+const OFFICIAL_SUBAGENT_ROUTE_KEYS = new Set([
+    'team', '$team',
+    'naruto', '$naruto',
+    'shadowclone', '$shadowclone',
+    'shadow-clone', '$shadow-clone',
+    'kagebunshin', '$kagebunshin',
+    'kage-bunshin', '$kage-bunshin',
+    'swarm', '$swarm',
+    'work', '$work'
 ]);
+const EXPLICIT_SUBAGENT_RE = /\$(Team|Naruto|ShadowClone|Shadow-Clone|Kagebunshin|Kage-Bunshin|Swarm|Work)\b/i;
+const PARALLELIZABLE_RE = /\b(parallel|subagents?|fan out|one agent per|independent|disjoint|multiple files|all files)\b|병렬|하위\s*에이전트|서브\s*에이전트|독립|분리된|여러\s*파일|모든\s*파일|분담/i;
 function routeKey(route) {
     return String(route?.id || route?.command || route?.name || route || '').trim().toLowerCase();
 }
 export function routeRequiresAgentIntake(route, input = {}) {
-    if (input.noAgents === true || input.agents === false)
+    const options = normalizeOptions(input);
+    if (options.noAgents === true || options.agents === false)
         return false;
-    if (input.force === true || input.forceAgents === true)
+    if (options.force === true || options.forceAgents === true)
         return true;
-    const key = routeKey(route);
-    if (AGENT_REQUIRED_ROUTE_KEYS.has(key))
+    const task = String(options.task || '');
+    const officialRouteWasImplicit = Boolean(route
+        && typeof route === 'object'
+        && !Array.isArray(route)
+        && route.explicit_invocation === false);
+    if ((OFFICIAL_SUBAGENT_ROUTE_KEYS.has(routeKey(route)) && !officialRouteWasImplicit) || EXPLICIT_SUBAGENT_RE.test(task))
         return true;
-    const task = String(input.task || '');
-    return /\$(Team|Naruto|ShadowClone|Kagebunshin|Research|AutoResearch|QA-LOOP|Review|Release-Review)\b/i.test(task);
+    if (positiveNumber(options.requestedSubagents) || positiveNumber(options.agents))
+        return true;
+    const profile = taskProfile(options.taskProfile, task);
+    if (profile === 'parallel-read' || profile === 'parallel-write')
+        return true;
+    return profile === 'high-risk' && explicitlyParallelizable(task);
 }
 export function normalizeAgentPolicy(route, task = '', input = {}) {
-    const required = routeRequiresAgentIntake(route, { task, ...(typeof input === 'object' && input ? input : {}) });
+    const options = normalizeOptions(input);
+    const profile = taskProfile(options.taskProfile, String(task || ''));
+    const required = routeRequiresAgentIntake(route, { ...options, task, taskProfile: profile });
+    const requested = firstPositiveNumber(options.requestedSubagents, options.agents, options.independentSliceCount);
+    const budget = resolveSubagentThreadBudget({
+        ...(requested === null ? {} : { requested }),
+        ...(positiveNumber(options.maxThreads) ? { configuredMaxThreads: Number(options.maxThreads) } : {}),
+        ...(positiveNumber(options.independentSliceCount) ? { independentSliceCount: Number(options.independentSliceCount) } : {})
+    });
+    const requestedSubagents = required ? budget.requestedSubagents : 0;
     return {
-        schema: 'sks.agent-intake-policy.v1',
+        schema: 'sks.subagent-intake-policy.v1',
         required,
+        subagents_required: required,
+        task_profile: profile,
         stage_id: AGENT_INTAKE_STAGE_ID,
-        agent_count: required ? DEFAULT_AGENT_COUNT : 0,
-        backend: 'native-agent-kernel',
-        outputs: ['agents/agent-proof-evidence.json', 'agents/agent-sessions.json', 'agents/agent-leases.json', 'agents/agent-consensus.json']
+        workflow: 'official_codex_subagent',
+        requested_subagents: requestedSubagents,
+        max_threads: budget.maxThreads,
+        max_depth: budget.maxDepth,
+        first_wave: required ? budget.firstWave : 0,
+        wave_count: required ? budget.waveCount : 0,
+        agent_count: requestedSubagents,
+        backend: 'official-codex-subagent',
+        reason: policyReason(route, task, profile, required),
+        outputs: ['subagent-plan.json', 'subagent-events.jsonl', 'subagent-parent-summary.json', 'subagent-evidence.json'],
+        deprecated_fields: ['agent_count']
     };
 }
 export function agentPipelineStage(policy = {}) {
     const required = policy.required !== false;
+    const requestedSubagents = required
+        ? Math.max(1, Math.floor(Number(policy.requested_subagents || policy.agent_count || DEFAULT_NARUTO_REQUESTED_SUBAGENTS)))
+        : 0;
+    const maxThreads = required
+        ? Math.max(1, Math.floor(Number(policy.max_threads || DEFAULT_NARUTO_MAX_THREADS)))
+        : 0;
     return {
         id: AGENT_INTAKE_STAGE_ID,
-        goal: 'Run native multi-session agent intake with non-overlapping leases and proof evidence.',
-        agent_count: required ? Number(policy.agent_count || DEFAULT_AGENT_COUNT) : 0,
-        max_parallel_native_sessions: Number(policy.agent_count || DEFAULT_AGENT_COUNT),
-        backend: 'native-agent-kernel',
+        goal: 'Run a Codex official subagent workflow with disjoint ownership and correlated event evidence.',
+        workflow: 'official_codex_subagent',
+        requested_subagents: requestedSubagents,
+        max_parallel_agent_threads: Math.min(requestedSubagents, maxThreads),
+        max_threads: maxThreads,
+        max_depth: 1,
+        agent_count: requestedSubagents,
+        backend: 'official-codex-subagent',
         read_only: false,
-        write_policy: 'bounded workspace-write analysis leases; parent-owned integration',
-        outputs: policy.outputs || ['agents/agent-proof-evidence.json']
+        write_policy: 'bounded workspace-write with disjoint path leases; parent-owned integration',
+        outputs: policy.outputs || ['subagent-plan.json', 'subagent-events.jsonl', 'subagent-parent-summary.json', 'subagent-evidence.json'],
+        deprecated_fields: ['agent_count']
     };
 }
+export function explicitlyParallelizable(prompt) {
+    return PARALLELIZABLE_RE.test(String(prompt || ''));
+}
+function taskProfile(value, task) {
+    return isTaskProfile(value) ? value : classifyTaskProfile(task);
+}
+function normalizeOptions(input) {
+    if (typeof input === 'number' && Number.isFinite(input))
+        return { agents: input };
+    return input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+}
+function firstPositiveNumber(...values) {
+    for (const value of values) {
+        if (positiveNumber(value))
+            return Math.floor(Number(value));
+    }
+    return null;
+}
+function positiveNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0;
+}
+function policyReason(route, task, profile, required) {
+    if (!required)
+        return `task_profile_${profile}_does_not_require_subagents`;
+    if (OFFICIAL_SUBAGENT_ROUTE_KEYS.has(routeKey(route)) || EXPLICIT_SUBAGENT_RE.test(String(task || ''))) {
+        return 'explicit_official_subagent_route';
+    }
+    return `task_profile_${profile}_requires_subagents`;
+}
 //# sourceMappingURL=agent-plan.js.map

package/dist/core/agents/agent-role-config.js

@@ -1,17 +1,30 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
-import { MANAGED_AGENT_ROLES, managedAgentRoleByFile, managedAgentRoleByName, managedAgentRoleContent, managedAgentRoleOwnsText } from '../managed-assets/managed-assets-manifest.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { MANAGED_AGENT_ROLES, MANAGED_OFFICIAL_SUBAGENT_ROLES, managedAgentRoleByFile, managedAgentRoleByName, managedAgentRoleContent, managedOfficialSubagentRoleByFile, managedOfficialSubagentRoleByName, managedOfficialSubagentRoleContent } from '../managed-assets/managed-assets-manifest.js';
+import { installOfficialSubagentAgentConfigs } from '../subagents/official-subagent-config.js';
 export const AGENT_ROLE_CONFIG_REPAIR_SCHEMA = 'sks.agent-role-config-repair.v1';
-export const SKS_OWNED_AGENT_CONFIGS = new Map(MANAGED_AGENT_ROLES.map((role) => [
-    role.filename,
-    { name: role.codex_name, sandbox: role.sandbox, content: managedAgentRoleContent(role), id: role.id }
-]));
+export const SKS_OWNED_AGENT_CONFIGS = new Map([
+    ...MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => [
+        role.filename,
+        { name: role.codex_name, sandbox: role.sandbox ?? null, content: managedOfficialSubagentRoleContent(role), id: role.id }
+    ]),
+    ...MANAGED_AGENT_ROLES.map((role) => [
+        role.filename,
+        { name: role.codex_name, sandbox: role.sandbox, content: managedAgentRoleContent(role), id: role.id }
+    ])
+]);
 export function managedAgentRoleConfigForFile(file) {
+    const official = managedOfficialSubagentRoleByFile(file);
+    if (official)
+        return managedOfficialSubagentRoleContent(official);
     const role = managedAgentRoleByFile(file);
     return role ? managedAgentRoleContent(role) : null;
 }
 export function managedAgentRoleConfigForRole(role) {
+    const official = managedOfficialSubagentRoleByName(role);
+    if (official)
+        return { file: official.filename, content: managedOfficialSubagentRoleContent(official) };
     const match = managedAgentRoleByName(role);
     return match ? { file: match.filename, content: managedAgentRoleContent(match) } : null;
 }
@@ -19,66 +32,50 @@ export async function repairAgentRoleConfigs(input) {
     const root = path.resolve(input.root);
     const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(process.env.HOME || '', '.codex');
     const candidates = [path.join(root, '.codex', 'agents'), path.join(codexHome, 'agents')];
-    const missing = [];
-    const stale = [];
-    const created = [];
-    const repaired = [];
-    const existing = [];
-    const projectAgentsDir = path.join(root, '.codex', 'agents');
+    const officialRepair = await installOfficialSubagentAgentConfigs(root, { apply: input.apply === true });
+    const missing = [...officialRepair.missing];
+    const stale = [...officialRepair.stale];
+    stale.push(...officialRepair.legacy_stale);
+    const created = [...officialRepair.created];
+    const repaired = [...officialRepair.updated];
+    const removed = [...officialRepair.removed_legacy];
+    const existing = [...officialRepair.existing];
+    const manualBlockers = [...officialRepair.manual_blockers];
+    // Exact historical SKS templates are removed by the official installer.
+    // Any user-authored or modified legacy TOML remains an extension surface and
+    // is only inventoried here; it is never normalized, overwritten, or deleted.
     for (const role of MANAGED_AGENT_ROLES) {
         const file = role.filename;
-        const content = managedAgentRoleContent(role);
         const foundPaths = candidates.map((dir) => path.join(dir, file)).filter((filePath) => fs.existsSync(filePath));
-        let managedCopyFound = false;
         for (const foundPath of foundPaths) {
-            const text = fs.readFileSync(foundPath, 'utf8');
-            if (isValidRoleConfig(text, content)) {
-                managedCopyFound = true;
-                existing.push(path.relative(root, foundPath) || foundPath);
-                continue;
-            }
-            const projectOwnedByFilename = foundPath.startsWith(`${projectAgentsDir}${path.sep}`);
-            if (!projectOwnedByFilename && !managedAgentRoleOwnsText(text, role))
-                continue;
-            managedCopyFound = true;
-            stale.push(file);
-            if (input.apply) {
-                await ensureDir(path.dirname(foundPath));
-                await writeTextAtomic(foundPath, content);
-                repaired.push(path.relative(root, foundPath) || foundPath);
-            }
-        }
-        if (managedCopyFound)
-            continue;
-        missing.push(file);
-        if (input.apply) {
-            const target = path.join(projectAgentsDir, file);
-            await ensureDir(path.dirname(target));
-            await writeTextAtomic(target, content);
-            created.push(path.relative(root, target));
+            existing.push(path.relative(root, foundPath) || foundPath);
         }
     }
     const requiredFixes = missing.length + stale.length;
-    const appliedFixes = created.length + repaired.length;
+    const appliedFixes = created.length + repaired.length + removed.length;
     const report = {
         schema: AGENT_ROLE_CONFIG_REPAIR_SCHEMA,
         generated_at: nowIso(),
-        ok: input.apply ? requiredFixes === appliedFixes : true,
+        ok: input.apply ? requiredFixes === appliedFixes && manualBlockers.length === 0 : manualBlockers.length === 0,
         apply: input.apply === true,
         missing,
         stale,
         existing,
         created,
         repaired,
-        manifest_role_ids: MANAGED_AGENT_ROLES.map((role) => role.id),
+        removed,
+        backups: officialRepair.backups,
+        manual_blockers: manualBlockers,
+        manifest_role_ids: MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.id),
+        legacy_compatibility_role_ids: MANAGED_AGENT_ROLES.map((role) => role.id),
         warnings_suppressed: true,
-        blockers: input.apply && requiredFixes !== appliedFixes ? ['agent_role_config_repair_incomplete'] : []
+        blockers: [
+            ...manualBlockers,
+            ...(input.apply && requiredFixes !== appliedFixes ? ['agent_role_config_repair_incomplete'] : [])
+        ]
     };
     if (input.reportPath)
         await writeJsonAtomic(input.reportPath, report);
     return report;
 }
-function isValidRoleConfig(text, expected) {
-    return text === expected;
-}
 //# sourceMappingURL=agent-role-config.js.map

package/dist/core/agents/agent-runner-codex-exec.js

@@ -4,6 +4,7 @@ import { managedProxyEnvForChild } from '../codex/managed-proxy-env.js';
 import { agentWorkerEnv, validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { fastModeEnv, resolveFastModePolicy } from './fast-mode-policy.js';
 import { buildCodexExecArgs } from '../codex/codex-cli-syntax-builder.js';
+import { codexLbRecoveryBlockedProcessResult, withCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
 export function buildCodexExecAgentArgs(agent, prompt, opts = {}) {
     const resultFile = opts.resultFile || defaultCodexResultFile(agent, opts);
     const sandbox = opts.workspaceWrite ? 'workspace-write' : 'read-only';
@@ -72,8 +73,19 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
     const stderrFile = path.join(logRoot, 'codex-exec.stderr.log');
     const allowedCommandsFile = path.join(opts.agentRoot || opts.cwd || process.cwd(), 'agent-allowed-commands.json');
     const workerEnv = agentWorkerEnv(agent, allowedCommandsFile);
-    const proxyEnv = managedProxyEnvForChild({ ...process.env, ...(opts.env || {}) });
-    const result = await runProcess(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile });
+    const effectiveEnv = { ...process.env, ...(opts.env || {}) };
+    const proxyEnv = managedProxyEnvForChild(effectiveEnv);
+    const execute = opts.runProcessImpl || runProcess;
+    const guarded = await withCodexLbCliLaunchRecovery({
+        root: opts.cwd || process.cwd(),
+        env: effectiveEnv,
+        cliArgs: command.args.slice(0, -1),
+        ...(typeof opts.recoveryFetch === 'function' ? { fetchImpl: opts.recoveryFetch } : {}),
+        ...(opts.recoveryTimeoutMs === undefined ? {} : { timeoutMs: opts.recoveryTimeoutMs })
+    }, () => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
+    const result = guarded.launched
+        ? guarded.value
+        : codexLbRecoveryBlockedProcessResult(guarded.toolOutputRecovery);
     const report = await writeCodexProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, {
         project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
         command: [opts.codexBin || 'codex', ...command.args],
@@ -99,6 +111,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
         stderr_bytes: result.stderrBytes,
         truncated: result.truncated,
         timed_out: result.timedOut,
+        codex_lb_tool_output_recovery: guarded.toolOutputRecovery,
         dry_run: false
     });
     if (result.code === 0) {
@@ -123,7 +136,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
             return { ...validated, status: 'blocked', blockers: [...validated.blockers, 'codex_exec_result_schema_invalid'] };
         }
     }
-    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? ['codex_exec_output_last_message_missing_or_invalid'] : ['codex_exec_exit_' + result.code], confidence: 'verified_partial', unverified: result.code === 0 ? ['codex-exec stdout fallback; resultFile JSON missing or invalid'] : [], writes: [], source_intelligence_refs: agent.source_intelligence_refs || null, goal_mode_ref: agent.goal_mode_ref || null, verification: { status: result.code === 0 ? 'partial' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report', 'codex-exec-output-last-message'] } });
+    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? ['codex_exec_output_last_message_missing_or_invalid'] : [...(guarded.launched ? [] : guarded.toolOutputRecovery.blockers), 'codex_exec_exit_' + result.code], confidence: 'verified_partial', unverified: result.code === 0 ? ['codex-exec stdout fallback; resultFile JSON missing or invalid'] : [], writes: [], source_intelligence_refs: agent.source_intelligence_refs || null, goal_mode_ref: agent.goal_mode_ref || null, codex_child_report: { tool_output_recovery: guarded.toolOutputRecovery }, verification: { status: result.code === 0 ? 'partial' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report', 'codex-exec-output-last-message'] } });
 }
 function workerNoMcpDefault(agent, opts = {}, sandbox = 'read-only') {
     if (opts.noMcp !== undefined)

package/dist/core/agents/agent-schema.js

@@ -1,3 +1,4 @@
+export { DEFAULT_NARUTO_MAX_THREADS, DEFAULT_NARUTO_REQUESTED_SUBAGENTS, HARD_NARUTO_MAX_THREADS } from '../subagents/thread-budget.js';
 export const AGENT_KERNEL_SCHEMA = 'sks.native-agent-kernel.v1';
 export const AGENT_RESULT_SCHEMA = 'sks.agent-result.v1';
 export const AGENT_LEDGER_EVENT_SCHEMA = 'sks.agent-ledger-event.v1';
@@ -9,9 +10,9 @@ export const AGENT_COUNT = DEFAULT_AGENT_COUNT;
 export const AGENT_INTAKE_STAGE_ID = 'native_agent_intake';
 export const MAX_AGENT_COUNT = 20;
 export const DEFAULT_AGENT_CONCURRENCY = 4;
-// Naruto may queue a large roster, but active workers are governed separately and
-// remain bounded by live CPU, memory, load, and I/O pressure.
+/** @deprecated Legacy process-swarm queue ceiling; never an official thread cap. */
 export const MAX_NARUTO_AGENT_COUNT = 100;
+/** @deprecated Legacy clone default; official workflows use two default children unless --agents is explicit. */
 export const DEFAULT_NARUTO_CLONES = 8;
 export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk', 'zellij', 'ollama', 'local-llm'];
 export function normalizeAgentBackend(input) {

package/dist/core/agents/native-cli-session-swarm.js

@@ -435,7 +435,7 @@ class NativeCliSessionSwarmRecorder {
                         headless_by_design_viewport_ui: process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? 0 : this.input.targetActiveSlots
                     },
                     active_workers: this.input.targetActiveSlots,
-                    visible_panes: Number(process.env.SKS_ZELLIJ_VIEWPORTS || 4),
+                    visible_panes: Number(process.env.SKS_ZELLIJ_VIEWPORTS || 1),
                     headless_workers: process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts)) : this.input.targetActiveSlots,
                     queue_depth: Math.max(0, this.input.requestedAgents - this.input.targetActiveSlots),
                     local_llm: { tps: 0, queue: 0 },

package/dist/core/agents/zellij-right-lane-cockpit.js

@@ -36,9 +36,9 @@ export function buildZellijRightLaneCockpit(input = {}) {
         visible_lane_count: Math.min(lanes.length, maxVisible),
         page_count: pageCount,
         actual_pane_ids: lanes.map((lane) => lane.pane_id).filter(Boolean),
-        attach_command: input.sessionName ? `zellij attach ${input.sessionName}` : 'sks team open-zellij latest',
+        attach_command: input.sessionName ? `zellij attach ${input.sessionName}` : 'sks zellij status',
         keyboard_hint: 'Use the Zellij pane controls to move between lanes; detach with the configured Zellij detach binding.',
-        cleanup_command_hint: 'sks team cleanup-zellij latest',
+        cleanup_command_hint: 'Use native Zellij session controls; legacy Team mutation commands are removed.',
         ok: lanes.length > 0
     };
     const laneManifest = {