sneakoscope 6.2.0 → 6.4.0

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

@@ -17,18 +17,17 @@ 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';
 import { responseLanguageInstruction } from '../language-preference.js';
-import { SSOT_GUARD_ARTIFACT, buildSsotGuard, ssotGuardPolicyText } from '../safety/ssot-guard.js';
+import { buildSsotGuard, ssotGuardPolicyText } from '../safety/ssot-guard.js';
 import { SPEED_LANE_POLICY } from '../proof-field.js';
 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 } from '../agents/agent-schema.js';
-import { normalizeAgentPolicy, routeRequiresAgentIntake, agentPipelineStage } from '../agents/agent-plan.js';
-import { readAgentGateStatus } from '../agents/agent-gate.js';
+import { prepareMadSksSqlPlaneMission } from '../mad-sks/sql-plane/coordinator.js';
+import { MAD_SKS_SQL_PLANE_CAPABILITY_FILE, madSksSqlPlaneRelativePath } from '../mad-sks/sql-plane/paths.js';
+import { OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID } from '../agents/agent-schema.js';
+import { normalizeOfficialSubagentPolicy, officialSubagentPipelineStage } from '../agents/agent-plan.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 { classifyTaskProfile, gateProfileForTask } from '../runtime/task-profile.js';
 import { chooseVerificationBudget } from '../runtime/verification-budget.js';
 import { NARUTO_PARENT_MODEL } from '../subagents/model-policy.js';
@@ -51,7 +50,6 @@ function ambientGoalContinuation() {
 const REFLECTION_ARTIFACT = 'reflection.md';
 const REFLECTION_GATE = 'reflection-gate.json';
 const REFLECTION_MEMORY_PATH = '.sneakoscope/memory/q2_facts/post-route-reflection.md';
-const TEAM_SESSION_CLEANUP_ARTIFACT = 'team-session-cleanup.json';
 const COMPLIANCE_LOOP_GUARD_ARTIFACT = 'compliance-loop-guard.json';
 const HARD_BLOCKER_ARTIFACT = 'hard-blocker.json';
 const DEFAULT_COMPLIANCE_LOOP_LIMIT = 3;
@@ -78,7 +76,6 @@ const STAGE_BLOCKING_GATE = Object.freeze({
     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',
@@ -110,15 +107,21 @@ export function buildPipelinePlan(input = {}) {
     const proof = normalizeProofField(input.proofField);
     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 explicitSubagentOptions = input.agents && typeof input.agents === 'object' && !Array.isArray(input.agents)
+        ? input.agents
+        : input.agents === undefined
+            ? {}
+            : { agents: input.agents };
+    const officialSubagentPolicy = normalizeOfficialSubagentPolicy(route, task, {
+        ...explicitSubagentOptions,
+        required: subagentsRequired,
+        taskProfile
+    });
     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 stages = buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, lane, Boolean(input.required), officialSubagentPolicy);
     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);
@@ -185,10 +188,10 @@ export function buildPipelinePlan(input = {}) {
         lean_decision: leanDecision,
         ssot_guard: buildSsotGuard({ route: route?.id || 'SKS', mode: route?.mode || 'SKS', task }),
         route_economy: routeEconomy,
-        agent_intake: agentPolicy,
+        official_subagents: officialSubagentPolicy,
         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, taskProfile, ambiguity, lane, agentPolicy, input.missionId),
+        next_actions: planNextActions(route, task, taskProfile, ambiguity, lane),
         no_unrequested_fallback_code: true
     };
 }
