sneakoscope 6.0.3 → 6.1.2

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,24 @@ 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 always use max reasoning. Clear bounded work uses
+// Luna; any judgment-bearing slice uses Sol. There is no automatic Terra or
+// lower-effort fallback.
+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 routed = decideSubagentModel({
+        title: [agentId, persona.naruto_role, persona.work_kind].filter(Boolean).join(' '),
+        description: [prompt, persona.risk_focus, persona.write_policy].filter(Boolean).join(' '),
+        role,
+        expectedOutput: (persona.output_expectations || []).join(' ')
+    });
+    const effort = 'max';
     const modelCapability = codexModelEffortCapability({
         model: routed.model,
-        advertisedEfforts: narutoAdvertisedEfforts(routed.model),
+        advertisedEfforts: ['max'],
         defaultEffort: effort
     });
     return {
@@ -87,24 +91,23 @@ 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'
+            'UI, review, debugging, planning, architecture, integration, security, database, release, or ambiguity selects Sol Max',
+            'requiresJudgment or reasoning-sensitive evidence selects Sol Max',
+            'requested model or max effort 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'
-        ]
+        downshift_triggers: []
     };
 }
+/** @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 +129,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_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'] : null,
+        model_catalog_policy: narutoFamilyOnly ? 'official_subagent_luna_sol_max' : 'codex_catalog_passthrough',
+        model_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-5.6-sol'] : null,
+        explicit_compatibility_models: narutoFamilyOnly ? ['gpt-5.6-terra'] : 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-max', 'gpt-5.6-terra-max']
             : ['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 ? ['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 automatically use GPT-5.6 Luna Max for clear bounded repeatable work and GPT-5.6 Sol Max for every reasoning-sensitive slice; an explicit user-selected Terra model remains compatible but is never selected automatically.'
             : '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 +169,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-janitor.js

@@ -2,6 +2,7 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { normalizeAgentSessionRows } from './agent-session-rows.js';
+import { resolveOwnedNamespacePath } from './agent-namespace-safety.js';
 export async function runAgentJanitor(input) {
     const staleMs = input.staleMs ?? 30 * 60 * 1000;
     const agentRoot = path.join(input.missionDir, 'agents');
@@ -39,7 +40,7 @@ export async function runAgentJanitor(input) {
     const staleZellijSessions = rawStaleZellijSessions.filter((id) => !activeGenerationSet.has(id));
     const skippedActiveGenerations = rawStaleZellijSessions.filter((id) => activeGenerationSet.has(id));
     const orphanGenerationDirs = await detectOrphanGenerationDirs(agentRoot, new Set(generationRows.map((row) => String(row.artifact_dir || ''))));
-    const orphanTempDirs = await scopedExistingPaths(Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs : [], projectHash);
+    const orphanTempDirs = await scopedExistingPaths(Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs : [], projectHash, namespace?.temp_dir ? [namespace.temp_dir] : []);
     const staleLocks = await scopedStaleLockPaths(namespace?.lock_dir ? [namespace.lock_dir] : [], projectHash, staleMs);
     const cleaned = [];
     if (input.cleanup) {
@@ -103,15 +104,12 @@ async function detectOrphanGenerationDirs(agentRoot, knownGenerationDirs) {
 export async function writeAgentJanitorReport(missionDir, report) {
     await writeJsonAtomic(path.join(missionDir, 'agents', 'agent-janitor-report.json'), report);
 }
-async function scopedExistingPaths(paths, projectHash) {
+async function scopedExistingPaths(paths, projectHash, anchors = []) {
     const out = [];
     for (const candidate of paths) {
-        if (!candidate)
-            continue;
-        if (projectHash && !candidate.includes(projectHash))
-            continue;
-        if (await exists(candidate))
-            out.push(candidate);
+        const owned = await resolveOwnedNamespacePath(candidate, String(projectHash || ''), anchors);
+        if (owned)
+            out.push(owned);
     }
     return out;
 }
@@ -119,9 +117,10 @@ async function scopedStaleLockPaths(paths, projectHash, staleMs) {
     const out = [];
     const now = Date.now();
     for (const dir of paths) {
-        if (!dir || (projectHash && !dir.includes(projectHash)) || !(await exists(dir)))
+        const ownedDir = await resolveOwnedNamespacePath(dir, String(projectHash || ''));
+        if (!ownedDir)
             continue;
-        for (const file of await listFiles(dir)) {
+        for (const file of await listFiles(ownedDir)) {
             const stat = await fsp.stat(file).catch(() => null);
             if (stat && now - stat.mtimeMs > staleMs)
                 out.push(file);

package/dist/core/agents/agent-namespace-safety.js

@@ -0,0 +1,56 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+export function validProjectNamespaceHash(value) {
+    return /^[A-Za-z0-9_-]{4,64}$/.test(String(value || ''));
+}
+export function processReportMatchesProjectNamespace(report, projectHash) {
+    if (!validProjectNamespaceHash(projectHash) || !report || typeof report !== 'object')
+        return false;
+    if (String(report.project_hash || '') === projectHash)
+        return true;
+    if (String(report.root_hash || '') === projectHash)
+        return true;
+    const namespace = String(report.project_namespace || '');
+    return namespace === projectHash || namespace === `sks-${projectHash}` || namespace.startsWith(`sks-${projectHash}-`);
+}
+export async function resolveOwnedNamespacePath(candidate, projectHash, anchors = []) {
+    if (!validProjectNamespaceHash(projectHash))
+        return null;
+    const raw = String(candidate || '');
+    if (!raw || !path.isAbsolute(raw) || raw.includes('\0') || raw.split(/[\\/]+/).includes('..'))
+        return null;
+    const resolved = path.resolve(raw);
+    const stat = await fsp.lstat(resolved).catch(() => null);
+    if (!stat || stat.isSymbolicLink())
+        return null;
+    const real = await fsp.realpath(resolved).catch(() => null);
+    if (!real)
+        return null;
+    const validAnchors = [];
+    for (const value of anchors) {
+        const anchorRaw = String(value || '');
+        if (!anchorRaw || !path.isAbsolute(anchorRaw) || anchorRaw.split(/[\\/]+/).includes('..'))
+            continue;
+        const anchorResolved = path.resolve(anchorRaw);
+        const anchorStat = await fsp.lstat(anchorResolved).catch(() => null);
+        if (!anchorStat?.isDirectory() || anchorStat.isSymbolicLink())
+            continue;
+        const anchorReal = await fsp.realpath(anchorResolved).catch(() => null);
+        if (anchorReal)
+            validAnchors.push({ resolved: anchorResolved, real: anchorReal });
+    }
+    if (validAnchors.length) {
+        return validAnchors.some((anchor) => isWithin(anchor.resolved, resolved) && isWithin(anchor.real, real)) ? resolved : null;
+    }
+    return pathContainsHashToken(resolved, projectHash) && pathContainsHashToken(real, projectHash) ? resolved : null;
+}
+function pathContainsHashToken(value, projectHash) {
+    const escaped = projectHash.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const token = new RegExp(`(^|[-_.])${escaped}($|[-_.])`);
+    return path.resolve(value).split(path.sep).filter(Boolean).some((segment) => token.test(segment));
+}
+function isWithin(parent, candidate) {
+    const rel = path.relative(path.resolve(parent), path.resolve(candidate));
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+//# sourceMappingURL=agent-namespace-safety.js.map

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

@@ -53,6 +53,7 @@ import { writeNativeCliSessionProof } from './native-cli-session-proof.js';
 import { writeNoSubagentScalingPolicy } from './no-subagent-scaling-policy.js';
 import { writeOfficialSubagentHelperPolicy } from './official-subagent-helper-policy.js';
 import { runCodexTask } from '../codex-control/codex-control-plane.js';
+import { codexTimeoutClassForRoute } from '../codex-control/codex-reliability-shield.js';
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
 import { resolveLocalCollaborationPolicy, localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
 import { runFinalGptReviewStage } from '../pipeline/final-gpt-review-stage.js';
@@ -72,7 +73,7 @@ import { APPROACHES, rank, scoreCandidate, summarizeTournament } from '../naruto
 export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const sessionKey = opts.sessionKey || null;
-    const prompt = String(opts.prompt || 'Native agent run');
+    const prompt = await resolveAgentMissionPrompt(root, opts);
     const route = opts.route || '$Agent';
     const routeCommand = String(opts.routeCommand || defaultRouteCommand(route));
     const routeBlackboxKind = String(opts.routeBlackboxKind || defaultRouteBlackboxKind(route));
@@ -412,7 +413,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
                 generationIndex: agent.generation_index,
                 requireGeneration: true
             });
-            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, projectRoot: root, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
+            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, projectRoot: root, projectHash: namespace.root_hash, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
             const result = opts.nativeCliSwarm === false
                 ? await runAgentByBackend(backend, runtimeAgent, runtimeSlice, backendOpts)
                 : await nativeCliSwarm.launchWorker({ agent: runtimeAgent, slice: runtimeSlice, opts: backendOpts });
@@ -684,6 +685,27 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         proof
     };
 }
+export async function resolveAgentMissionPrompt(root, opts) {
+    const direct = String(opts.prompt || '').trim();
+    if (opts.promptExplicit === true || (direct && direct !== 'Native agent run'))
+        return direct || 'Native agent run';
+    const missionId = String(opts.missionId || '').trim();
+    if (!missionId)
+        return direct || 'Native agent run';
+    const dir = missionDir(root, missionId);
+    const [intake, routeContext, mission] = await Promise.all([
+        readJson(path.join(dir, 'request-intake.json'), null),
+        readJson(path.join(dir, 'route-context.json'), null),
+        readJson(path.join(dir, 'mission.json'), null)
+    ]);
+    return String(intake?.transformed_prompt
+        || routeContext?.transformed_prompt
+        || routeContext?.task
+        || routeContext?.prompt
+        || mission?.prompt
+        || direct
+        || 'Native agent run').trim();
+}
 function normalizeMissionHardTimeoutMs(opts = {}, route = '') {
     const raw = Number(opts.hardTimeoutMs || opts.agentHardTimeoutMs || process.env.SKS_AGENT_HARD_TIMEOUT_MS || 0);
     if (Number.isFinite(raw) && raw > 0)
@@ -1989,7 +2011,7 @@ async function runAgentByBackend(backend, agent, slice, opts) {
             zellijPaneId: null,
             reliabilityPolicy: {
                 maxEmptyResultRetries: writePaths.length ? 1 : 2,
-                timeoutClass: writePaths.length ? 'standard' : 'short'
+                timeoutClass: codexTimeoutClassForRoute(opts.route, writePaths.length ? 'standard' : 'short')
             }
         });
         const sdkWorkerResult = await readJson(sdkTask.workerResultPath, null);

package/dist/core/agents/agent-output-validator.js

@@ -34,7 +34,7 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
         task_slice_id: { type: 'string' },
         work_item_kind: { type: 'string' },
         status: { enum: ['done', 'blocked', 'failed'] },
-        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'zellij', 'ollama', 'local-llm'] },
+        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'codex-exec', 'zellij', 'tmux', 'ollama', 'local-llm'] },
         summary: { type: 'string' },
         findings: { type: 'array', items: { type: 'string' } },
         proposed_changes: { type: 'array', items: { type: 'string' } },

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,69 +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, role)) {
-                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, role) {
-    return managedAgentRoleOwnsText(text, role)
-        && text.includes('description = "')
-        && text.includes('developer_instructions = """')
-        && !/^\s*(?:model|model_reasoning_effort)\s*=/m.test(text);
-}
 //# sourceMappingURL=agent-role-config.js.map