sneakoscope 6.0.3 → 6.1.2

package/dist/core/pipeline-internals/runtime-core.js

@@ -1,18 +1,18 @@
-import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { appendJsonl, exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { appendJsonl, exists, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 import { containsUserQuestion, noQuestionContinuationReason } from '../no-question-guard.js';
-import { createMission, missionDir, setCurrent } from '../mission.js';
+import { createMission, getOrCreateSessionMission, missionDir, sessionStateKey, setCurrent } from '../mission.js';
 import { buildQuestionSchemaForRoute, buildRequestIntake, REQUEST_INTAKE_ARTIFACT, writeQuestions } from '../questions.js';
 import { sealContract } from '../decision-contract.js';
 import { scanDbSafety } from '../db-safety.js';
 import { GOAL_WORKFLOW_ARTIFACT, writeGoalWorkflow } from '../goal-workflow.js';
+import { createAndWriteWorkOrderLedgerForPrompt } from '../work-order-ledger.js';
 import { writeCodeStructureReport } from '../code-structure.js';
 import { writeMemorySweepReport } from '../memory-governor.js';
 import { writeMistakeMemoryReport } from '../mistake-memory.js';
 import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from '../mistake-recall.js';
 import { recordSkillDreamEvent, SKILL_DREAM_POLICY, skillDreamPolicyText, writeSkillForgeReport } from '../skill-forge.js';
-import { evaluateResearchGate, writeResearchPlan } from '../research.js';
+import { evaluateResearchGate, researchPaperArtifactForPlan, writeResearchPlan } from '../research.js';
 import { PPT_REQUIRED_GATE_FIELDS, writePptRouteArtifacts } from '../ppt.js';
 import { writeQaLoopArtifacts } from '../qa-loop.js';
 import { IMAGE_UX_REVIEW_GATE_ARTIFACT, IMAGE_UX_REVIEW_POLICY_ARTIFACT, IMAGE_UX_REVIEW_SCREEN_INVENTORY_ARTIFACT, IMAGE_UX_REVIEW_GENERATED_REVIEW_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ITERATION_REPORT_ARTIFACT, IMAGE_UX_REVIEW_REQUIRED_GATE_FIELDS, writeImageUxReviewRouteArtifacts } from '../image-ux-review.js';
@@ -23,13 +23,17 @@ import { validateRouteCompletionProof } from '../proof/route-proof-gate.js';
 import { routeFromState, routeRequiresCompletionProof } from '../proof/route-proof-policy.js';
 import { permissionGateSummary } from '../permission-gates.js';
 import { prepareMadDbMission } from '../mad-db/mad-db-coordinator.js';
-import { AGENT_INTAKE_STAGE_ID, AGENT_COUNT } from '../agents/agent-schema.js';
+import { AGENT_INTAKE_STAGE_ID } from '../agents/agent-schema.js';
 import { normalizeAgentPolicy, routeRequiresAgentIntake, agentPipelineStage } from '../agents/agent-plan.js';
 import { readAgentGateStatus } from '../agents/agent-gate.js';
 import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, 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, SOLUTION_SCOUT_STAGE_ID, chatCaptureIntakeText, context7RequirementText, dollarCommand, evidenceMentionsForbiddenBrowserAutomation, getdesignReferencePolicyText, hasFromChatImgSignal, hasMadSksSignal, imageUxReviewPipelinePolicyText, leanEngineeringCompactText, looksLikeProblemSolvingRequest, pptPipelineAllowlistPolicyText, reflectionRequiredForRoute, reasoningInstruction, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, solutionScoutPolicyText, stripDollarCommand, stripMadSksSignal, stripVisibleDecisionAnswerBlocks, subagentExecutionPolicyText, stackCurrentDocsPolicyText, triwikiContextTracking, triwikiContextTrackingText, triwikiStagePolicyText } from '../routes.js';
 import { normalizeLeanDecision, validateLeanDecision } from '../lean-engineering-policy.js';
 import { MIN_TEAM_REVIEWER_LANES, MIN_TEAM_REVIEW_POLICY_TEXT } from '../team-review-policy.js';
-import { normalizeCodexMultiAgentEventName } from '../codex-control/codex-multi-agent-event-normalizer.js';
+import { classifyTaskProfile, gateProfileForTask } from '../runtime/task-profile.js';
+import { chooseVerificationBudget } from '../runtime/verification-budget.js';
+import { NARUTO_PARENT_MODEL } from '../subagents/model-policy.js';
+import { NARUTO_GATE_FILENAME, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME, prepareOfficialSubagentMission } from '../subagents/official-subagent-preparation.js';
+import { buildSubagentEvidence, readSubagentEvents, recordSubagentEvent, SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME } from '../subagents/subagent-evidence.js';
 export { routePrompt };
 export const PIPELINE_PLAN_ARTIFACT = 'pipeline-plan.json';
 export const PIPELINE_PLAN_SCHEMA_VERSION = 1;
@@ -54,52 +58,79 @@ const DEFAULT_COMPLIANCE_LOOP_LIMIT = 3;
 const CLARIFICATION_BYPASS_ROUTES = new Set(['Answer', 'DFix', 'Help', 'Wiki', 'ComputerUse', 'Goal']);
 const QUESTION_GATE_ROUTES = new Set(['QALoop', 'PPT']);
 const LIGHTWEIGHT_ROUTES = new Set(['Answer', 'DFix', 'Help', 'Wiki']);
-const FULL_ROUTE_STAGES = Object.freeze([
-    'route_classification',
-    SOLUTION_SCOUT_STAGE_ID,
-    'skill_dream_counter',
-    'ambiguity_gate',
-    'pipeline_plan',
-    'proof_field_scan',
-    'triwiki_use_first',
-    'ssot_guard',
-    'context7_evidence',
-    AGENT_INTAKE_STAGE_ID,
-    'native_agent_intake',
-    'planning_debate',
-    'route_materialization',
-    'fresh_executor_team',
-    'broad_route_rework',
-    'focused_implementation',
-    'listed_verification',
-    'triwiki_validate_before_final',
-    'reflection',
-    'honest_mode'
-]);
+const GATE_PROFILE_STAGES = Object.freeze({
+    none: [],
+    minimal: ['route_classification', 'listed_verification'],
+    scoped: ['route_classification', 'ownership', 'listed_verification', 'honest_summary'],
+    full: ['route_classification', 'ambiguity_gate', 'safety_gate', 'ownership', 'listed_verification', 'honest_summary']
+});
+const STAGE_BLOCKING_GATE = Object.freeze({
+    ambiguity_gate: 'scope',
+    safety_gate: 'safety',
+    ssot_guard: 'safety',
+    context7_evidence: 'safety',
+    mistake_recall: 'safety',
+    ownership: 'ownership',
+    pipeline_plan: 'ownership',
+    focused_implementation: 'ownership',
+    [SOLUTION_SCOUT_STAGE_ID]: 'ownership',
+    triwiki_use_first: 'ownership',
+    subagent_plan: 'ownership',
+    official_subagent_execution: 'ownership',
+    parent_integration: 'ownership',
+    [AGENT_INTAKE_STAGE_ID]: 'ownership',
+    route_materialization: 'ownership',
+    work_order_coverage: 'ownership',
+    listed_verification: 'verification',
+    triwiki_validate_before_final: 'verification',
+    completion_proof: 'verification',
+    reflection: 'verification',
+    honest_summary: 'verification'
+});
+const BLOCKING_GATE_LIMITS = Object.freeze({
+    passthrough: 0,
+    answer: 0,
+    'tiny-change': 1,
+    'bounded-work': 2,
+    'parallel-read': 2,
+    'parallel-write': 3,
+    'high-risk': 4
+});
 function reflectionInstructionText(commandPrefix = 'sks') {
     return `Post-route reflection: full routes load \`reflection\` after work/tests and before final; DFix/Answer/Help/Wiki/SKS discovery are exempt. Write ${REFLECTION_ARTIFACT}; record only real misses/gaps, or no_issue_acknowledged. For lessons, append TriWiki claim rows to ${REFLECTION_MEMORY_PATH}. Run "${commandPrefix} wiki refresh" or pack, validate, then pass ${REFLECTION_GATE}.`;
 }
 export function buildPipelinePlan(input = {}) {
     const route = input.route || routePrompt(input.task || '$SKS');
     const task = String(input.task || '').trim();
+    const taskProfile = input.taskProfile || taskProfileForRoute(route, task, classifyTaskProfile(task));
+    const gateProfile = gateProfileForTask(taskProfile);
     const requestIntake = input.requestIntake || null;
     const executionPrompt = String(requestIntake?.transformed_prompt || task || '').trim();
     const ambiguity = normalizeAmbiguity(input.ambiguity, route);
     const proof = normalizeProofField(input.proofField);
-    const lane = selectPipelineLane(route, task, proof);
-    const agentPolicy = normalizeAgentPolicy(route, task, input.agents === undefined ? {} : input.agents);
-    const stages = buildPipelineStages(route, task, ambiguity, lane, Boolean(input.required), agentPolicy);
-    const verification = planVerification(route, proof);
+    const subagentsRequired = routeRequiresSubagents(route, task, taskProfile);
+    const lane = selectPipelineLane(route, task, proof, taskProfile);
+    const normalizedAgentPolicy = normalizeAgentPolicy(route, task, input.agents === undefined ? {} : input.agents);
+    const agentPolicy = subagentsRequired
+        ? { ...normalizedAgentPolicy, required: false, subagents_required: false, reason: 'official_codex_subagent_workflow_replaces_legacy_agent_intake' }
+        : normalizedAgentPolicy;
+    const verificationBudget = input.verificationBudget || chooseVerificationBudget({
+        taskProfile,
+        changedFiles: Array.isArray(input.changedFiles) ? input.changedFiles : []
+    });
+    const stages = buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, lane, Boolean(input.required), agentPolicy);
+    const verification = planVerification(route, proof, verificationBudget);
     const skipped = stages.filter((stage) => stage.status === 'skipped').map((stage) => stage.id);
     const kept = stages.filter((stage) => stage.status !== 'skipped' && stage.status !== 'not_applicable').map((stage) => stage.id);
     const routeEconomy = routeEconomyPlan(proof);
     const leanDecision = normalizeLeanDecision(input.leanDecision, {
-        selected_rung: ['Answer', 'Help', 'Wiki'].includes(route?.id) ? 'skip' : 'minimal-custom',
-        task_requires_change: !['Answer', 'Help', 'Wiki'].includes(route?.id),
+        selected_rung: gateProfile === 'none' ? 'skip' : 'minimal-custom',
+        task_requires_change: !['passthrough', 'answer'].includes(taskProfile),
         root_cause_target: route?.id ? `${route.id} route selected implementation surface` : null,
         expected_changed_paths: input.expectedChangedPaths || input.touchedFiles || [],
         verification_minimum: verification.slice(0, 3).map((item) => String(item || '').trim()).filter(Boolean)
     });
+    const invariants = pipelineInvariants({ taskProfile, gateProfile, stages, verificationBudget });
     return {
         schema_version: PIPELINE_PLAN_SCHEMA_VERSION,
         generated_at: nowIso(),
@@ -111,10 +142,18 @@ export function buildPipelinePlan(input = {}) {
             stop_gate: route?.stopGate || 'honest_mode',
             required_skills: route?.requiredSkills || [],
             context7_required: Boolean(input.required),
-            subagents_required: false,
-            native_sessions_required: routeRequiresSubagents(route, task),
+            subagents_required: subagentsRequired,
+            native_sessions_required: false,
             reflection_required: reflectionRequiredForRoute(route)
         },
+        task_profile: taskProfile,
+        gate_profile: gateProfile,
+        gate_budget: {
+            blocking_gate_limit: BLOCKING_GATE_LIMITS[taskProfile],
+            blocking_gate_count: countBlockingGateStages(stages),
+            blocking_stage_count: countBlockingStages(stages),
+            blocking_gate_ids: blockingGateIds(stages)
+        },
         task,
         request_intake: requestIntake ? {
             artifact: REQUEST_INTAKE_ARTIFACT,
@@ -139,8 +178,9 @@ export function buildPipelinePlan(input = {}) {
         },
         skipped_stages: skipped,
         kept_stages: kept,
+        verification_budget: verificationBudget,
         verification,
-        invariants: ['no_unrequested_fallback_code', 'ssot_guard', 'listed_verification', 'triwiki_validate_before_final', 'honest_mode'],
+        invariants,
         proof_field: proof,
         lean_decision: leanDecision,
         ssot_guard: buildSsotGuard({ route: route?.id || 'SKS', mode: route?.mode || 'SKS', task }),
@@ -148,13 +188,28 @@ export function buildPipelinePlan(input = {}) {
         agent_intake: agentPolicy,
         skill_dream: input.skillDream || { attached: false, reason: 'skill dreaming uses cheap counters and only runs inventory at threshold' },
         goal_continuation: ambientGoalContinuation(),
-        next_actions: planNextActions(route, task, ambiguity, lane, agentPolicy),
+        next_actions: planNextActions(route, task, taskProfile, ambiguity, lane, agentPolicy, input.missionId),
         no_unrequested_fallback_code: true
     };
 }
+function taskProfileForRoute(route, task, classified) {
+    if (classified !== 'answer' && classified !== 'passthrough')
+        return classified;
+    const routeId = String(route?.id || '');
+    if (['DB', 'MadDB', 'ReleaseReview'].includes(routeId) && /\b(apply|execute|run|fix|change|migrate|deploy|release|publish)\b|적용|실행|수정|변경|마이그레이션|배포|릴리즈|출시/i.test(task))
+        return 'high-risk';
+    if (['Research', 'AutoResearch', 'QALoop', 'PPT', 'ImageUXReview', 'GX', 'DB', 'MadDB', 'ReleaseReview'].includes(routeId))
+        return 'bounded-work';
+    return classified;
+}
 export async function writePipelinePlan(dir, input = {}) {
+    const route = input.route || routePrompt(input.task || '$SKS');
+    const taskProfile = input.taskProfile || taskProfileForRoute(route, String(input.task || ''), classifyTaskProfile(input.task || ''));
+    if ((taskProfile === 'passthrough' || taskProfile === 'answer') && input.forceLightweightPlan !== true) {
+        return buildPipelinePlan({ ...input, taskProfile, requestIntake: input.requestIntake || null });
+    }
     const requestIntake = input.requestIntake || await writeRequestIntakeArtifact(dir, input);
-    const plan = buildPipelinePlan({ ...input, requestIntake });
+    const plan = buildPipelinePlan({ ...input, taskProfile, requestIntake });
     await writeJsonAtomic(path.join(dir, PIPELINE_PLAN_ARTIFACT), plan);
     return plan;
 }
@@ -186,15 +241,38 @@ function rootFromMissionDir(dir) {
 }
 export function validatePipelinePlan(plan = {}) {
     const issues = [];
+    const taskProfile = plan.task_profile || classifyTaskProfile(plan.task || '');
+    const expectedGateProfile = gateProfileForTask(taskProfile);
+    const gateProfile = plan.gate_profile || expectedGateProfile;
+    const verificationBudget = plan.verification_budget || chooseVerificationBudget({ taskProfile, changedFiles: [] });
+    const expectedBlockingGateLimit = BLOCKING_GATE_LIMITS[taskProfile];
+    const declaredBlockingGateLimit = Number(plan.gate_budget?.blocking_gate_limit);
+    const actualBlockingGateCount = countBlockingGateStages(plan.stages);
     if (plan.schema_version !== PIPELINE_PLAN_SCHEMA_VERSION)
         issues.push('schema_version');
     if (!plan.route?.id || !plan.route?.command)
         issues.push('route');
     if (!plan.runtime_lane?.lane)
         issues.push('runtime_lane');
-    if (!Array.isArray(plan.stages) || !plan.stages.length)
+    if (gateProfile !== expectedGateProfile)
+        issues.push('gate_profile');
+    if (!Number.isInteger(declaredBlockingGateLimit) || declaredBlockingGateLimit !== expectedBlockingGateLimit)
+        issues.push('gate_budget.blocking_gate_limit');
+    if (actualBlockingGateCount > expectedBlockingGateLimit)
+        issues.push(`gate_budget.blocking_gate_limit_exceeded:${actualBlockingGateCount}>${expectedBlockingGateLimit}`);
+    if (plan.gate_budget?.blocking_gate_count !== undefined && Number(plan.gate_budget.blocking_gate_count) !== actualBlockingGateCount)
+        issues.push('gate_budget.blocking_gate_count');
+    if (plan.gate_budget?.blocking_stage_count !== undefined && Number(plan.gate_budget.blocking_stage_count) !== countBlockingStages(plan.stages))
+        issues.push('gate_budget.blocking_stage_count');
+    if (!sameStringArray(plan.gate_budget?.blocking_gate_ids, blockingGateIds(plan.stages)))
+        issues.push('gate_budget.blocking_gate_ids');
+    if (!Array.isArray(plan.stages) || (gateProfile !== 'none' && !plan.stages.length))
         issues.push('stages');
-    if (!Array.isArray(plan.verification) || !plan.verification.length)
+    else {
+        issues.push(...validateRequiredGateProfileStages(plan, expectedGateProfile));
+        issues.push(...validateStageBlockingMetadata(plan.stages));
+    }
+    if (!Array.isArray(plan.verification) || (verificationBudget !== 'none' && !plan.verification.length))
         issues.push('verification');
     if (!plan.route_economy?.mode)
         issues.push('route_economy');
@@ -206,16 +284,79 @@ export function validatePipelinePlan(plan = {}) {
         issues.push(...leanDecision.issues.map((issue) => `lean_decision:${issue}`));
     if (plan.no_unrequested_fallback_code !== true || !plan.invariants?.includes('no_unrequested_fallback_code'))
         issues.push('fallback_guard');
-    if (!plan.ssot_guard?.required || !plan.invariants?.includes('ssot_guard'))
-        issues.push('ssot_guard');
-    if (!plan.stages?.some((stage) => stage.id === 'ssot_guard' && !['skipped', 'not_applicable'].includes(stage.status)))
-        issues.push('ssot_guard_stage');
-    if (!plan.next_actions?.length)
+    if (plan.invariants?.includes('ssot_guard')) {
+        if (!plan.ssot_guard?.required)
+            issues.push('ssot_guard');
+        if (!plan.stages?.some((stage) => stage.id === 'ssot_guard' && !['skipped', 'not_applicable'].includes(stage.status)))
+            issues.push('ssot_guard_stage');
+    }
+    if (gateProfile !== 'none' && !plan.next_actions?.length)
         issues.push('next_actions');
-    if (plan.agent_intake?.required && !plan.stages?.some((stage) => stage.id === AGENT_INTAKE_STAGE_ID && stage.agent_count === AGENT_COUNT && stage.read_only === false && /bounded workspace-write/i.test(String(stage.write_policy || '')) && /lease/i.test(String(stage.write_policy || ''))))
+    if (plan.agent_intake?.required && !plan.stages?.some((stage) => stage.id === AGENT_INTAKE_STAGE_ID
+        && stage.workflow === 'official_codex_subagent'
+        && Number(stage.requested_subagents || 0) === Number(plan.agent_intake.requested_subagents || 0)
+        && Number(stage.requested_subagents || 0) > 0
+        && Number(stage.max_threads || 0) > 0
+        && Number(stage.max_depth || 0) === 1
+        && Array.isArray(stage.outputs)
+        && stage.outputs.includes(SUBAGENT_EVIDENCE_FILENAME)))
         issues.push('agent_intake_stage');
     return { ok: issues.length === 0, issues };
 }
+function validateRequiredGateProfileStages(plan, gateProfile) {
+    const issues = [];
+    const stages = Array.isArray(plan.stages) ? plan.stages : [];
+    const activeStatuses = new Set(['keep', 'required', 'passed', 'completed']);
+    for (const id of GATE_PROFILE_STAGES[gateProfile]) {
+        const matches = stages.filter((stage) => String(stage?.id || '') === id);
+        if (matches.length !== 1) {
+            issues.push(`stages.required_count:${id}:${matches.length}`);
+            continue;
+        }
+        const status = String(matches[0]?.status || '');
+        const validNotApplicable = id === 'ambiguity_gate'
+            && plan.ambiguity_gate?.required === false
+            && status === 'not_applicable';
+        if (!activeStatuses.has(status) && !validNotApplicable) {
+            issues.push(`stages.required_inactive:${id}:${status || 'missing'}`);
+        }
+    }
+    return issues;
+}
+function countBlockingGateStages(stages) {
+    return blockingGateIds(stages).length;
+}
+function countBlockingStages(stages) {
+    if (!Array.isArray(stages))
+        return 0;
+    return stages.filter((stage) => stage?.blocking === true && !['skipped', 'not_applicable'].includes(String(stage?.status || ''))).length;
+}
+function blockingGateIds(stages) {
+    if (!Array.isArray(stages))
+        return [];
+    return [...new Set(stages
+            .filter((stage) => stage?.blocking === true && !['skipped', 'not_applicable'].includes(String(stage?.status || '')))
+            .map((stage) => String(stage?.blocking_gate || '').trim())
+            .filter(Boolean))].sort();
+}
+function validateStageBlockingMetadata(stages) {
+    const issues = [];
+    for (const stage of stages) {
+        const id = String(stage?.id || 'missing');
+        if (typeof stage?.blocking !== 'boolean')
+            issues.push(`stages.blocking_metadata_missing:${id}`);
+        if (stage?.blocking === true && !String(stage?.blocking_gate || '').trim())
+            issues.push(`stages.blocking_gate_missing:${id}`);
+        if (stage?.blocking !== true && stage?.blocking_gate != null)
+            issues.push(`stages.nonblocking_gate_present:${id}`);
+    }
+    return issues;
+}
+function sameStringArray(left, right) {
+    return Array.isArray(left)
+        && left.length === right.length
+        && left.every((value, index) => String(value) === right[index]);
+}
 function validateRouteEconomyDecisionLattice(routeEconomy = {}, proof = {}) {
     const lattice = routeEconomy.decision_lattice;
     if (!lattice)
@@ -316,7 +457,7 @@ function routeEconomyPlan(proof = {}) {
         deletion_policy: 'do_not_delete_or_skip_pipeline_stages_until_report_only_metrics_are_calibrated'
     };
 }
-function selectPipelineLane(route, task, proof) {
+function selectPipelineLane(route, task, proof, taskProfile = classifyTaskProfile(task)) {
     if (proof.attached && proof.lane) {
         return {
             lane: proof.lane,
@@ -328,65 +469,101 @@ function selectPipelineLane(route, task, proof) {
             keep: proof.keep || SPEED_LANE_POLICY.always_keep
         };
     }
+    if (taskProfile === 'passthrough' || taskProfile === 'answer')
+        return { lane: 'no_pipeline', source: 'task_profile', fast_lane_allowed: true, reason: 'Light conversation does not create an execution pipeline.', blockers: [], skip_when_fast: [], keep: [] };
     if (route?.id === 'ComputerUse')
         return { lane: 'computer_use_fast_lane', source: 'route_policy', fast_lane_allowed: true, reason: 'Computer Use route is intentionally direct and defers wiki/honest checks to closeout.', blockers: [], skip_when_fast: ['native_agent_intake', 'planning_debate', 'fresh_executor_team'], keep: ['focused_implementation', 'triwiki_validate_before_final', 'honest_mode'] };
+    if (taskProfile === 'tiny-change')
+        return { lane: 'minimal_change_lane', source: 'task_profile', fast_lane_allowed: true, reason: 'Tiny change uses one blocking gate and one focused check at most.', blockers: [], skip_when_fast: SPEED_LANE_POLICY.skip_when_fast, keep: ['listed_verification'] };
     if (LIGHTWEIGHT_ROUTES.has(route?.id))
         return { lane: `${String(route.id).toLowerCase()}_lightweight_lane`, source: 'route_policy', fast_lane_allowed: true, reason: 'Lightweight route bypasses full mission orchestration by design.', blockers: [], skip_when_fast: SPEED_LANE_POLICY.skip_when_fast, keep: ['focused_implementation', 'listed_verification', 'honest_mode'] };
-    if (routeRequiresSubagents(route, task))
-        return { lane: SPEED_LANE_POLICY.full_lane, source: 'route_policy', fast_lane_allowed: false, reason: 'No Proof Field attached and this route normally requires full Naruto evidence.', blockers: ['proof_field_not_attached'], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
+    if (routeRequiresSubagents(route, task, taskProfile))
+        return { lane: 'official_subagent_lane', source: 'task_profile', fast_lane_allowed: false, reason: 'Explicit Naruto or parallel work uses the Codex subagent workflow.', blockers: [], skip_when_fast: [], keep: ['subagent_plan', 'official_subagent_execution', 'parent_integration', 'listed_verification', 'honest_summary'] };
+    if (taskProfile === 'high-risk')
+        return { lane: SPEED_LANE_POLICY.full_lane, source: 'task_profile', fast_lane_allowed: false, reason: 'High-risk work uses the full risk gate profile.', blockers: [], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
     return { lane: SPEED_LANE_POLICY.balanced_lane, source: 'route_policy', fast_lane_allowed: false, reason: 'Balanced parent-owned route until Proof Field proves a narrower lane.', blockers: ['proof_field_not_attached'], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
 }
-function buildPipelineStages(route, task, ambiguity, lane, context7Required, agentPolicy = normalizeAgentPolicy(route, task, {})) {
-    return FULL_ROUTE_STAGES.map((id) => {
-        const optional = optionalStage(route, task, ambiguity, context7Required, id);
-        const skippedByFast = lane.fast_lane_allowed && SPEED_LANE_POLICY.skip_when_fast.includes(id);
-        const skipped = skippedByFast || optional.skip;
-        if (id === AGENT_INTAKE_STAGE_ID) {
-            if (!agentPolicy.required)
-                return agentPipelineStage(agentPolicy);
-            return { ...agentPipelineStage(agentPolicy), status: skipped ? 'skipped' : 'required', reason: skippedByFast ? 'proof_field_fast_lane' : agentPolicy.reason };
-        }
-        return {
-            id,
-            status: skipped ? (optional.notApplicable ? 'not_applicable' : 'skipped') : (id === 'ambiguity_gate' && ambiguity.passed ? 'passed' : 'keep'),
-            reason: skippedByFast ? 'proof_field_fast_lane' : optional.reason
-        };
+function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, lane, context7Required, agentPolicy = normalizeAgentPolicy(route, task, {})) {
+    if (gateProfile === 'none')
+        return [];
+    const ids = [...GATE_PROFILE_STAGES[gateProfile]];
+    const specializedRoute = Boolean(route?.id && !LIGHTWEIGHT_ROUTES.has(route.id) && route.id !== 'SKS');
+    if (looksLikeProblemSolvingRequest(task) && !['Answer', 'Help', 'Wiki'].includes(route?.id))
+        ids.push(SOLUTION_SCOUT_STAGE_ID);
+    if (gateProfile === 'scoped' || gateProfile === 'full' || specializedRoute)
+        ids.push('pipeline_plan', 'focused_implementation');
+    if ((gateProfile === 'full' || specializedRoute) && !ids.includes('ssot_guard'))
+        ids.push('ssot_guard');
+    if (context7Required)
+        ids.push('context7_evidence');
+    if ((gateProfile === 'scoped' || gateProfile === 'full') && !LIGHTWEIGHT_ROUTES.has(route?.id)) {
+        ids.push('triwiki_use_first', 'triwiki_validate_before_final', 'mistake_recall', 'work_order_coverage');
+    }
+    if (routeRequiresSubagents(route, task, taskProfile))
+        ids.push('subagent_plan', 'official_subagent_execution', 'parent_integration');
+    if (agentPolicy.required)
+        ids.push(AGENT_INTAKE_STAGE_ID);
+    if (specializedRoute)
+        ids.push('route_materialization');
+    if (specializedRoute)
+        ids.push('completion_proof');
+    if (reflectionRequiredForRoute(route))
+        ids.push('reflection');
+    return [...new Set(ids)].map((id) => {
+        const configuredGate = STAGE_BLOCKING_GATE[id] || null;
+        const blockingGate = configuredGate === 'safety' && gateProfile !== 'full'
+            ? 'ownership'
+            : configuredGate;
+        const blocking = Boolean(blockingGate);
+        const metadata = { blocking, blocking_gate: blocking ? blockingGate : null };
+        if (id === AGENT_INTAKE_STAGE_ID)
+            return { ...agentPipelineStage(agentPolicy), status: 'required', reason: agentPolicy.reason, ...metadata };
+        if (id === 'ambiguity_gate' && ambiguity?.required === false)
+            return { id, status: 'not_applicable', reason: 'ambiguity_gate_not_required_for_entrypoint', ...metadata };
+        if (id === 'ambiguity_gate' && ambiguity?.passed)
+            return { id, status: 'passed', reason: 'ambiguity_contract_already_sealed', ...metadata };
+        return { id, status: 'keep', reason: lane.fast_lane_allowed ? 'task_profile_minimal_lane' : 'required_by_task_and_route_profile', ...metadata };
     });
 }
-function optionalStage(route, task, ambiguity, context7Required, id) {
-    if (id === AGENT_INTAKE_STAGE_ID && !routeRequiresAgentIntake(route, { task }))
-        return { skip: true, notApplicable: true, reason: 'five_agent_intake_not_required_for_route' };
-    if (id === AGENT_INTAKE_STAGE_ID)
-        return { skip: false, reason: 'serious_route_requires_five_agent_intake' };
-    if (id === SOLUTION_SCOUT_STAGE_ID && !looksLikeProblemSolvingRequest(task))
-        return { skip: true, notApplicable: true, reason: 'no_problem_solving_signal' };
-    if (id === SOLUTION_SCOUT_STAGE_ID && ['Answer', 'Help', 'Wiki'].includes(route?.id))
-        return { skip: true, notApplicable: true, reason: 'route_not_code_repair' };
-    if (id === SOLUTION_SCOUT_STAGE_ID)
-        return { skip: false, reason: 'problem_solving_request_requires_web_similarity_agent' };
-    if (id === 'ambiguity_gate' && ambiguity?.required === false)
-        return { skip: true, notApplicable: true, reason: 'ambiguity_gate_not_required_for_entrypoint' };
-    if (id === 'ambiguity_gate' && CLARIFICATION_BYPASS_ROUTES.has(route?.id))
-        return { skip: true, notApplicable: true, reason: 'route_bypasses_clarification' };
-    if (id === 'context7_evidence' && !context7Required)
-        return { skip: true, notApplicable: true, reason: 'context7_not_required_by_route' };
-    if (id === 'reflection' && !reflectionRequiredForRoute(route))
-        return { skip: true, notApplicable: true, reason: 'reflection_not_required_for_route' };
-    if (['native_agent_intake', 'planning_debate', 'fresh_executor_team'].includes(id) && !routeRequiresSubagents(route, task))
-        return { skip: true, notApplicable: true, reason: 'native_session_team_not_required_by_route' };
-    return { skip: false, reason: 'required_by_lane' };
-}
-function planVerification(route, proof) {
+function planVerification(route, proof, budget) {
+    if (budget === 'none')
+        return [];
     const out = new Set(proof.verification || []);
+    if (budget === 'single-check')
+        out.add('run one focused check for the changed surface');
+    if (budget === 'affected')
+        out.add('run affected tests or checks for changed files');
+    if (budget === 'confidence') {
+        out.add('run the focused build or typecheck for the affected package');
+        out.add('run affected regression tests and the risk-specific safety check');
+    }
+    if (budget === 'release') {
+        out.add('npm run packcheck');
+        out.add('sks selftest --mock --json');
+    }
+    if (route?.id === 'Naruto' || route?.id === 'Team')
+        out.add('validate official subagent evidence and the parent integration summary');
     if (route?.id === 'Team')
         out.add('sks validate-artifacts latest --json');
     if (reflectionRequiredForRoute(route))
         out.add('sks wiki validate .sneakoscope/wiki/context-pack.json');
-    out.add('npm run packcheck');
-    out.add('npm run selftest -- --mock');
     return [...out];
 }
-function planNextActions(route, task, ambiguity, lane, agentPolicy = normalizeAgentPolicy(route, task, {})) {
+function pipelineInvariants(input) {
+    const out = ['no_unrequested_fallback_code'];
+    if (input.verificationBudget !== 'none')
+        out.push('listed_verification');
+    if (input.stages.some((stage) => stage.id === 'ssot_guard' && stage.status !== 'not_applicable'))
+        out.push('ssot_guard');
+    if (input.stages.some((stage) => stage.id === 'triwiki_validate_before_final'))
+        out.push('triwiki_validate_before_final');
+    if (input.gateProfile !== 'none')
+        out.push('honest_summary');
+    return out;
+}
+function planNextActions(route, task, taskProfile, ambiguity, lane, agentPolicy = normalizeAgentPolicy(route, task, {}), missionId = null) {
+    if (taskProfile === 'passthrough' || taskProfile === 'answer')
+        return [];
     if (ambiguity.required && !ambiguity.passed) {
         return [
             `read ${REQUEST_INTAKE_ARTIFACT} and preserve its source-order requirements`,
@@ -396,21 +573,29 @@ function planNextActions(route, task, ambiguity, lane, agentPolicy = normalizeAg
         ];
     }
     const actions = [`read ${REQUEST_INTAKE_ARTIFACT} and use its transformed_prompt`, 'read pipeline-plan.json before work', 'execute kept stages only', 'run listed verification'];
-    if (agentPolicy.required)
-        actions.splice(1, 0, 'run sks agents run latest --json before implementation');
-    if (!lane.fast_lane_allowed && routeRequiresSubagents(route, task)) {
+    if (agentPolicy.required) {
+        const missionArg = String(missionId || '').trim() || '<mission-id>';
+        const routeArg = String(route?.command || route?.id || '$Agent');
+        actions.splice(1, 0, `run sks agent run --mission ${shellQuote(missionArg)} --route ${shellQuote(routeArg)} --agents ${Number(agentPolicy.requested_subagents || agentPolicy.agent_count || 1)} --json before implementation`);
+    }
+    if (!lane.fast_lane_allowed && routeRequiresSubagents(route, task, taskProfile)) {
         actions.splice(1, 0, route?.id === 'Naruto'
-            ? 'materialize Naruto clone roster, work graph, worker proof, and naruto-gate.json before implementation'
-            : 'materialize full Team artifacts before implementation');
+            ? 'read subagent-plan.json, create independent disjoint slices, run the official Codex subagent workflow, wait for all requested agent threads, and integrate their results'
+            : 'materialize the route-specific subagent plan before implementation');
     }
     if (looksLikeProblemSolvingRequest(task))
         actions.splice(1, 0, 'run Solution Scout web search for similar fixes before editing');
     actions.push('refresh/validate TriWiki when required', 'finish with completion summary and Honest Mode');
     return actions;
 }
+function shellQuote(value) {
+    return `'${String(value ?? '').replace(/'/g, `'"'"'`)}'`;
+}
 export function promptPipelineContext(prompt, route = null) {
     const cleanPrompt = stripVisibleDecisionAnswerBlocks(prompt);
     route = route || routePrompt(cleanPrompt);
+    if (!route)
+        return '';
     const required = routeNeedsContext7(route, cleanPrompt);
     const reasoning = routeReasoning(route, cleanPrompt);
     const directFix = route?.id === 'DFix';
@@ -434,7 +619,7 @@ export function promptPipelineContext(prompt, route = null) {
         'Question-shaped directive policy: before using Answer, decide whether a question is a real information request or an implicit instruction/complaint about broken behavior. Rhetorical bug reports, mandatory-policy statements, and "why is this not happening?" execution complaints must route to Naruto, not Answer.',
         'Best-practice prompt shape: extract Goal, Context, Constraints, and Done-when before implementation; keep questions compact and only ask for answers that can change scope, safety, user-facing behavior, or acceptance criteria.',
         chatCaptureIntakeText(),
-        'Default execution routing: general implementation/code-changing prompts promote to Naruto so the normal path is shadow-clone fan-out, hardware-safe concurrency, patch envelopes, verification DAG, and GPT final arbitration. Answer, DFix, Help, Wiki maintenance, and safety-specific routes are intentional exceptions.',
+        'Default execution routing: general implementation/code-changing prompts use the profile-selected parent-owned path; explicit Naruto or parallel work uses the Codex subagent workflow with disjoint slices, official agent threads, parent integration, and scoped verification. Answer, DFix, Help, Wiki maintenance, and safety-specific routes remain intentional exceptions.',
         'Stance: infer the user intent aggressively from rough wording, local context, TriWiki, and conservative defaults; do not surface prequestion sheets before work.',
         subagentExecutionPolicyText(route, cleanPrompt),
         solutionScoutPolicyText(cleanPrompt),
@@ -443,7 +628,7 @@ export function promptPipelineContext(prompt, route = null) {
         skillDreamPolicyText(),
         route?.id === 'PPT'
             ? `${pptPipelineAllowlistPolicyText()} ${getdesignReferencePolicyText()}`
-            : `Design routing: UI/UX uses the Codex App Product Design plugin first for get-context/user-context, research/ideate, prototype/image-to-code/url-to-code, audit/design-qa, and share when available. Treat design.md, design-system-builder, design-ui-editor, design-artifact-expert, and getdesign-reference as compatibility fallback only when the Product Design plugin is unavailable or an existing local design.md must be preserved. Image/logo/raster assets use imagegen, which must prefer Codex App built-in image generation documented at ${CODEX_APP_IMAGE_GENERATION_DOC_URL}. ${CODEX_IMAGEGEN_REQUIRED_POLICY} ${getdesignReferencePolicyText()}`,
+            : `Design routing: UI/UX uses the Codex App Product Design plugin first for get-context/user-context, research/ideate, index/image-to-code/url-to-code, audit/design-qa, and share when available. Treat design.md, design-system-builder, design-ui-editor, design-artifact-expert, and getdesign-reference as compatibility fallback only when the Product Design plugin is unavailable or an existing local design.md must be preserved. Image/logo/raster assets use imagegen, which must prefer Codex App built-in image generation documented at ${CODEX_APP_IMAGE_GENERATION_DOC_URL}. ${CODEX_IMAGEGEN_REQUIRED_POLICY} ${getdesignReferencePolicyText()}`,
         triwikiContextTrackingText(),
         triwikiStagePolicyText(),
         stackCurrentDocsPolicyText(),
@@ -455,7 +640,7 @@ export function promptPipelineContext(prompt, route = null) {
     if (reflectionRequiredForRoute(route))
         lines.push(reflectionInstructionText());
     if (route?.id === 'Naruto')
-        lines.push(`Naruto route: build clone roster, massive work graph, hardware-safe governor, active pool, allocation/rebalance policy, parallel verification DAG, GPT final pack, per-clone proof, session cleanup, reflection, and Honest Mode. $Team is deprecated for new execution missions.`);
+        lines.push('Naruto route: prepare subagent-plan.json, delegate independent slices through official Codex worker/expert agent threads, record SubagentStart/SubagentStop events, wait for every requested thread, integrate the parent summary, run scoped verification, and pass naruto-gate.json. Process counts, PID evidence, clone rosters, custom active pools, and verification DAGs are not completion evidence.');
     if (route?.id === 'Team')
         lines.push(`Team route is a deprecated compatibility surface; use $Naruto for new execution missions. Existing Team mission observation commands remain available.`);
     if (route?.id === 'Goal')
@@ -511,50 +696,74 @@ export function answerOnlyContext(prompt, route = routePrompt(prompt)) {
 export async function prepareRoute(root, prompt, state = {}, opts = {}) {
     const cleanPrompt = stripVisibleDecisionAnswerBlocks(prompt);
     const route = routePrompt(cleanPrompt);
-    const sessionKey = opts.sessionKey || state?._session_key || null;
+    const codexThreadId = String(process.env.CODEX_THREAD_ID || '').trim();
+    const sessionKey = opts.sessionKey || codexThreadId || state?._session_key || null;
     const madSksAuthorization = hasMadSksSignal(cleanPrompt);
     const task = stripDollarCommand(stripMadSksSignal(cleanPrompt)) || stripMadSksSignal(stripDollarCommand(cleanPrompt)) || String(cleanPrompt || '').trim();
     const explicit = Boolean(dollarCommand(cleanPrompt));
     if (!route)
         return { route: null, additionalContext: promptPipelineContext(prompt, null) };
     const dreamContext = await routeSkillDreamContext(root, route, task);
+    const required = routeNeedsContext7(route, cleanPrompt);
+    const reasoning = routeReasoning(route, cleanPrompt);
+    const subagentsRequired = routeRequiresSubagents(route, cleanPrompt);
+    const finish = async (prepared) => {
+        const materialized = subagentsRequired && !['Naruto', 'Team', 'Goal'].includes(route.id)
+            ? await materializeOfficialSubagentOverlay(root, prepared, route, task, { sessionKey, parentModel: opts.parentModel || null })
+            : prepared;
+        return withSkillDreamContext(materialized, dreamContext);
+    };
     if (route.id === 'DFix')
-        return withSkillDreamContext(await prepareDfixQuickRoute(route, task), dreamContext);
+        return finish(await prepareDfixQuickRoute(route, task));
     if (route.id === 'Answer')
-        return withSkillDreamContext(await prepareAnswerOnlyRoute(route, task), dreamContext);
+        return finish(await prepareAnswerOnlyRoute(route, task));
     if (route.id === 'ComputerUse')
-        return withSkillDreamContext(await prepareComputerUseFastRoute(route, task), dreamContext);
+        return finish(await prepareComputerUseFastRoute(route, task));
     if (route.id === 'Wiki')
-        return withSkillDreamContext(await prepareWikiQuickRoute(route, task), dreamContext);
+        return finish(await prepareWikiQuickRoute(route, task));
     if (route.id === 'Goal')
-        return withSkillDreamContext(await prepareGoal(root, route, task, routeNeedsContext7(route, cleanPrompt), { sessionKey }), dreamContext);
+        return finish(await prepareGoal(root, route, task, required, { sessionKey }));
     if (route.id === 'ImageUXReview')
-        return withSkillDreamContext(await prepareImageUxReview(root, route, task, routeNeedsContext7(route, cleanPrompt), { sessionKey }), dreamContext);
+        return finish(await prepareImageUxReview(root, route, task, required, { sessionKey }));
     if (route.id === 'MadDB')
-        return withSkillDreamContext(await prepareMadDb(root, route, task, routeNeedsContext7(route, cleanPrompt), { sessionKey }), dreamContext);
-    const required = routeNeedsContext7(route, cleanPrompt);
-    const reasoning = routeReasoning(route, cleanPrompt);
-    const nativeSessionsRequired = routeRequiresSubagents(route, cleanPrompt);
+        return finish(await prepareMadDb(root, route, task, required, { sessionKey }));
     if (QUESTION_GATE_ROUTES.has(route.id) || route.id === 'MadSKS')
-        return withSkillDreamContext(await prepareClarificationGate(root, route, task, required, { madSksAuthorization, sessionKey }), dreamContext);
+        return finish(await prepareClarificationGate(root, route, task, required, { madSksAuthorization, sessionKey }));
+    if (route.id === 'Naruto' && subagentsRequired)
+        return finish(await prepareNaruto(root, route, task, required, { madSksAuthorization, sessionKey, parentModel: opts.parentModel || null }));
     if (route.id === 'Naruto')
-        return withSkillDreamContext(await prepareNaruto(root, route, task, required, { madSksAuthorization, sessionKey }), dreamContext);
+        return finish(await prepareLightRoute(root, parentOwnedProfileRoute(route), task, required, { sessionKey }));
     if (route.id === 'Team')
-        return withSkillDreamContext(await prepareNaruto(root, { ...route, id: 'Naruto', command: '$Naruto', mode: 'NARUTO', stopGate: 'naruto-gate.json', requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'] }, task, required, { madSksAuthorization, teamAlias: true, sessionKey }), dreamContext);
+        return finish(await prepareNaruto(root, { ...route, id: 'Naruto', command: '$Naruto', mode: 'NARUTO', stopGate: 'naruto-gate.json', requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'] }, task, required, { madSksAuthorization, teamAlias: true, sessionKey, parentModel: opts.parentModel || null }));
     if (route.id === 'Research')
-        return withSkillDreamContext(await prepareResearch(root, route, task, required, { sessionKey }), dreamContext);
+        return finish(await prepareResearch(root, route, task, required, { sessionKey }));
     if (route.id === 'AutoResearch')
-        return withSkillDreamContext(await prepareAutoResearch(root, route, task, required, { sessionKey }), dreamContext);
+        return finish(await prepareAutoResearch(root, route, task, required, { sessionKey }));
     if (route.id === 'DB')
-        return withSkillDreamContext(await prepareDb(root, route, task, required, { sessionKey }), dreamContext);
+        return finish(await prepareDb(root, route, task, required, { sessionKey }));
     if (route.id === 'GX')
-        return withSkillDreamContext(await prepareGx(root, route, task, required, { sessionKey }), dreamContext);
+        return finish(await prepareGx(root, route, task, required, { sessionKey }));
     if (explicit || required)
-        return withSkillDreamContext(await prepareLightRoute(root, route, task, required, { sessionKey }), dreamContext);
-    return withSkillDreamContext({
+        return finish(await prepareLightRoute(root, route, task, required, { sessionKey }));
+    return finish({
         route,
-        additionalContext: `${promptPipelineContext(prompt, route)}\n\nReasoning: ${reasoning.effort} (${reasoning.reason}); temporary profile ${reasoning.profile}.\nRequired skills: ${route.requiredSkills.join(', ')}.\nNative sessions required: ${nativeSessionsRequired ? 'yes' : 'no'}.`
-    }, dreamContext);
+        additionalContext: `${promptPipelineContext(prompt, route)}\n\nReasoning: ${reasoning.effort} (${reasoning.reason}); temporary profile ${reasoning.profile}.\nRequired skills: ${route.requiredSkills.join(', ')}.\nOfficial subagents required: ${subagentsRequired ? 'yes' : 'no'}.`
+    });
+}
+function parentOwnedProfileRoute(route) {
+    return {
+        ...route,
+        id: 'SKS',
+        command: '$SKS',
+        mode: 'SKS',
+        route: 'profiled parent-owned execution',
+        description: 'Parent-owned bounded execution selected by the task profile; no subagent workflow is required.',
+        requiredSkills: ['pipeline-runner', 'prompt-pipeline', 'honest-mode'],
+        lifecycle: ['task_profile', 'ownership', 'focused_implementation', 'listed_verification', 'honest_summary'],
+        stopGate: 'honest_mode',
+        coverage_required: false,
+        explicit_invocation: false
+    };
 }
 async function routeSkillDreamContext(root, route, task) {
     try {
@@ -695,14 +904,13 @@ export async function activeRouteContext(root, state) {
             ? ' Context7 evidence is still required before completion: use resolve-library-id, then query-docs (or legacy get-library-docs).'
             : '';
         const roles = state.role_counts ? ` Role counts: ${formatLegacyRoleCounts(state.role_counts)}.` : '';
-        return `Active Team mission ${state.mission_id || 'latest'} must keep the user-visible live transcript updated. Native session budget: ${state.agent_sessions || MIN_TEAM_REVIEWER_LANES}.${roles} Run native sessions, TriWiki refresh, debate, consensus, fresh development, minimum ${MIN_TEAM_REVIEWER_LANES}-lane review/integration, then close or account for every Team native session and write ${TEAM_SESSION_CLEANUP_ARTIFACT} before reflection/final. ${MIN_TEAM_REVIEW_POLICY_TEXT} After each native-session status/result/handoff, run: sks team event ${state.mission_id || 'latest'} --agent <name> --phase <phase> --message "...". Inspect with sks team log/watch ${state.mission_id || 'latest'}.${reasoningNote}${context7}${planNote}`;
+        return `Legacy Team mission ${state.mission_id || 'latest'} must keep its existing live transcript and compatibility artifacts current.${roles} New Team invocations redirect to the Naruto official Codex subagent workflow; this context is only for finishing a pre-6.1.1 Team mission. Preserve its original minimum ${MIN_TEAM_REVIEWER_LANES}-lane review/integration and ${TEAM_SESSION_CLEANUP_ARTIFACT} contract before reflection/final. ${MIN_TEAM_REVIEW_POLICY_TEXT} Inspect with sks team log/watch ${state.mission_id || 'latest'}.${reasoningNote}${context7}${planNote}`;
     }
     if (state.mode === 'NARUTO') {
-        const clones = state.clone_count ? ` Clone count: ${state.clone_count}.` : '';
-        return `Active Naruto mission ${state.mission_id || 'latest'} must keep clone/worker evidence current.${clones} Use sks naruto status ${state.mission_id || 'latest'} --json, inspect .sneakoscope/missions/${state.mission_id || 'latest'}/naruto-gate.json and agents/agent-proof-evidence.json, then continue until the Naruto gate passes or a hard blocker is recorded.${reasoningNote}${planNote}`;
+        return `Active Naruto mission ${state.mission_id || 'latest'} uses the official Codex subagent workflow. Read subagent-plan.json, keep ${SUBAGENT_EVENT_LOG_FILENAME} and ${SUBAGENT_EVIDENCE_FILENAME} current from SubagentStart/SubagentStop, wait for all requested agent threads, then return the exact sks.subagent-parent-summary.v1 JSON result so SKS can persist ${SUBAGENT_PARENT_SUMMARY_FILENAME} and derive naruto-summary.json/naruto-gate.json. Do not substitute process counts, PID evidence, clone artifacts, or a custom active pool.${reasoningNote}${planNote}`;
     }
     if (state.subagents_required && !(await hasSubagentEvidence(root, state))) {
-        return `Active SKS route ${id} requires native multi-session evidence before code-changing work can be considered complete. Run worker/reviewer native sessions for disjoint write scopes, or record explicit unavailable/unsplittable native-session evidence before editing.${reasoningNote}${planNote}`;
+        return `Active SKS route ${id} requires official subagent evidence before completion. Delegate independent slices to worker/expert custom agents, record matched SubagentStart/SubagentStop thread ids, wait for every requested agent thread, and provide the parent integration summary.${reasoningNote}${planNote}`;
     }
     if (state.mode === 'GOAL')
         return `Active Goal mission ${state.mission_id || 'latest'} uses Codex native /goal continuation. Inspect .sneakoscope/missions/${state.mission_id || 'latest'}/${GOAL_WORKFLOW_ARTIFACT}, then use /goal create, pause, resume, or clear in the Codex runtime as appropriate.${planNote}`;
@@ -728,7 +936,17 @@ async function prepareGoal(root, route, task, required, opts = {}) {
     const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt: task, sessionKey: opts.sessionKey });
     const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt: task });
     await writeJsonAtomic(path.join(dir, 'route-context.json'), { route: route.id, command: route.command, mode: route.mode, task, required_skills: route.requiredSkills, context7_required: required, native_goal: workflow.native_goal, stop_gate: route.stopGate });
-    const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'not_required' } });
+    const pipelinePlan = await writePipelinePlan(dir, {
+        missionId: id,
+        route,
+        task,
+        required,
+        ambiguity: { required: false, status: 'not_required' },
+        // Goal is a lightweight persistence overlay, but its mission still owns the
+        // durable request-intake/plan contract. Question-shaped or vague Goal tasks
+        // must not be mistaken for answer-only work and skip artifact writes.
+        forceLightweightPlan: true
+    });
     const executionRoute = routePrompt(task);
     const shouldDelegateExecution = routeRequiresSubagents(route, task)
         && executionRoute
@@ -811,6 +1029,7 @@ async function prepareClarificationGate(root, route, task, required, opts = {})
         const materializedLine = materialized.phase ? `\nRoute artifacts were materialized immediately; state advanced to ${materialized.phase}.` : '';
         return {
             route,
+            mission_id: id,
             additionalContext: `${promptPipelineContext(task, route)}
 
 Route contract auto-sealed for ${route.command}: contract answers were inferred from the prompt, TriWiki/current-code defaults, and conservative SKS safety policy.
@@ -945,10 +1164,10 @@ async function materializeMadSksAuthorization(dir, id, route, routeContext = {},
 }
 async function prepareResearch(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: 'research', prompt: task, sessionKey: opts.sessionKey });
-    await writeResearchPlan(dir, task, {});
+    const researchPlan = await writeResearchPlan(dir, task, {});
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
     await setCurrent(root, routeState(id, route, 'RESEARCH_PREPARED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
-    return routeContext(route, id, task, required, 'Run sks research run latest as a real long-running source-gathering pass, never an automatic mock fallback; do not modify repository source code; create research-source-skill.md, maximize layered public source search, require every agent effort=xhigh plus one Eureka! idea, repeat agent/debate/falsification cycles until unanimous_consensus=true for every agent or the explicit safety cap pauses the run, fill source-ledger.json, agent-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, genius-opinion-summary.md, and pass research-gate.json.');
+    return routeContext(route, id, task, required, `Run sks research run latest as a real long-running source-gathering pass, never an automatic mock fallback; do not modify repository source code. Run layered Super Search first and allow only correlated verified-content rows to support real claims. Then run exactly three independent official research_reviewer threads on GPT-5.6 Sol Max. Any objection requires a mission-local research_synthesizer revision and a fresh three-thread review cycle; do not launch a custom scheduler or debate pool. Treat agent-ledger.json and debate-ledger.json as compatibility projections, write research-report.md and ${researchPaperArtifactForPlan(researchPlan)}, and pass the adversarial convergence, Honest Mode, and research-gate.json checks.`);
 }
 async function prepareAutoResearch(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: 'autoresearch', prompt: task, sessionKey: opts.sessionKey });
@@ -966,7 +1185,7 @@ async function prepareDb(root, route, task, required, opts = {}) {
     await writeJsonAtomic(path.join(dir, 'db-review.json'), { passed: false, scan_ok: scan.ok, destructive_operation_zero: true, safe_mcp_policy: false, context7_evidence: false, notes: [] });
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
     await setCurrent(root, routeState(id, route, 'DB_REVIEW_REQUIRED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
-    return routeContext(route, id, task, required, 'Run sks db policy/scan/check as needed, keep DB operations read-only, record safe MCP policy, and pass db-review.json.');
+    return routeContext(route, id, task, required, 'Inspect the automatically materialized db-safety-scan.json, keep database operations read-only, record safe MCP and current-docs evidence, and pass db-review.json. The legacy sks db CLI is removed; explicitly authorized SQL-plane work uses sks mad-sks.');
 }
 async function prepareMadDb(root, route, task, required, opts = {}) {
     const prepared = await prepareMadDbMission({ root, task, verifyTools: false, sessionKey: opts.sessionKey, route: 'MadSKS', routeCommand: '$MAD-SKS' });
@@ -1018,10 +1237,101 @@ async function prepareLightRoute(root, route, task, required, opts = {}) {
     await setCurrent(root, routeState(id, route, 'ROUTE_CONTEXT_READY', required, { prompt: task, stop_gate: 'none', pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, task, required, 'Load the route skill context, execute the smallest matching action, and finish with Honest Mode.');
 }
+async function materializeOfficialSubagentOverlay(root, prepared, route, task, opts = {}) {
+    const id = String(prepared?.mission_id || '').trim();
+    if (!id)
+        throw new Error(`official_subagent_overlay_mission_missing:${route?.id || 'unknown'}`);
+    const dir = missionDir(root, id);
+    const cleanTask = stripDollarCommand(task) || String(task || '').trim();
+    await createAndWriteWorkOrderLedgerForPrompt(dir, {
+        missionId: id,
+        route: route?.command || route?.id || 'official-subagent-overlay',
+        prompt: cleanTask
+    });
+    const requestedSubagents = requestedSubagentsFromTask(cleanTask);
+    const observedParentModel = typeof opts.parentModel === 'string' && opts.parentModel.trim()
+        ? opts.parentModel.trim()
+        : null;
+    const preparation = await prepareOfficialSubagentMission({
+        root,
+        dir,
+        missionId: id,
+        goal: cleanTask,
+        route: route?.command || route?.id || 'specialized-route',
+        sessionScope: opts.sessionKey || null,
+        ...(requestedSubagents === undefined ? {} : { requestedSubagents }),
+        requestedSubagentsExplicit: requestedSubagents !== undefined,
+        mode: 'generic',
+        observedParentModel,
+        preparationOnly: true
+    });
+    const { budget, delegationPrompt, plan } = preparation;
+    await setCurrent(root, {
+        mission_id: id,
+        subagents_required: true,
+        subagents_verified: false,
+        native_sessions_required: false,
+        native_sessions_verified: false,
+        agents_required: false,
+        requested_subagents: budget.requestedSubagents,
+        subagent_max_threads: budget.maxThreads,
+        subagent_max_depth: budget.maxDepth,
+        official_subagent_run_id: plan.workflow_run_id,
+        session_scope: opts.sessionKey || null,
+        subagent_plan_file: SUBAGENT_PLAN_FILENAME,
+        subagent_evidence_file: SUBAGENT_EVIDENCE_FILENAME
+    }, { sessionKey: opts.sessionKey });
+    return {
+        ...prepared,
+        mission_id: id,
+        additionalContext: [
+            prepared.additionalContext,
+            `Official Codex subagent overlay for ${route?.command || route?.id || 'this route'}: use ${SUBAGENT_PLAN_FILENAME}, record matched SubagentStart/SubagentStop events in ${SUBAGENT_EVENT_LOG_FILENAME}, and provide the required structured parent thread-outcome summary before this route's own gate can pass. This generic overlay does not create ${NARUTO_SUMMARY_FILENAME}, ${NARUTO_GATE_FILENAME}, or close the work-order ledger.`,
+            delegationPrompt
+        ].filter(Boolean).join('\n\n')
+    };
+}
 async function prepareNaruto(root, route, task, required, opts = {}) {
     const cleanTask = stripDollarCommand(task) || String(task || '').trim();
     const fromChatImgRequired = hasFromChatImgSignal(cleanTask);
-    const { id, dir } = await createMission(root, { mode: 'naruto', prompt: cleanTask, sessionKey: opts.sessionKey });
+    const requestedSubagents = requestedSubagentsFromTask(cleanTask);
+    const observedParentModel = typeof opts.parentModel === 'string' && opts.parentModel.trim()
+        ? opts.parentModel.trim()
+        : null;
+    const mission = opts.sessionKey
+        ? await getOrCreateSessionMission(root, {
+            mode: 'naruto',
+            prompt: cleanTask,
+            sessionKey: opts.sessionKey,
+            selectMissionId: (state) => {
+                const activeRoute = String(state?.route || state?.route_command || state?.mode || '').replace(/^\$/, '').toUpperCase();
+                const sessionMatches = state?._session_key === sessionStateKey(opts.sessionKey);
+                return sessionMatches && state?.mission_id && state?.route_closed !== true && activeRoute === 'NARUTO'
+                    ? String(state.mission_id)
+                    : null;
+            }
+        })
+        : await createMission(root, { mode: 'naruto', prompt: cleanTask, sessionKey: opts.sessionKey });
+    const { id, dir } = mission;
+    await createAndWriteWorkOrderLedgerForPrompt(dir, {
+        missionId: id,
+        route: 'Naruto',
+        prompt: cleanTask
+    });
+    const preparation = await prepareOfficialSubagentMission({
+        root,
+        dir,
+        missionId: id,
+        goal: cleanTask,
+        route: '$Naruto',
+        sessionScope: opts.sessionKey || null,
+        ...(requestedSubagents === undefined ? {} : { requestedSubagents }),
+        requestedSubagentsExplicit: requestedSubagents !== undefined,
+        mode: 'naruto',
+        observedParentModel,
+        preparationOnly: true
+    });
+    const { budget, delegationPrompt, workflowRunId, taskProfile, officialConfig, triwikiAttention, parentModelMatch } = preparation;
     const routeContextPayload = {
         route: 'Naruto',
         command: '$Naruto',
@@ -1030,34 +1340,34 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
         required_skills: route.requiredSkills || ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         context7_required: required,
         context_tracking: triwikiContextTracking(),
-        stop_gate: 'naruto-gate.json',
+        stop_gate: NARUTO_GATE_FILENAME,
+        workflow: 'official_codex_subagent',
+        workflow_run_id: workflowRunId,
+        session_scope: opts.sessionKey || null,
+        requested_subagents: budget.requestedSubagents,
+        requested_subagents_explicit: requestedSubagents !== undefined,
+        max_threads: budget.maxThreads,
+        max_depth: budget.maxDepth,
+        parent_model_policy: NARUTO_PARENT_MODEL,
+        observed_parent_model: observedParentModel,
+        parent_model_match: parentModelMatch,
+        config_sources: officialConfig.sources,
+        config_blockers: officialConfig.blockers,
+        triwiki_attention: triwikiAttention,
         team_alias: opts.teamAlias === true,
         from_chat_img_required: fromChatImgRequired,
         mad_sks_authorization: Boolean(opts.madSksAuthorization)
     };
     await writeJsonAtomic(path.join(dir, 'route-context.json'), routeContextPayload);
-    await writeJsonAtomic(path.join(dir, 'naruto-gate.json'), {
-        schema: 'sks.naruto-gate.v1',
-        passed: false,
-        mission_id: id,
-        clone_roster_built: false,
-        work_graph_ready: false,
-        role_distribution_ready: false,
-        allocation_ready: false,
-        rebalance_ready: false,
-        concurrency_governor_ready: false,
-        active_pool_ready: false,
-        verification_dag_ready: false,
-        gpt_final_pack_ready: false,
-        zellij_dashboard_ready: false,
-        native_agent_proof: false,
-        final_arbiter_accepted: false,
-        session_cleanup: false,
-        ...(fromChatImgRequired ? { from_chat_img_required: true, from_chat_img_request_coverage: false } : {}),
-        blockers: ['naruto_run_not_started'],
-        updated_at: nowIso()
-    });
-    const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: cleanTask, required, ambiguity: { required: false, status: opts.teamAlias ? 'team_alias_to_naruto' : 'direct_naruto' } });
+    if (fromChatImgRequired) {
+        const gate = await readJson(path.join(dir, NARUTO_GATE_FILENAME), {});
+        await writeJsonAtomic(path.join(dir, NARUTO_GATE_FILENAME), {
+            ...gate,
+            from_chat_img_required: true,
+            from_chat_img_request_coverage: false
+        });
+    }
+    const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: cleanTask, taskProfile, required, ambiguity: { required: false, status: opts.teamAlias ? 'team_alias_to_naruto' : 'direct_naruto' } });
     await setCurrent(root, routeState(id, route, 'NARUTO_READY', required, {
         prompt: cleanTask,
         route: 'Naruto',
@@ -1066,26 +1376,45 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
         implementation_allowed: true,
         ambiguity_gate_required: false,
         ambiguity_gate_passed: true,
-        stop_gate: 'naruto-gate.json',
+        stop_gate: NARUTO_GATE_FILENAME,
         required_skills: routeContextPayload.required_skills,
         subagents_required: true,
-        native_sessions_required: true,
+        native_sessions_required: false,
+        agents_required: false,
+        requested_subagents: budget.requestedSubagents,
+        subagent_max_threads: budget.maxThreads,
+        subagent_max_depth: budget.maxDepth,
+        subagent_plan_file: SUBAGENT_PLAN_FILENAME,
+        subagent_evidence_file: SUBAGENT_EVIDENCE_FILENAME,
+        official_subagent_run_id: workflowRunId,
+        session_scope: opts.sessionKey || null,
+        observed_parent_model: observedParentModel,
+        parent_model_match: parentModelMatch,
         from_chat_img_required: fromChatImgRequired,
-        naruto_gate_file: 'naruto-gate.json',
+        naruto_gate_file: NARUTO_GATE_FILENAME,
         pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
         pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
     }), { sessionKey: opts.sessionKey });
-    return routeContext(route, id, cleanTask, required, `Run sks naruto run ${JSON.stringify(cleanTask)} --json (or continue with Codex native workers for the same mission), then update naruto-gate.json from the worker proof and verification DAG.`);
+    return routeContext(route, id, cleanTask, required, `Use the delegation context below in the current Codex parent session. First replace parent_required with a defensible independent/disjoint decomposition, then spawn and wait for every requested agent thread. Record official events and integrate the parent summary before passing ${NARUTO_GATE_FILENAME}.\n\n${delegationPrompt}`);
+}
+function requestedSubagentsFromTask(task) {
+    const text = String(task || '');
+    const value = text.match(/(?:^|\s)--agents(?:=|\s+)(\d+)\b/i)?.[1];
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
 }
 function routeState(id, route, phase, context7Required, extra = {}) {
     const reasoning = routeReasoning(route, extra.prompt || '');
-    const nativeSessionsRequired = routeRequiresSubagents(route, extra.prompt || '');
-    return { mission_id: id, route: route.id, route_command: route.command, mode: route.mode, phase, context7_required: context7Required, context7_verified: false, subagents_required: false, subagents_verified: true, native_sessions_required: nativeSessionsRequired, native_sessions_verified: false, agents_required: routeRequiresAgentIntake(route, { task: extra.prompt }), agent_count: AGENT_COUNT, reflection_required: reflectionRequiredForRoute(route), visible_progress_required: true, context_tracking: 'triwiki', required_skills: route.requiredSkills, stop_gate: route.stopGate, reasoning_effort: reasoning.effort, reasoning_profile: reasoning.profile, reasoning_temporary: true, goal_continuation: ambientGoalContinuation(), ...extra };
+    const subagentsRequired = routeRequiresSubagents(route, extra.prompt || '');
+    return { mission_id: id, route: route.id, route_command: route.command, mode: route.mode, phase, context7_required: context7Required, context7_verified: false, subagents_required: subagentsRequired, subagents_verified: !subagentsRequired, native_sessions_required: false, native_sessions_verified: false, agents_required: subagentsRequired ? false : routeRequiresAgentIntake(route, { task: extra.prompt }), reflection_required: reflectionRequiredForRoute(route), visible_progress_required: true, context_tracking: 'triwiki', required_skills: route.requiredSkills, stop_gate: route.stopGate, reasoning_effort: reasoning.effort, reasoning_profile: reasoning.profile, reasoning_temporary: true, goal_continuation: ambientGoalContinuation(), ...extra };
 }
 function routeContext(route, id, task, required, next) {
     const visibleTask = stripVisibleDecisionAnswerBlocks(task);
     return {
         route,
+        mission_id: id,
         additionalContext: `${promptPipelineContext(visibleTask, route)}
 
 ${route.command} route prepared.
@@ -1096,7 +1425,7 @@ Execution prompt: request-intake.transformed_prompt
 Pipeline plan: .sneakoscope/missions/${id}/${PIPELINE_PLAN_ARTIFACT}
 Required skills: ${route.requiredSkills.join(', ')}
 Stop gate: ${route.stopGate}
-Native sessions: ${routeRequiresSubagents(route, visibleTask) ? 'required before code-changing execution; run parallel workers/reviewers with disjoint ownership or record explicit unavailable/unsplittable evidence.' : 'optional'}
+Official subagents: ${routeRequiresSubagents(route, visibleTask) ? 'required for this explicit Naruto/parallel task; use independent disjoint slices, official agent threads, matched SubagentStart/SubagentStop events, and a parent integration summary.' : 'not required by this task profile; keep the work parent-owned unless a concrete independent decomposition emerges.'}
 TriWiki: use only the latest coordinate+voxel-overlay context pack before each route phase, hydrate low-trust claims during the phase, refresh after new findings or artifact changes, and validate before handoffs/final claims. Coordinate-only legacy packs are invalid and must be refreshed before pipeline decisions.
 Final closeout: every pipeline final answer must summarize what was done, what changed for the user/repo, what was verified, and any remaining gaps.
 ${reflectionRequiredForRoute(route) ? `Reflection: ${reflectionInstructionText()}` : 'Reflection: not required for this lightweight route.'}
@@ -1175,19 +1504,26 @@ export async function recordContext7Evidence(root, state, payload) {
     return record;
 }
 export async function recordSubagentEvidence(root, state, payload) {
-    const stage = subagentStage(payload);
-    if (!stage)
-        return null;
     if (!await shouldWritePipelineEvidence(root, state))
         return null;
-    const record = { ts: nowIso(), stage, tool: subagentToolName(payload), payload_keys: Object.keys(payload || {}).sort() };
     const id = state?.mission_id;
-    const file = id ? path.join(missionDir(root, id), 'subagent-evidence.jsonl') : path.join(root, '.sneakoscope', 'state', 'subagent-evidence.jsonl');
-    await appendJsonl(file, record);
-    if (id) {
-        const evidence = await subagentEvidence(root, state);
-        await setCurrent(root, { subagents_spawned: evidence.spawn, subagents_reported: evidence.result, subagents_verified: evidence.ok }, { sessionKey: state._session_key });
-    }
+    const dir = id ? missionDir(root, id) : path.join(root, '.sneakoscope', 'state', 'subagents');
+    const explicitEventName = payload?.hook_event_name
+        || payload?.hookEventName
+        || payload?.event_name
+        || payload?.eventName
+        || payload?.event
+        || null;
+    const officialEvent = await recordSubagentEvent(dir, payload, explicitEventName);
+    if (officialEvent)
+        return officialEvent;
+    if (!legacySubagentWorkflowEnabled(state))
+        return null;
+    const stage = legacySubagentStage(payload);
+    if (!stage)
+        return null;
+    const record = { ts: nowIso(), stage, tool: legacySubagentToolName(payload), payload_keys: Object.keys(payload || {}).sort(), workflow: 'legacy_process_swarm' };
+    await appendJsonl(path.join(dir, 'subagent-evidence.jsonl'), record);
     return record;
 }
 async function shouldWritePipelineEvidence(root, state = {}) {
@@ -1195,11 +1531,11 @@ async function shouldWritePipelineEvidence(root, state = {}) {
         return exists(missionDir(root, state.mission_id));
     return exists(path.join(root, '.sneakoscope', 'state', 'current.json'));
 }
-function subagentToolName(payload) {
+function legacySubagentToolName(payload) {
     const obj = payload || {};
     return String(obj.tool_name || obj.name || obj.tool?.name || obj.mcp_tool || obj.command || obj.type || '');
 }
-function subagentStage(payload) {
+function legacySubagentStage(payload) {
     const hay = JSON.stringify(payload || {});
     // Codex 0.139 renamed multi-agent v2 `close_agent` to `interrupt_agent`;
     // accept both so cockpit evidence keeps classifying on newer CLIs.
@@ -1209,10 +1545,8 @@ function subagentStage(payload) {
         return 'exception';
     if (/spawn_agent/i.test(hay))
         return 'spawn_agent';
-    for (const name of ['interrupt_agent', 'close_agent']) {
-        if (hay.includes(name) && normalizeCodexMultiAgentEventName(name).stage === 'result')
-            return 'result';
-    }
+    if (/interrupt_agent|close_agent/i.test(hay))
+        return 'result';
     if (/wait_agent|completed|final/i.test(hay))
         return 'result';
     return 'subagent';
@@ -1220,8 +1554,44 @@ function subagentStage(payload) {
 export async function subagentEvidence(root, state) {
     const id = state?.mission_id;
     if (!id)
-        return { spawn: false, result: false, exception: false, ok: false, count: 0 };
-    const text = await readText(path.join(missionDir(root, id), 'subagent-evidence.jsonl'), '');
+        return { spawn: false, result: false, exception: false, ok: false, count: 0, workflow: 'official_codex_subagent' };
+    const dir = missionDir(root, id);
+    const plan = await readJson(path.join(dir, 'subagent-plan.json'), null).catch(() => null);
+    if (plan?.workflow === 'official_codex_subagent') {
+        const [events, persistedParentSummary, summary, canonical] = await Promise.all([
+            readSubagentEvents(dir),
+            readJson(path.join(dir, SUBAGENT_PARENT_SUMMARY_FILENAME), null).catch(() => null),
+            readJson(path.join(dir, 'naruto-summary.json'), null).catch(() => null),
+            readJson(path.join(dir, SUBAGENT_EVIDENCE_FILENAME), null).catch(() => null)
+        ]);
+        const evidence = buildSubagentEvidence({
+            requestedSubagents: Number(plan.requested_subagents || 0),
+            events,
+            parentSummary: persistedParentSummary,
+            workflowStatus: summary?.status || null,
+            preparationOnly: summary?.status === 'delegation_context_ready' || canonical?.preparation_only === true,
+            additionalBlockers: Array.isArray(plan.config_blockers)
+                ? plan.config_blockers.map((item) => `official_subagent_config:${String(item)}`)
+                : []
+        });
+        const canonicalMismatch = canonicalEvidenceMismatch(canonical, evidence);
+        const blockers = [...new Set([
+                ...(Array.isArray(evidence.blockers) ? evidence.blockers : []),
+                ...(canonicalMismatch ? [canonicalMismatch] : [])
+            ])];
+        return {
+            ...evidence,
+            ok: evidence.ok === true && blockers.length === 0,
+            blockers,
+            spawn: evidence.started_threads > 0,
+            result: evidence.completed_threads > 0,
+            exception: evidence.failed_threads > 0,
+            count: events.length
+        };
+    }
+    if (!legacySubagentWorkflowEnabled(state))
+        return { spawn: false, result: false, exception: false, ok: false, count: 0, workflow: 'official_codex_subagent' };
+    const text = await readText(path.join(dir, 'subagent-evidence.jsonl'), '');
     const lines = text.split(/\n/).filter(Boolean);
     let spawn = false;
     let result = false;
@@ -1238,11 +1608,39 @@ export async function subagentEvidence(root, state) {
         }
         catch { }
     }
-    return { spawn, result, exception, ok: spawn || exception, count: lines.length };
+    return { spawn, result, exception, ok: spawn || exception, count: lines.length, workflow: 'legacy_process_swarm' };
+}
+function canonicalEvidenceMismatch(canonical, recomputed) {
+    if (canonical?.schema !== 'sks.subagent-evidence.v1' || canonical?.workflow !== 'official_codex_subagent') {
+        return 'persisted_subagent_evidence_schema_invalid';
+    }
+    const scalarKeys = [
+        'requested_subagents', 'started_threads', 'completed_threads', 'failed_threads',
+        'parent_summary_present', 'parent_summary_trustworthy', 'parent_summary_status',
+        'preparation_only', 'status', 'ok'
+    ];
+    for (const key of scalarKeys) {
+        if (canonical?.[key] !== recomputed?.[key])
+            return `persisted_subagent_evidence_mismatch:${key}`;
+    }
+    const arrayKeys = [
+        'started_thread_ids', 'completed_thread_ids', 'failed_thread_ids', 'open_thread_ids',
+        'unmatched_stop_thread_ids', 'ambiguous_stop_thread_ids', 'event_sources', 'blockers'
+    ];
+    for (const key of arrayKeys) {
+        if (JSON.stringify(canonical?.[key] || []) !== JSON.stringify(recomputed?.[key] || [])) {
+            return `persisted_subagent_evidence_mismatch:${key}`;
+        }
+    }
+    return null;
 }
 export async function hasSubagentEvidence(root, state) {
     return (await subagentEvidence(root, state)).ok;
 }
+function legacySubagentWorkflowEnabled(state = {}) {
+    return state?.legacy_subagent_workflow === true
+        || state?.workflow === 'legacy_process_swarm';
+}
 function context7ToolName(payload) {
     const obj = payload || {};
     return String(obj.tool_name || obj.name || obj.tool?.name || obj.mcp_tool || obj.command || obj.type || '');