@@ -196,9 +199,9 @@ 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))
+    if (['DB', 'MadSKS', '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))
+    if (['Research', 'AutoResearch', 'QALoop', 'PPT', 'ImageUXReview', 'GX', 'DB', 'MadSKS', 'ReleaseReview'].includes(routeId))
         return 'bounded-work';
     return classified;
 }
@@ -292,15 +295,15 @@ export function validatePipelinePlan(plan = {}) {
     }
     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
+    if (plan.official_subagents?.required && !plan.stages?.some((stage) => stage.id === OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID
         && stage.workflow === 'official_codex_subagent'
-        && Number(stage.requested_subagents || 0) === Number(plan.agent_intake.requested_subagents || 0)
+        && Number(stage.requested_subagents || 0) === Number(plan.official_subagents.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');
+        issues.push('official_subagent_execution_stage');
     return { ok: issues.length === 0, issues };
 }
 function validateRequiredGateProfileStages(plan, gateProfile) {
@@ -420,7 +423,7 @@ function normalizeProofField(report) {
         source_hash: report.source_hash || null,
         contract_clarity: report.contract_clarity || null,
         workflow_complexity: report.workflow_complexity || null,
-        team_trigger_matrix: report.team_trigger_matrix || null,
+        naruto_trigger_matrix: report.naruto_trigger_matrix || null,
         verification_stage_cache: report.verification_stage_cache || null,
         decision_lattice: report.decision_lattice || null
     };
@@ -434,7 +437,7 @@ function routeEconomyPlan(proof = {}) {
             reason: proof.reason || 'Proof Field not attached yet'
         };
     }
-    const triggers = proof.team_trigger_matrix?.active_triggers || [];
+    const triggers = proof.naruto_trigger_matrix?.active_triggers || [];
     return {
         schema_version: 1,
         mode: 'report_only',
@@ -444,8 +447,8 @@ function routeEconomyPlan(proof = {}) {
         ask_recommended: proof.contract_clarity?.ask_recommended === true,
         workflow_complexity_score: Number(proof.workflow_complexity?.score || 0),
         workflow_complexity_band: proof.workflow_complexity?.band || null,
-        team_trigger_count: triggers.length,
-        active_team_triggers: triggers,
+        naruto_trigger_count: triggers.length,
+        active_naruto_triggers: triggers,
         verification_stage_cache_key: proof.verification_stage_cache?.cache_key || null,
         decision_lattice: proof.decision_lattice ? {
             selected_path: proof.decision_lattice.selected_path?.id || null,
@@ -472,7 +475,7 @@ function selectPipelineLane(route, task, proof, taskProfile = classifyTaskProfil
     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'] };
+        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: ['planning_debate'], 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))
@@ -483,7 +486,7 @@ function selectPipelineLane(route, task, proof, taskProfile = classifyTaskProfil
         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, taskProfile, gateProfile, ambiguity, lane, context7Required, agentPolicy = normalizeAgentPolicy(route, task, {})) {
+function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, lane, context7Required, officialSubagentPolicy = normalizeOfficialSubagentPolicy(route, task, {})) {
     if (gateProfile === 'none')
         return [];
     const ids = [...GATE_PROFILE_STAGES[gateProfile]];
@@ -501,8 +504,6 @@ function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, l
     }
     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)
@@ -516,8 +517,8 @@ function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, l
             : 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 === OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID)
+            return { ...officialSubagentPipelineStage(officialSubagentPolicy), status: 'required', reason: officialSubagentPolicy.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)
@@ -541,10 +542,8 @@ function planVerification(route, proof, budget) {
         out.add('npm run packcheck');
         out.add('sks selftest --mock --json');
     }
-    if (route?.id === 'Naruto' || route?.id === 'Team')
+    if (route?.id === 'Naruto')
         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');
     return [...out];
@@ -561,7 +560,7 @@ function pipelineInvariants(input) {
         out.push('honest_summary');
     return out;
 }
-function planNextActions(route, task, taskProfile, ambiguity, lane, agentPolicy = normalizeAgentPolicy(route, task, {}), missionId = null) {
+function planNextActions(route, task, taskProfile, ambiguity, lane) {
     if (taskProfile === 'passthrough' || taskProfile === 'answer')
         return [];
     if (ambiguity.required && !ambiguity.passed) {
@@ -573,11 +572,6 @@ function planNextActions(route, task, taskProfile, ambiguity, lane, agentPolicy
         ];
     }
     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) {
-        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'
             ? 'read subagent-plan.json, create independent disjoint slices, run the official Codex subagent workflow, wait for all requested agent threads, and integrate their results'
@@ -588,9 +582,6 @@ function planNextActions(route, task, taskProfile, ambiguity, lane, agentPolicy
     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);
@@ -611,7 +602,7 @@ export function promptPipelineContext(prompt, route = null) {
         'Before work, load the required SKS skill context and follow the route lifecycle instead of treating the command as plain text.',
         'Codex App visibility: briefly surface what SKS is doing before tools run, mirror important worker/tool status to mission artifacts, and keep progress legible to the user.',
         responseLanguageInstruction(cleanPrompt),
-        'Hook visibility limit: hooks can inject context/status or block/continue a turn, but they cannot create arbitrary live chat bubbles; use team events, mission files, or normal assistant updates for live transcript details.',
+        'Hook visibility limit: hooks can inject context/status or block/continue a turn, but they cannot create arbitrary live chat bubbles; use official subagent events, mission files, or normal assistant updates for live transcript details.',
         'Ambient Goal continuation: even without an explicit $Goal keyword, use Codex native /goal persistence when it helps keep long work resumable and complete; do not let it replace or skip the selected SKS route gates.',
         'Route contract: execution routes infer contract answers from the prompt, TriWiki/current-code defaults, and conservative SKS policy. DFix and Answer bypass stateful execution because they do not start implementation.',
         `Wiki-informed request intake: when a mission exists, read ${REQUEST_INTAKE_ARTIFACT} before execution; preserve every source-order requirement, apply TriWiki attention/use_first and hydrate_first context, and execute request_intake.transformed_prompt through the selected route instead of relying on the vague original wording alone.`,
@@ -640,9 +631,7 @@ export function promptPipelineContext(prompt, route = null) {
     if (reflectionRequiredForRoute(route))
         lines.push(reflectionInstructionText());
     if (route?.id === 'Naruto')
-        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.`);
+        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, custom process pools, and verification DAGs are not completion evidence.');
     if (route?.id === 'Goal')
         lines.push('Goal route: write SKS goal bridge artifacts, then use Codex native /goal persistence for create, pause, resume, and clear continuation controls.');
     if (route?.id === 'PPT')
@@ -653,8 +642,8 @@ export function promptPipelineContext(prompt, route = null) {
         lines.push('AutoResearch route: load autoresearch-loop for experiments and benchmarking. SEO/GEO, discoverability, README, npm, GitHub search visibility, and AI-search visibility should use the first-class $SEO-GEO-OPTIMIZER parent route unless the selected route explicitly needs a child experiment.');
     if (route?.id === 'DB')
         lines.push('DB route: scan/check database risk first; destructive DB operations remain forbidden.');
-    if (route?.id === 'MadDB')
-        lines.push('MadDB route: explicit invocation is the SQL-plane approval boundary. Use the mission-local write-capable Supabase MCP profile only for the bound cycle, verify execute_sql/apply_migration inventory before claiming ready, execute requested SQL-plane mutations, read back postconditions, then close the capability/profile and prove normal read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied.');
+    if (route?.id === 'MadSKS')
+        lines.push('MAD-SKS SQL-plane: explicit invocation is the approval boundary. Use the mission-local write-capable Supabase MCP profile only for the bound cycle, verify execute_sql/apply_migration inventory before claiming ready, execute requested SQL-plane mutations, read back postconditions, then close the capability/profile and prove normal read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied.');
     if (route?.id === 'GX')
         lines.push('GX route: use deterministic vgraph/beta render, validate, drift, and snapshot artifacts.');
     return lines.join('\n');
@@ -670,7 +659,7 @@ export function dfixQuickContext(prompt, route = routePrompt(prompt)) {
         'Task list:',
         '1. Infer the smallest visible Direct Fix target from the request and current files.',
         '2. Inspect only the files needed to locate that target.',
-        `3. Apply only the listed Direct Fix edit; keep broad implementation routed to Team, and for UI/UX micro-edits read design.md when present and use imagegen for any image/logo/raster asset. ${CODEX_IMAGEGEN_REQUIRED_POLICY}`,
+        `3. Apply only the listed Direct Fix edit; keep broad implementation routed to Naruto, and for UI/UX micro-edits read design.md when present and use imagegen for any image/logo/raster asset. ${CODEX_IMAGEGEN_REQUIRED_POLICY}`,
         '4. Run only cheap verification when useful, such as syntax check, focused test, or local render smoke.',
         '5. Final response: start with `DFix 완료 요약:` and include one `DFix 솔직모드:` line with verified / not verified / remaining issue status. Do not create TriWiki/TriFix/reflection/state records and do not enter repeated full-route Honest Mode loops.'
     ].join('\n');
@@ -681,7 +670,7 @@ export function answerOnlyContext(prompt, route = routePrompt(prompt)) {
     return [
         `SKS answer-only pipeline active. Route: ${route?.command || '$Answer'} (${route?.route || 'answer-only research'}).`,
         responseLanguageInstruction(task),
-        'Intent classification: answer/research question, not implementation. Do not create route mission state, ask ambiguity-gate questions, open worker sessions, continue active Team/Goal work, or edit files unless the user explicitly asks for implementation.',
+        'Intent classification: answer/research question, not implementation. Do not create route mission state, ask ambiguity-gate questions, open worker sessions, continue active Naruto/Goal work, or edit files unless the user explicitly asks for implementation.',
         `Question: ${task}`,
         'Evidence flow:',
         '1. Check current repo facts and TriWiki context first; hydrate low-trust wiki claims from source paths before relying on them.',
@@ -708,7 +697,7 @@ export async function prepareRoute(root, prompt, state = {}, opts = {}) {
     const reasoning = routeReasoning(route, cleanPrompt);
     const subagentsRequired = routeRequiresSubagents(route, cleanPrompt);
     const finish = async (prepared) => {
-        const materialized = subagentsRequired && !['Naruto', 'Team', 'Goal'].includes(route.id)
+        const materialized = subagentsRequired && !['Naruto', 'Goal'].includes(route.id)
             ? await materializeOfficialSubagentOverlay(root, prepared, route, task, { sessionKey, parentModel: opts.parentModel || null })
             : prepared;
         return withSkillDreamContext(materialized, dreamContext);
@@ -725,16 +714,14 @@ export async function prepareRoute(root, prompt, state = {}, opts = {}) {
         return finish(await prepareGoal(root, route, task, required, { sessionKey }));
     if (route.id === 'ImageUXReview')
         return finish(await prepareImageUxReview(root, route, task, required, { sessionKey }));
-    if (route.id === 'MadDB')
-        return finish(await prepareMadDb(root, route, task, required, { sessionKey }));
-    if (QUESTION_GATE_ROUTES.has(route.id) || route.id === 'MadSKS')
+    if (route.id === 'MadSKS')
+        return finish(await prepareMadSksSqlPlane(root, route, task, required, { sessionKey }));
+    if (QUESTION_GATE_ROUTES.has(route.id))
         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 finish(await prepareLightRoute(root, parentOwnedProfileRoute(route), task, required, { sessionKey }));
-    if (route.id === 'Team')
-        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 finish(await prepareResearch(root, route, task, required, { sessionKey }));
     if (route.id === 'AutoResearch')
@@ -758,7 +745,7 @@ function parentOwnedProfileRoute(route) {
         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'],
+        requiredSkills: ['sks-pipeline-runner', 'sks-prompt-pipeline', 'sks-honest-mode'],
         lifecycle: ['task_profile', 'ownership', 'focused_implementation', 'listed_verification', 'honest_summary'],
         stopGate: 'honest_mode',
         coverage_required: false,
@@ -819,7 +806,7 @@ export function computerUseFastContext(prompt, route = routePrompt(prompt)) {
     return [
         `Native Computer Use fast lane active. Route: ${route?.command || '$Computer-Use'} (${route?.route || 'native Computer Use fast lane'}).`,
         responseLanguageInstruction(task),
-        'Speed contract: do not enter Team, QA-LOOP clarification, repeated upfront TriWiki refresh, Context7, native-session orchestration, debate, reflection, or broad planning unless the user explicitly requests that heavier route.',
+        'Speed contract: do not enter Naruto, QA-LOOP clarification, repeated upfront TriWiki refresh, Context7, native-session orchestration, debate, reflection, or broad planning unless the user explicitly requests that heavier route.',
         `Task: ${task}`,
         'Execution order:',
         '1. Infer the smallest native Mac, desktop-app, OS-settings, or non-web visual target and acceptance from the prompt and current app context.',
@@ -899,15 +886,8 @@ export async function activeRouteContext(root, state) {
     if (state.clarification_passed && String(state.phase || '').includes('CLARIFICATION_CONTRACT_SEALED')) {
         return `Route contract sealed for ${state.route_command || state.route || state.mode}. Use decision-contract.json and ${PIPELINE_PLAN_ARTIFACT} before executing the route. Before the next route phase, read relevant TriWiki context, hydrate low-trust claims from source, and refresh/validate TriWiki again after new findings or artifact changes. Next atomic action: continue the original route lifecycle with the inferred goal, constraints, non-goals, risk boundary, and test scope.${planNote}`;
     }
-    if (state.mode === 'TEAM') {
-        const context7 = state.context7_required && !(await hasContext7DocsEvidence(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 `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') {
-        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}`;
+        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, retired process-pool artifacts, or a custom active pool.${reasoningNote}${planNote}`;
     }
     if (state.subagents_required && !(await hasSubagentEvidence(root, state))) {
         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}`;
@@ -915,7 +895,7 @@ export async function activeRouteContext(root, state) {
     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}`;
     if (state.context7_required && !(await hasContext7DocsEvidence(root, state))) {
-        return `Active SKS route ${id} still requires Context7 evidence. Use resolve-library-id, then query-docs (or legacy get-library-docs) for relevant docs/APIs before completing.${reasoningNote}${planNote}`;
+        return `Active SKS route ${id} still requires Context7 evidence. Use resolve-library-id, then query-docs for relevant docs/APIs before completing.${reasoningNote}${planNote}`;
     }
     return planNote.trim();
 }
@@ -1167,7 +1147,7 @@ async function prepareResearch(root, route, task, required, opts = {}) {
     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. 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.`);
+    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. Keep subagent-plan.json, subagent-events.jsonl, subagent-parent-summary.json, and subagent-evidence.json current, 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 });
@@ -1185,10 +1165,10 @@ 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, '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.');
+    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. 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' });
+async function prepareMadSksSqlPlane(root, route, task, required, opts = {}) {
+    const prepared = await prepareMadSksSqlPlaneMission({ root, task, verifyTools: false, sessionKey: opts.sessionKey, route: 'MadSKS', routeCommand: '$MAD-SKS' });
     const dir = missionDir(root, prepared.mission_id);
     const pipelinePlan = await writePipelinePlan(dir, {
         missionId: prepared.mission_id,
@@ -1199,7 +1179,7 @@ async function prepareMadDb(root, route, task, required, opts = {}) {
     });
     await appendJsonl(path.join(dir, 'events.jsonl'), {
         ts: nowIso(),
-        type: 'mad_db.route_prepared',
+        type: 'mad_sks_sql_plane.route_prepared',
         mission_id: prepared.mission_id,
         cycle_id: prepared.cycle_id,
         blockers: prepared.blockers
@@ -1210,18 +1190,18 @@ async function prepareMadDb(root, route, task, required, opts = {}) {
         implementation_allowed: prepared.ok,
         ambiguity_gate_required: true,
         ambiguity_gate_passed: true,
-        mad_db_active: prepared.ok,
-        mad_db_cycle_id: prepared.cycle_id,
-        mad_db_runtime_session_id: prepared.capability.runtime_session_id,
-        mad_db_profile_sha256: prepared.capability.transport.profile_sha256,
-        mad_db_capability_mission_id: prepared.mission_id,
-        mad_db_capability_file: 'mad-db-capability.json',
+        mad_sks_sql_plane_active: prepared.ok,
+        mad_sks_sql_plane_cycle_id: prepared.cycle_id,
+        mad_sks_sql_plane_runtime_session_id: prepared.capability.runtime_session_id,
+        mad_sks_sql_plane_profile_sha256: prepared.capability.transport.profile_sha256,
+        mad_sks_sql_plane_capability_mission_id: prepared.mission_id,
+        mad_sks_sql_plane_capability_file: madSksSqlPlaneRelativePath(MAD_SKS_SQL_PLANE_CAPABILITY_FILE),
         mad_sks_gate_file: 'mad-sks-gate.json',
         stop_gate: 'mad-sks-gate.json',
         pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
         pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
     }), { sessionKey: opts.sessionKey });
-    return routeContext(route, prepared.mission_id, task, required, `MadDB mission/capability/profile were created atomically for cycle ${prepared.cycle_id}. Verify Supabase MCP tool inventory exposes execute_sql and apply_migration before claiming ready; after execution require read-back proof, finally close the profile/capability and prove read-only restoration.`);
+    return routeContext(route, prepared.mission_id, task, required, `MAD-SKS SQL-plane mission/capability/profile were created atomically for cycle ${prepared.cycle_id}. Verify Supabase MCP tool inventory exposes execute_sql and apply_migration before claiming ready; after execution require read-back proof, finally close the profile/capability and prove read-only restoration.`);
 }
 async function prepareGx(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: 'gx', prompt: task, sessionKey: opts.sessionKey });
@@ -1272,7 +1252,6 @@ async function materializeOfficialSubagentOverlay(root, prepared, route, task, o
         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,
@@ -1337,7 +1316,7 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
         command: '$Naruto',
         mode: 'NARUTO',
         task: cleanTask,
-        required_skills: route.requiredSkills || ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
+        required_skills: route.requiredSkills || ['sks-naruto', 'sks-pipeline-runner', 'sks-prompt-pipeline', 'sks-honest-mode'],
         context7_required: required,
         context_tracking: triwikiContextTracking(),
         stop_gate: NARUTO_GATE_FILENAME,
@@ -1354,7 +1333,6 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
         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)
     };
@@ -1367,7 +1345,7 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
             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' } });
+    const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: cleanTask, taskProfile, required, ambiguity: { required: false, status: 'direct_naruto' } });
     await setCurrent(root, routeState(id, route, 'NARUTO_READY', required, {
         prompt: cleanTask,
         route: 'Naruto',
@@ -1380,7 +1358,6 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
         required_skills: routeContextPayload.required_skills,
         subagents_required: true,
         native_sessions_required: false,
-        agents_required: false,
         requested_subagents: budget.requestedSubagents,
         subagent_max_threads: budget.maxThreads,
         subagent_max_depth: budget.maxDepth,
@@ -1408,7 +1385,7 @@ function requestedSubagentsFromTask(task) {
 function routeState(id, route, phase, context7Required, extra = {}) {
     const reasoning = routeReasoning(route, extra.prompt || '');
     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 };
+    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, 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);
@@ -1426,7 +1403,7 @@ Pipeline plan: .sneakoscope/missions/${id}/${PIPELINE_PLAN_ARTIFACT}
 Required skills: ${route.requiredSkills.join(', ')}
 Stop gate: ${route.stopGate}
 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.
+TriWiki: use only a 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 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.'}
 Reasoning: ${routeReasoning(route, visibleTask).effort} temporary; return to default after completion.
@@ -1446,7 +1423,6 @@ function clarificationVisibleResponseContract(id) {
     return `
 
 VISIBLE RESPONSE CONTRACT:
-- This is stale compatibility text for old missions only.
 - Do not show a prequestion sheet in chat.
 - Seal internally with inferred answers using \`${answerCommand}\`, or re-prepare the current prompt so the route auto-seals.`;
 }
@@ -1458,7 +1434,7 @@ Codex plan-tool interaction:
 Use update_plan only for real execution work:
 - in_progress: Auto-seal inferred route contract for ${route.command || '$SKS'}
 - pending: Continue the original route lifecycle with decision-contract.json
-Do not surface a prequestion sheet. Legacy answer command if needed: \`${command}\`.`;
+Do not surface a prequestion sheet. If auto-sealing cannot proceed, use \`${command}\`.`;
 }
 function formatRequiredQuestions(schema) {
     return schema.slots.map((s, i) => {
@@ -1517,40 +1493,13 @@ export async function recordSubagentEvidence(root, state, payload) {
     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;
+    return null;
 }
 async function shouldWritePipelineEvidence(root, state = {}) {
     if (state?.mission_id)
         return exists(missionDir(root, state.mission_id));
     return exists(path.join(root, '.sneakoscope', 'state', 'current.json'));
 }
-function legacySubagentToolName(payload) {
-    const obj = payload || {};
-    return String(obj.tool_name || obj.name || obj.tool?.name || obj.mcp_tool || obj.command || obj.type || '');
-}
-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.
-    if (!/(spawn_agent|send_input|wait_agent|close_agent|interrupt_agent|subagent|worker|explorer)/i.test(hay))
-        return null;
-    if (/subagent[_ -]?unavailable|subagents unavailable|unsafe to split|unsplittable|cannot safely split/i.test(hay))
-        return 'exception';
-    if (/spawn_agent/i.test(hay))
-        return 'spawn_agent';
-    if (/interrupt_agent|close_agent/i.test(hay))
-        return 'result';
-    if (/wait_agent|completed|final/i.test(hay))
-        return 'result';
-    return 'subagent';
-}
 export async function subagentEvidence(root, state) {
     const id = state?.mission_id;
     if (!id)
@@ -1589,26 +1538,7 @@ export async function subagentEvidence(root, state) {
             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;
-    let exception = false;
-    for (const line of lines) {
-        try {
-            const entry = JSON.parse(line);
-            if (entry.stage === 'spawn_agent')
-                spawn = true;
-            if (entry.stage === 'result')
-                result = true;
-            if (entry.stage === 'exception')
-                exception = true;
-        }
-        catch { }
-    }
-    return { spawn, result, exception, ok: spawn || exception, count: lines.length, workflow: 'legacy_process_swarm' };
+    return { spawn: false, result: false, exception: false, ok: false, count: 0, workflow: 'official_codex_subagent' };
 }
 function canonicalEvidenceMismatch(canonical, recomputed) {
     if (canonical?.schema !== 'sks.subagent-evidence.v1' || canonical?.workflow !== 'official_codex_subagent') {
@@ -1637,10 +1567,6 @@ function canonicalEvidenceMismatch(canonical, recomputed) {
 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 || '');
@@ -1686,9 +1612,6 @@ function context7DirectSignal(payload = {}) {
     }
     return '';
 }
-function formatLegacyRoleCounts(roleCounts = {}) {
-    return Object.entries(roleCounts || {}).map(([role, count]) => `${role}:${count}`).join(' ');
-}
 function context7SafeInput(input) {
     if (!input || typeof input !== 'object' || Array.isArray(input))
         return input ?? null;
@@ -1754,4 +1677,3 @@ export async function hasContext7DocsEvidence(root, state) {
     return (await context7Evidence(root, state)).ok;
 }
 export { projectGateStatus, evaluateStop } from './runtime-gates.js';
-//# sourceMappingURL=runtime-core.js.map