sneakoscope 6.1.0 → 6.2.0

package/dist/core/retention.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { exists, readJson, writeJsonAtomic, ensureDir, dirSize, fileSize, formatBytes, rmrf, nowIso, appendJsonlBounded, listFilesRecursive, managedSksTmpRoot, sha256 } from './fsx.js';
+import { exists, readJson, writeJsonAtomic, ensureDir, dirSize, fileSize, formatBytes, rmrf, nowIso, appendJsonlBounded, listFilesRecursive, managedSksTmpRoot, sha256, SKS_TEMP_LEASE_FILE } from './fsx.js';
 import { FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS } from './routes.js';
 export const DEFAULT_RETENTION_POLICY = Object.freeze({
     schema_version: 1,
@@ -487,6 +487,44 @@ function currentProcessOwns(stat) {
 function sharedTempEntryMatchesProject(entryName, projectHash) {
     return entryName === `sks-${projectHash}` || entryName.startsWith(`sks-${projectHash}-`);
 }
+function activeTempEnvironmentKey(target) {
+    const resolvedTarget = path.resolve(target);
+    for (const key of ['SKS_TMP_DIR', 'TMPDIR', 'TMP', 'TEMP']) {
+        const raw = process.env[key];
+        if (!raw)
+            continue;
+        const activePath = path.resolve(raw);
+        if (isWithin(resolvedTarget, activePath))
+            return key;
+    }
+    return null;
+}
+async function liveTempLease(target) {
+    const leasePath = path.join(target, SKS_TEMP_LEASE_FILE);
+    const stat = await fs.lstat(leasePath).catch(() => null);
+    if (!stat?.isFile() || stat.isSymbolicLink() || !currentProcessOwns(stat))
+        return null;
+    const lease = await readJson(leasePath, null).catch(() => null);
+    const pid = Number(lease?.pid);
+    if (lease?.schema !== 'sks.temp-lease.v1' || !processIdAlive(pid))
+        return null;
+    return {
+        path: leasePath,
+        pid,
+        kind: lease?.kind ? String(lease.kind) : null
+    };
+}
+function processIdAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
 async function pruneTmp(root, policy, dryRun, actions) {
     const tmp = path.join(root, '.sneakoscope', 'tmp');
     if (!(await exists(tmp)))
@@ -1138,6 +1176,28 @@ export async function sweepSksTempDirs(root, opts = {}) {
             const stat = await fs.lstat(target).catch(() => null);
             if (!stat || stat.isSymbolicLink() || !currentProcessOwns(stat))
                 continue;
+            const environmentKey = activeTempEnvironmentKey(target);
+            if (environmentKey) {
+                actions.push({
+                    action: 'retain_active_sks_temp',
+                    path: target,
+                    reason: 'active_temp_environment',
+                    environment_key: environmentKey
+                });
+                continue;
+            }
+            const lease = stat.isDirectory() ? await liveTempLease(target) : null;
+            if (lease) {
+                actions.push({
+                    action: 'retain_active_sks_temp',
+                    path: target,
+                    reason: 'active_temp_lease',
+                    lease_path: lease.path,
+                    owner_pid: lease.pid,
+                    lease_kind: lease.kind
+                });
+                continue;
+            }
             const inspected = await inspectTempPath(target);
             if (!inspected.complete) {
                 actions.push({ action: 'skip_unsafe_temp_entry', path: target, reason: inspected.blockers.join(',') });
@@ -1561,7 +1621,15 @@ export async function enforceRetention(root, opts = {}) {
         await rotateLargeJsonl(root, policy, dryRun, actions);
     await pruneDisposableReportLogs(root, policy, dryRun, actions, opts);
     await pruneSessionStateFiles(root, policy, dryRun, actions);
-    await sweepSksTempDirs(root, { dryRun, actions, maxAgeHours: opts.sksTempMaxAgeHours ?? policy.max_tmp_age_hours ?? 0 });
+    if (opts.skipSksTempSweep === true) {
+        actions.push({
+            action: 'skip_sks_temp_sweep',
+            reason: opts.afterRoute ? 'post_route_global_temp_isolation' : 'explicit_temp_sweep_skip'
+        });
+    }
+    else {
+        await sweepSksTempDirs(root, { dryRun, actions, maxAgeHours: opts.sksTempMaxAgeHours ?? policy.max_tmp_age_hours ?? 0 });
+    }
     if (opts.pruneWikiArtifacts || policy.prune_wiki_artifacts)
         await pruneWikiArtifacts(root, { policy, dryRun, actions, lowTrust: opts.pruneWikiLowTrust });
     let report = boundedMode || opts.skipStorageReport === true ? await lightweightStorageReport(root) : await storageReport(root);

package/dist/core/routes/constants.js

@@ -9,7 +9,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|computer-use|goal|fast-mode|review|ui|research|seo-geo-optimizer|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|super-search|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|memory|wrongness|code-structure|proof-field|skill-dream|rust';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|naruto|team|qa-loop|ppt|image-ux-review|computer-use|goal|fast-mode|review|ui|research|seo-geo-optimizer|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|super-search|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|memory|wrongness|code-structure|proof-field|skill-dream|rust';
 export const RECOMMENDED_MCP_SERVERS = [
     {
         id: 'context7',

package/dist/core/routes/dollar-manifest-lite.js

@@ -1,22 +1,22 @@
-const NARUTO_DESCRIPTION = '$Naruto mode launches a hardware-safe massive parallel work swarm. Clones may implement, modify, verify, test, research, document, and resolve conflicts according to role and lease policy; write-capable output is accepted only through patch envelopes, verification DAG, mutation guard, and GPT final arbiter.';
+const NARUTO_DESCRIPTION = '$Naruto is the lightweight Codex official subagent workflow. The Sol Max parent uses two independent children for non-trivial work and at most three for critical multi-domain risk; explicit --agents remains authoritative. Child routing is fixed to Luna Max mechanical, Sol High implementation, Sol Max judgment, and Terra Medium long-context/Computer Use/Browser/ImageGen execution. It delegates only defensible independent slices, reuses bounded query-aware TriWiki attention anchors, and requires official lifecycle events plus a trustworthy structured parent summary.';
 const COMPUTER_USE_DESCRIPTION = 'Maximum-speed Codex Computer Use lane for native macOS, desktop-app, OS-settings, and non-web visual tasks only. Browser, localhost, website, webapp, and web-based app verification must route through Codex Chrome Extension readiness first.';
 export const DOLLAR_COMMANDS_LITE = [
     { command: '$DFix', route: 'fast direct fix', description: 'Tiny simple direct edits such as copy, labels, typos, wording, spacing, colors, or clearly scoped one-line changes. Bypasses the general SKS pipeline and runs an ultralight, no-record task-list path.' },
     { command: '$Answer', route: 'answer-only research', description: 'Answer questions without starting implementation. Uses TriWiki, web, Context7 when relevant, and Honest Mode fact-checking.' },
     { command: '$SKS', route: 'general SKS workflow', description: 'General Sneakoscope setup, help, status, and workflow routing.' },
-    { command: '$Plan', route: 'planning-only frontdoor', description: 'Plan scaffold only: writes a fixed-template .sneakoscope/plans/<slug>.md (goal/scope/steps headings to fill in), not project-specific decision-complete planning. Keeps implementation disallowed until $Work runs the plan.' },
+    { command: '$Plan', route: 'planning-only frontdoor', description: 'Plan scaffold only: writes a fixed-template .sneakoscope/plans/<slug>.md (goal/scope/steps headings to fill in), not project-specific decision-complete planning. Keeps implementation disallowed until an explicit $Work alias or $Naruto runs the plan.' },
     { command: '$Review', route: 'machine-first diff review', description: 'Review staged or selected diffs with machine evidence sorted above LLM opinion.' },
-    { command: '$Fast-Mode', route: 'fast-mode toggle', description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and native-agent routes. Explicit --fast, --no-fast, and --service-tier flags still override it.' },
-    { command: '$Fast-On', route: 'fast-mode toggle', description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and native-agent routes. Explicit --fast, --no-fast, and --service-tier flags still override it.' },
-    { command: '$Fast-Off', route: 'fast-mode toggle', description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and native-agent routes. Explicit --fast, --no-fast, and --service-tier flags still override it.' },
+    { command: '$Fast-Mode', route: 'fast-mode toggle', description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and routed workflows. Explicit --fast, --no-fast, and --service-tier flags still override it.' },
+    { command: '$Fast-On', route: 'fast-mode toggle', description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and routed workflows. Explicit --fast, --no-fast, and --service-tier flags still override it.' },
+    { command: '$Fast-Off', route: 'fast-mode toggle', description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and routed workflows. Explicit --fast, --no-fast, and --service-tier flags still override it.' },
     { command: '$with-local-llm-on', route: 'local Ollama worker toggle', description: 'Turn the optional local Ollama worker backend on or off. Default off keeps SKS GPT-only; enabled mode lets eligible simple code/collection worker slices use Ollama while GPT/Codex owns strategy, design, review, verification, and integration.' },
     { command: '$with-local-llm-off', route: 'local Ollama worker toggle', description: 'Turn the optional local Ollama worker backend on or off. Default off keeps SKS GPT-only; enabled mode lets eligible simple code/collection worker slices use Ollama while GPT/Codex owns strategy, design, review, verification, and integration.' },
-    { command: '$Naruto', route: 'hardware-safe massive parallel work swarm', description: NARUTO_DESCRIPTION },
-    { command: '$ShadowClone', route: 'hardware-safe massive parallel work swarm', description: NARUTO_DESCRIPTION },
-    { command: '$Kagebunshin', route: 'hardware-safe massive parallel work swarm', description: NARUTO_DESCRIPTION },
-    { command: '$Work', route: 'hardware-safe massive parallel work swarm', description: NARUTO_DESCRIPTION },
-    { command: '$Swarm', route: 'hardware-safe massive parallel work swarm', description: NARUTO_DESCRIPTION },
-    { command: '$Release-Review', route: 'native release review', description: 'Run release-readiness collaboration through native multi-session agents with explicit agent count, concurrency, route personas, leases, dynamic effort, proof, and cleanup artifacts.' },
+    { command: '$Naruto', route: 'Codex official subagent workflow', description: NARUTO_DESCRIPTION },
+    { command: '$ShadowClone', route: 'deprecated alias to the Codex official subagent workflow', description: NARUTO_DESCRIPTION },
+    { command: '$Kagebunshin', route: 'deprecated alias to the Codex official subagent workflow', description: NARUTO_DESCRIPTION },
+    { command: '$Work', route: 'compatibility alias to the Codex official subagent workflow', description: NARUTO_DESCRIPTION },
+    { command: '$Swarm', route: 'compatibility alias to the Codex official subagent workflow', description: NARUTO_DESCRIPTION },
+    { command: '$Release-Review', route: 'official subagent release review', description: 'Run release-readiness collaboration through Codex official subagent threads with explicit review lanes, bounded thread budgets, structured parent outcomes, evidence, and cleanup artifacts.' },
     { command: '$QA-LOOP', route: 'QA loop', description: 'Dogfood UI/API as human proxy with safety gates, Codex Chrome Extension-first web UI evidence, safe fixes, rechecks, Honest Mode.' },
     { command: '$PPT', route: 'HTML/PDF presentation pipeline', description: 'Create restrained, information-first HTML/PDF presentation artifacts after delivery context, audience profile, STP, decision context, pain-point, research, design-system, and verification questions are sealed.' },
     { command: '$Image-UX-Review', route: 'image-generation UI/UX review loop', description: 'Review UI/UX through the imagegen/gpt-image-2 visual critique loop: source screenshots become generated annotated review images, those images become issue ledgers, then fixes are rechecked.' },

package/dist/core/routes.js

@@ -4,6 +4,7 @@ import { ALLOWED_REASONING_EFFORTS, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_
 import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, RESERVED_CODEX_PLUGIN_SKILL_NAMES } from './routes/evidence.js';
 import { getdesignReferencePolicyText, imageUxReviewPipelinePolicyText } from './routes/design-policy.js';
 import { PPT_PIPELINE_SKILL_ALLOWLIST, pptPipelineAllowlistPolicyText } from './routes/ppt-policy.js';
+import { classifyTaskProfile, looksLikeDatabaseWorkRequest } from './runtime/task-profile.js';
 export * from './routes/constants.js';
 export * from './routes/design-policy.js';
 export * from './routes/evidence.js';
@@ -217,7 +218,7 @@ export const ROUTES = [
         command: '$Fast-Mode',
         mode: 'FAST_MODE',
         route: 'fast-mode toggle',
-        description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and native-agent routes. Explicit --fast, --no-fast, and --service-tier flags still override it.',
+        description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and routed workflows. Explicit --fast, --no-fast, and --service-tier flags still override it.',
         requiredSkills: ['fast-mode', 'honest-mode'],
         dollarAliases: ['$Fast-On', '$Fast-Off'],
         appSkillAliases: ['fast-on', 'fast-off'],
@@ -251,52 +252,52 @@ export const ROUTES = [
         command: '$Team',
         mode: 'TEAM',
         route: 'deprecated alias to Naruto',
-        description: 'Deprecated compatibility alias. New substantial work is routed to $Naruto, the native shadow-clone swarm SSOT.',
+        description: 'Deprecated compatibility alias. New substantial work is routed to $Naruto, the Codex official subagent workflow SSOT.',
         requiredSkills: ['team', 'pipeline-runner', 'context7-docs', 'prompt-pipeline', REFLECTION_SKILL_NAME, 'honest-mode'],
         dollarAliases: ['$From-Chat-IMG'],
         appSkillAliases: ['from-chat-img'],
         deprecated: true,
         hidden: true,
         aliasTo: '$Naruto',
-        deprecationMessage: '$Team is deprecated and redirects new execution missions to $Naruto. Existing Team observation commands remain available for old missions.',
+        deprecationMessage: '$Team is deprecated and redirects new execution missions to $Naruto. Only read-only Team log/tail/watch/lane/status commands remain for old missions.',
         lifecycle: ['deprecated_alias_redirect', 'naruto_gate', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
         stopGate: 'naruto-gate.json',
         coverage_required: true,
-        cliEntrypoint: 'sks team "task" [executor:5 reviewer:6 user:1] | sks team log|tail|watch|lane|status|event|message|open-zellij|attach-zellij|cleanup-zellij',
+        cliEntrypoint: 'sks team "task" | sks team log|tail|watch|lane|status',
         examples: ['$Team executor:5 agree on the best plan and implement it', '$From-Chat-IMG 채팅+첨부 이미지 작업 지시서']
     },
     {
         id: 'Naruto',
         command: '$Naruto',
         mode: 'NARUTO',
-        route: 'hardware-safe massive parallel work swarm',
-        description: '$Naruto mode launches a hardware-safe massive parallel work swarm. Clones may implement, modify, verify, test, research, document, and resolve conflicts according to role and lease policy; write-capable output is accepted only through patch envelopes, verification DAG, mutation guard, and GPT final arbiter.',
+        route: 'Codex official subagent workflow',
+        description: '$Naruto prepares a lightweight Codex official subagent workflow. The Sol Max parent owns decomposition, delegates only defensible direct-child slices, reuses bounded query-aware TriWiki attention anchors, waits for every requested thread, integrates the results, and reports scoped verification. Automatic fan-out is two for non-trivial work and at most three for critical multi-domain risk; explicit --agents remains authoritative.',
         requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$ShadowClone', '$Kagebunshin', '$Work', '$Swarm'],
         appSkillAliases: ['shadow-clone', 'kage-bunshin', 'work', 'swarm'],
-        lifecycle: ['clone_roster_build', 'massive_work_graph', 'hardware_safe_governor', 'dynamic_active_pool', 'lease_based_write_swarm', 'parallel_verification_dag', 'gpt_final_arbiter_pack', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
+        lifecycle: ['task_profile', 'subagent_plan', 'official_delegation_context', 'subagent_events', 'parent_integration', 'scoped_verification', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
         stopGate: 'naruto-gate.json',
         coverage_required: true,
-        cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-sdk|fake|ollama] [--parallel-write] | sks naruto status',
-        examples: ['$Naruto run sweep the codebase for TODO comments with 50 clones', '$Work', '$Swarm "fix all lint errors"']
+        cliEntrypoint: 'sks naruto run "task" [--agents N] [--max-threads N] | sks naruto status|subagents|proof',
+        examples: ['$Naruto run review twelve independent packages with --agents 12', '$Work', '$Swarm "fix all lint errors"']
     },
     {
         id: 'ReleaseReview',
         command: '$Release-Review',
         mode: 'RELEASE_REVIEW',
-        route: 'native release review',
-        description: 'Run release-readiness collaboration through native multi-session agents with explicit agent count, concurrency, route personas, leases, dynamic effort, proof, and cleanup artifacts.',
-        requiredSkills: ['team', 'pipeline-runner', REFLECTION_SKILL_NAME, 'honest-mode'],
-        lifecycle: ['native_agent_intake', 'release_fixture_matrix', 'five_lane_review', 'integration_evidence', 'session_cleanup', 'honest_mode'],
+        route: 'official subagent release review',
+        description: 'Run release-readiness collaboration through official Codex subagents with explicit thread budget, disjoint ownership, parent integration, scoped verification, and cleanup evidence.',
+        requiredSkills: ['naruto', 'pipeline-runner', REFLECTION_SKILL_NAME, 'honest-mode'],
+        lifecycle: ['subagent_plan', 'release_fixture_matrix', 'risk_scoped_review', 'parent_integration', 'session_cleanup', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
         stopGate: 'release-readiness-report.json',
-        cliEntrypoint: 'sks agent run "release audit" --route "$Release-Review" --agents <n> --concurrency <n> --mock --json',
-        examples: ['$Release-Review agents:10 concurrency:4 release audit', 'sks agent run "wide release audit" --route "$Release-Review" --agents 10 --concurrency 4 --mock --json']
+        cliEntrypoint: 'sks naruto run "$Release-Review release audit" --agents <n> --read-only --json',
+        examples: ['$Release-Review agents:10 release audit', 'sks naruto run "$Release-Review wide release audit" --agents 10 --read-only --json']
     },
     {
         id: 'QALoop',
@@ -471,7 +472,9 @@ export const ROUTES = [
         context7Policy: 'required',
         reasoningPolicy: 'high',
         stopGate: 'db-review.json',
-        cliEntrypoint: 'sks db scan',
+        cliEntrypoint: 'Codex App prompt route only; the legacy `sks db` CLI is removed',
+        codexAppOnly: true,
+        codexAppOnlyReason: '$DB remains a route-level safety policy. The legacy `sks db` CLI is removed from public dispatch and returns unknown_command.',
         examples: ['$DB check this migration safely']
     },
     {
@@ -601,9 +604,9 @@ export const COMMAND_CATALOG = [
     { name: 'daemon', usage: 'sks daemon status|warm|stop [--json]', description: 'Inspect or warm the local SKS daemon cache state for build/proof reuse.' },
     { name: 'run', usage: 'sks run "task" [--visual|--research|--db] [--json]', description: 'Classify a plain-language task, materialize a mission, and route it through the SKS trust kernel.' },
     { name: 'plan', usage: 'sks plan "task" [--json]', description: 'Write a planning-only artifact under .sneakoscope/plans without editing code.' },
-    { name: 'status', usage: 'sks status [--json]', description: 'Show the active mission, route, phase, proof, trust, native agent, image voxel, DB safety, and next action.' },
+    { name: 'status', usage: 'sks status [--json]', description: 'Show the active mission, route, phase, proof, trust, subagent or legacy-agent evidence, image voxel, DB safety, and next action.' },
     { name: 'review', usage: 'sks review [--staged|--diff <ref>] [--fix] [--json]', description: 'Review a diff with machine-evidence findings sorted above LLM review notes.' },
-    { name: 'ui', usage: 'sks ui [--port 4477] [--mission latest] [--once] [--json]', description: 'Open the localhost SKS dashboard with live swarm slots, events, and gate status.' },
+    { name: 'ui', usage: 'sks ui [--port 4477] [--mission latest] [--once] [--json]', description: 'Open the localhost SKS dashboard with live agent-thread slots, events, and gate status.' },
     { name: 'usage', usage: `sks usage [${USAGE_TOPICS}]`, description: 'Print copy-ready workflows for common tasks.' },
     { name: 'quickstart', usage: 'sks quickstart', description: 'Show the shortest safe setup and verification flow.' },
     { name: 'bootstrap', usage: 'sks bootstrap [--install-scope global|project] [--local-only] [--json]', description: 'Initialize the current project, install SKS Codex App files/skills, check Context7/Codex App/Zellij, and print ready true/false.' },
@@ -611,12 +614,12 @@ export const COMMAND_CATALOG = [
     { name: 'update', usage: 'sks update [check|now] [--version <version>] [--json] [--dry-run]', description: 'Check npm for the latest SKS release and update the global package by default; use `check` for status-only.' },
     { name: 'uninstall', usage: 'sks uninstall [--dry-run] [--yes] [--keep-config] [--keep-data] [--purge-projects] [--json]', description: 'Remove SKS global skills, hooks, menu bar, state, temp files, and optional project residue while preserving user-owned content by default.' },
     { name: 'deps', usage: 'sks deps check [--json] [--yes]', description: 'Check Node/npm, Codex CLI, and Zellij readiness; pass --yes to repair missing Codex CLI/Zellij tooling when supported.' },
-    { name: 'codex', usage: 'sks codex compatibility|version|doctor|schema|0.144 [--json]', description: 'Check Codex CLI rust-v0.144.1 compatibility, installed version, current manifest/capability evidence, inherited historical baselines, and vendored hook schema snapshot freshness.' },
+    { name: 'codex', usage: 'sks codex compatibility|version|update-status [--refresh]|update|doctor|schema|0.144 [--json]', description: 'Check Codex CLI compatibility/version/update status, run the official `codex update`, and inspect current manifest, capability, and hook-schema evidence.' },
     { name: 'codex-app', usage: 'sks codex-app [check|glm-profile install|set-openrouter-key --api-key-stdin|product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App install, GLM/OpenRouter model profile visibility, codex-lb key-entry guidance, Product Design plugin readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI 0.130.0+ remote-control availability.' },
     { name: 'codex-native', usage: 'sks codex-native status|feature-broker|invocation-plan|init-deep [--json]', description: 'Inspect Codex Native feature broker readiness, invocation routing, pattern evidence, and managed memory setup.' },
     { name: 'hooks', usage: 'sks hooks explain|status|trust-report|replay|codex-validate|warning-check ... [--json]', description: 'Explain Codex hook events, validate vendored latest 10-event output schemas, replay fixtures, and enforce warning-zero SKS hook policies under the 0.134 compatibility matrix.' },
     { name: 'codex-lb', usage: 'sks codex-lb status|health|metrics|doctor|circuit|repair|setup ...', description: 'Configure, health-check, repair, and record circuit evidence for codex-lb provider auth without confusing ChatGPT OAuth and proxy keys.' },
-    { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks naruto dashboard latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Naruto lane UI.' },
+    { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD. Zellij panes are not official Naruto subagent evidence.' },
     { name: 'tmux', usage: 'removed-runtime migration notice (replacement: zellij)', description: 'Show the removed-runtime migration notice and point operators to Zellij.' },
     { name: 'mad-sks', usage: 'sks mad-sks plan|run|apply|sql|apply-migration|status|close|rollback-apply ... | sks --mad [--high]', description: 'Open or inspect MAD-SKS scoped permission workflows, merged SQL-plane execution, and the Zellij permission launcher.' },
     { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS Zellij with the auto-review profile.' },
@@ -652,7 +655,6 @@ export const COMMAND_CATALOG = [
     { name: 'goal', usage: 'sks goal create|pause|resume|clear|status ...', description: 'Prepare and control the fast SKS bridge overlay for Codex native persisted /goal workflows.' },
     { name: 'seo-geo-optimizer', usage: 'sks seo-geo-optimizer [seo|geo] doctor|audit|research|strategy|plan|apply|verify|status|rollback|fixture [mission|latest] [--mode seo|geo] [--target auto|website|docs|package] [--include-marketing] [--json]', description: 'Run the unified SEO/GEO optimizer on the shared search-visibility kernel with mode-specific gates, marketing research/strategy, safe apply, and proof.' },
     { name: 'research', usage: 'sks research prepare|run|status ...', description: 'Run long-form real research missions with xhigh agent Eureka ideas, debate, layered sources, paper, novelty, and falsification gates.' },
-    { name: 'db', usage: 'sks db policy|scan|mcp-config|classify|check ...', description: 'Inspect and enforce database/Supabase safety policy.' },
     { name: 'eval', usage: 'sks eval run|compare|thresholds ...', description: 'Run deterministic context-quality and performance evidence checks.' },
     { name: 'harness', usage: 'sks harness fixture|review [--json]', description: 'Run Harness Growth Factory fixtures for forgetting, skills, experiments, tool taxonomy, permissions, MultiAgentV2, and Zellij views.' },
     { name: 'perf', usage: 'sks perf run|workflow|cold-start [--json] [--iterations N]', description: 'Measure structured GPT-5.6/SKS performance budgets, including cold-start, Proof Field workflow decisions, and fast-lane evidence.' },
@@ -668,8 +670,9 @@ export const COMMAND_CATALOG = [
     { name: 'wiki', usage: 'sks wiki coords|pack|refresh|publish|rebuild-index|validate|validate-shared|wrongness ...', description: 'Build, refresh, publish shared shards, rebuild ignored indexes, validate, and attach wrongness-memory context to RGBA/trig LLM Wiki packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.' },
     { name: 'memory', usage: 'sks memory build [--json] | sks memory gc [--dry-run]', description: 'Project TriWiki context-pack memory into managed AGENTS.md blocks or run bounded memory cleanup.' },
     { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
-    { name: 'agent', usage: 'sks agent run|status|close|cleanup <mission-id|latest> [--agents N] [--work-items N] [--target-active-slots N] [--mock] [--apply|--dry-run] [--drain] [--stale-ms N] [--json] | sks agent rollback-patches [mission-id|latest] [--patch-entry-id id] [--dry-run|--apply] [--json]', description: 'Run, inspect, close, clean, or rollback native multi-session agent missions with agents as target active slots, work items as the route queue size, cleanup executor proof for stale runtime resources, and patch rollback proof for applied patch entries.' },
-    { name: 'team', usage: 'sks team \"task\" | sks team log|tail|watch|lane|status|dashboard|event|message|open-zellij|attach-zellij|cleanup-zellij ...', description: 'Deprecated compatibility command: new tasks redirect to Naruto; observation subcommands remain for old Team missions.' },
+    { name: 'agent', usage: 'sks agent run|status|close|cleanup <mission-id|latest> [--agents N] [--work-items N] [--target-active-slots N] [--mock] [--apply|--dry-run] [--drain] [--stale-ms N] [--json] | sks agent rollback-patches [mission-id|latest] [--patch-entry-id id] [--dry-run|--apply] [--json]', description: 'Run, inspect, close, clean, or roll back Codex subagent missions with an explicit requested-agent/thread budget, disjoint work ownership, official event evidence, and parent-owned integration.' },
+    { name: 'naruto', usage: 'sks naruto run \"task\" [--agents N] [--max-threads N] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json]', description: 'Run or inspect the Codex official subagent workflow with a Sol Max parent and fixed Luna Max mechanical, Sol High implementation, Sol Max judgment, and Terra Medium long-context/tool profiles, max_depth=1, and structured parent-thread completion evidence.' },
+    { name: 'team', usage: 'sks team \"task\" | sks team log|tail|watch|lane|status ...', description: 'Deprecated compatibility command: new tasks redirect to Naruto; only read-only observation subcommands remain for old Team missions.' },
     { name: 'reasoning', usage: 'sks reasoning ["prompt"] [--json]', description: 'Show SKS temporary reasoning-effort routing: medium for simple tasks, high for logic, xhigh for research.' },
     { name: 'gx', usage: 'sks gx init|render|validate|drift|snapshot [name]', description: 'Create and verify deterministic SVG/HTML visual context cartridges.' },
     { name: 'profile', usage: 'sks profile show|set <model>', description: 'Inspect or set the current SKS model profile metadata.' },
@@ -804,10 +807,14 @@ export function looksLikeSuperSearchRequest(prompt = '') {
 export function routePrompt(prompt) {
     const text = stripVisibleDecisionAnswerBlocks(prompt);
     const intentScores = scorePromptIntent(text);
-    const select = (route) => withPromptIntentScores(route, intentScores);
+    const taskProfile = classifyTaskProfile(text);
+    const explicitCommand = Boolean(dollarCommand(text)) || /^\$?(?:plan|swarm)\b/i.test(text);
+    const select = (route) => withTaskProfile(withPromptIntentScores(route, intentScores), taskProfile, explicitCommand);
+    if (!explicitCommand && taskProfile === 'passthrough')
+        return null;
     if (/^\$?plan\b/i.test(text))
         return select(routeById('Planner'));
-    if (/^\$?work\b/i.test(text))
+    if (/^\$work\b/i.test(text))
         return select(routeById('Naruto'));
     if (/^\$?swarm\b/i.test(text))
         return select(routeById('Naruto'));
@@ -844,10 +851,18 @@ export function routePrompt(prompt) {
         return select(routeById('ComputerUse'));
     if (looksLikeTinyDirectFix(text))
         return select(routeById('DFix'));
-    if (/\b(SQL|Supabase|Postgres|migration|RLS|Prisma|Drizzle|Knex|database|DB|execute_sql)\b/i.test(text))
+    if (looksLikeDatabaseWorkRequest(text))
         return select(routeById('DB'));
     if (looksLikeSuperSearchRequest(text) && !looksLikeCodeChangingWork(text))
         return select(routeById('SuperSearch'));
+    if (taskProfile === 'answer' && !looksLikeSpecializedAnswerRouteSignal(text) && !looksLikeDirectWorkRequest(text))
+        return select(routeById('Answer'));
+    if (/\bautoresearch\b/i.test(text) && !looksLikeCodeChangingWork(text))
+        return select(routeById('AutoResearch'));
+    if (/\b(research|hypothesis|falsify|novelty|frontier)\b|조사|연구/i.test(text) && !looksLikeCodeChangingWork(text))
+        return select(routeById('Research'));
+    if (taskProfile === 'parallel-read' || taskProfile === 'parallel-write')
+        return select(routeById('Naruto'));
     if (looksLikeQuestionShapedDirective(text))
         return select(routeById('Naruto'));
     if (looksLikeDirectWorkRequest(text))
@@ -876,8 +891,14 @@ export function routePrompt(prompt) {
         return select(routeById('GX'));
     if (looksLikeTeamDefaultWork(text))
         return select(routeById('Naruto'));
+    if (taskProfile === 'answer')
+        return select(routeById('Answer'));
     return select(routeById('SKS'));
 }
+function looksLikeSpecializedAnswerRouteSignal(prompt = '') {
+    const text = String(prompt || '');
+    return /\b(qa[-\s]?loop|qaloop|autoresearch|research|hypothesis|falsify|novelty|frontier|wiki|triwiki|GX|vgraph|visual context|render cartridge|wiki coordinate|rgba|trig|llm wiki|SEO|GEO|generative engine optimization)\b|조사|연구|위키|트라이위키|검색\s*엔진\s*최적화|생성형\s*엔진\s*최적화/i.test(text);
+}
 export function scorePromptIntent(prompt = '') {
     const text = String(prompt || '').trim();
     const reasons = new Set();
@@ -929,7 +950,7 @@ export function scorePromptIntent(prompt = '') {
         researchScore += 2;
         reasons.add('research');
     }
-    if (/\b(SQL|Supabase|Postgres|migration|RLS|Prisma|Drizzle|Knex|database|DB|execute_sql)\b/i.test(text)) {
+    if (looksLikeDatabaseWorkRequest(text)) {
         dbScore += 3;
         reasons.add('db');
     }
@@ -952,6 +973,11 @@ function withPromptIntentScores(route, intentScores) {
         return route;
     return { ...route, intent_scores: intentScores };
 }
+function withTaskProfile(route, taskProfile, explicitInvocation = false) {
+    if (!route)
+        return route;
+    return { ...route, task_profile: taskProfile, explicit_invocation: explicitInvocation };
+}
 export function looksLikeComputerUseFastLane(prompt = '') {
     const text = String(prompt || '');
     const computerUseCue = /\b(computer\s*use|codex\s+computer\s+use|computer-use)\b|컴퓨터\s*유즈|컴퓨터\s*사용|컴퓨터유즈/i.test(text);
@@ -1000,6 +1026,8 @@ export function looksLikeDirectWorkRequest(prompt = '') {
     const text = String(prompt || '');
     if (/(?:설명만|설명\s*만|just\s+explain|explain\s+only|only\s+explain)/i.test(text))
         return false;
+    if (looksLikePureExplanationRequest(text))
+        return false;
     const explicitDirective = looksLikeExplicitDirectWorkDirective(text);
     if (looksLikeDirectFixQuestion(text) && !explicitDirective)
         return false;
@@ -1013,6 +1041,14 @@ export function looksLikeDirectWorkRequest(prompt = '') {
         || /(작업|파이프라인|구현|수정|변경|추가|적용|반영|처리|수행|검수|설치|해결|리드미|README).*(해줘|해달|해라|해야|되게|줘야|줘야지|달라)/i.test(text)
         || /(진행해|수행해|작업해|처리해|적용해|반영해|검수해|고쳐줘|바꿔줘|해결해줘|만들어줘|해줘야|해줘야지|해달라|해야지|되게 해|install|run|execute|test|deploy|commit|push)/i.test(text);
 }
+function looksLikePureExplanationRequest(prompt = '') {
+    const text = String(prompt || '').trim();
+    const explanationEnding = /(?:설명|알려)\s*(?:해\s*줘|해\s*주세요|해달라|줘)\s*[.!?]*$/i.test(text)
+        || /^(?:can|could|would) you explain\b/i.test(text);
+    if (!explanationEnding)
+        return false;
+    return !/\b(fix|implement|change|edit|add|remove|delete|modify|refactor|build|create|write|update|rename|rewrite|patch|apply|execute|repair|resolve|publish|release|deploy|migrate)\b|고쳐|수정|변경|추가|삭제|구현|리팩터|작성|생성|업데이트|적용|실행|해결|배포|출시|마이그레이션/i.test(text);
+}
 function looksLikeConditionalWorkRequest(prompt = '') {
     const text = String(prompt || '').trim();
     if (!text)
@@ -1034,6 +1070,7 @@ function looksLikeExplicitDirectWorkDirective(prompt = '') {
         return false;
     const koreanDirective = /(해\s*줘|해\s*주세요|해달|달라|진행해|수행해|작업해|처리해|적용해|반영해|검수해|고쳐줘|수정해줘|변경해줘|바꿔줘|해결해줘|만들어줘|준비해줘|완료해줘|배포\s*준비|릴리즈\s*준비|다음\s*버전)/i.test(text);
     const englishDirective = /\b(?:please\s+)?(?:fix|repair|resolve|solve|implement|patch|update|change|modify|prepare|ship|release|publish|deploy)\b[\s\S]{0,180}\b(?:for\s+me|now|release|deployment|publish|next\s+version|ship|deploy|prepare)\b/i.test(text)
+        || /^(?:please\s+)?work\s+on\b/i.test(text)
         || /\b(?:prepare|make)\b[\s\S]{0,120}\b(?:next\s+version|release|deployment|publish|ship)\b/i.test(text)
         || /\b(?:fix|repair|resolve|solve|implement|patch|update|change|modify)\b[\s\S]{0,180}\b(?:prepare|ship|release|publish|deploy)\b/i.test(text);
     return koreanDirective || englishDirective;
@@ -1047,34 +1084,80 @@ export function routeNeedsContext7(route, prompt = '') {
         return false;
     return /\b(package|library|framework|SDK|API|MCP|Supabase|React|Next|Vue|Svelte|Vite|Prisma|Drizzle|Knex|Postgres|npm|node_modules|docs?|documentation)\b/i.test(String(prompt || ''));
 }
-export function routeRequiresSubagents(route, prompt = '') {
-    if (!route)
-        return false;
-    if (route.id === 'Team' || route.id === 'Naruto')
-        return true;
-    if (route.id === 'SKS')
-        return looksLikeTeamDefaultWork(prompt);
-    if (route.id === 'Help' || route.id === 'Answer' || route.id === 'Wiki' || route.id === 'ComputerUse' || route.id === 'Commit' || route.id === 'CommitAndPush')
-        return false;
-    if (route.id === 'PPT')
-        return false;
-    if (route.id === 'ImageUXReview')
-        return false;
-    if (route.id === 'SuperSearch')
-        return false;
-    if (route.id === 'SEOGEOOptimizer')
-        return false;
-    if (route.id === 'MadDB')
-        return false;
-    if (route.id === 'Research' || route.id === 'AutoResearch')
-        return true;
-    if (route.id === 'Goal')
-        return looksLikeExecutionWork(prompt) || looksLikeTeamDefaultWork(stripDollarCommand(prompt));
-    if (route.id === 'DB' || route.id === 'GX')
-        return looksLikeExecutionWork(prompt);
-    if (route.id === 'DFix')
-        return looksLikeCodeChangingWork(prompt) && !looksLikeTinyDirectFix(prompt);
-    return looksLikeExecutionWork(prompt);
+const NARUTO_GATE_BYPASS_ROUTE_IDS = new Set([
+    'Answer',
+    'DFix',
+    'Help',
+    'Wiki',
+    'ComputerUse',
+    'Goal',
+    'Commit',
+    'CommitAndPush',
+    'FastMode',
+    'LocalModel',
+    'Planner'
+]);
+const NARUTO_GATE_ROUTE_OWNED_IDS = new Set([
+    'Research',
+    'AutoResearch',
+    'QALoop'
+]);
+const NARUTO_GATE_SPECIALIZED_PARALLEL_ROUTE_IDS = new Set([
+    'Review',
+    'ReleaseReview',
+    'PPT',
+    'ImageUXReview',
+    'SuperSearch',
+    'SEOGEOOptimizer',
+    'DB',
+    'MadDB',
+    'MadSKS',
+    'GX'
+]);
+export function narutoDecisionForRoute(route, prompt = '', profile = classifyTaskProfile(prompt)) {
+    const routeId = route?.id ? String(route.id) : null;
+    if (!routeId) {
+        return narutoRouteDecision('none', null, profile, 'no_route_or_task_context', true);
+    }
+    if (NARUTO_GATE_ROUTE_OWNED_IDS.has(routeId)) {
+        // These routes already own their orchestration lifecycle. The common
+        // Naruto gate records that fact but must not add a second generic fanout.
+        return narutoRouteDecision('route_owned', routeId, profile, `route_owned_orchestration:${routeId}`, false);
+    }
+    if (NARUTO_GATE_BYPASS_ROUTE_IDS.has(routeId)) {
+        return narutoRouteDecision('none', routeId, profile, `lightweight_route_bypass:${routeId}`, true);
+    }
+    if ((routeId === 'Team' || routeId === 'Naruto') && route.explicit_invocation !== false) {
+        return narutoRouteDecision('generic_naruto', routeId, profile, 'explicit_official_subagent_route', false);
+    }
+    if (/(?:^|\s)--(?:agents|clones)(?:=|\s+)\d+\b/i.test(String(prompt || ''))) {
+        return narutoRouteDecision('generic_naruto', routeId, profile, 'explicit_subagent_count', false);
+    }
+    if (NARUTO_GATE_SPECIALIZED_PARALLEL_ROUTE_IDS.has(routeId)) {
+        return narutoRouteDecision('generic_naruto', routeId, profile, `specialized_route_default_parallel:${routeId}`, false);
+    }
+    if (profile === 'passthrough' || profile === 'answer' || profile === 'tiny-change') {
+        return narutoRouteDecision('none', routeId, profile, `task_profile_${profile}_bypass`, true);
+    }
+    if (profile === 'bounded-work' || profile === 'parallel-read' || profile === 'parallel-write' || profile === 'high-risk') {
+        return narutoRouteDecision('generic_naruto', routeId, profile, `task_profile_${profile}_default_parallel`, false);
+    }
+    return narutoRouteDecision('none', routeId, profile, `task_profile_${profile}_bypass`, true);
+}
+export function routeRequiresSubagents(route, prompt = '', profile = classifyTaskProfile(prompt)) {
+    return narutoDecisionForRoute(route, prompt, profile).mode === 'generic_naruto';
+}
+function narutoRouteDecision(mode, routeId, profile, reason, trivial) {
+    const required = mode === 'generic_naruto';
+    return {
+        mode,
+        required,
+        route_id: routeId,
+        task_profile: profile,
+        reason,
+        trivial,
+        default_parallel: required
+    };
 }
 export function simpleGitOnlyRouteId(prompt = '') {
     const text = stripVisibleDecisionAnswerBlocks(String(prompt || '')).trim();
@@ -1115,23 +1198,22 @@ export function subagentExecutionPolicyText(route, prompt = '') {
     const required = routeRequiresSubagents(route, prompt);
     if (route?.id === 'Goal') {
         if (!required)
-            return 'Native session policy: Goal itself is a lightweight native /goal persistence overlay; extra worker sessions are not required for bridge creation/control.';
+            return 'Subagent policy: Goal is a lightweight native /goal persistence overlay; a subagent workflow is not required for bridge creation or control.';
         return [
-            'Native session policy: Goal itself remains a lightweight native /goal persistence overlay.',
-            'Because the prompt also asks for code-changing or execution work, continue that work through the selected SKS execution route and apply that route\'s worker/reviewer policy there.',
+            'Subagent policy: Goal remains a lightweight native /goal persistence overlay.',
+            'Because the prompt also requests explicitly parallel execution, continue through the selected SKS execution route and use that route\'s Codex subagent workflow.',
             noUnrequestedFallbackCodePolicyText()
         ].join(' ');
     }
     if (!required) {
-        return 'Native session policy: optional for this route; open extra native sessions only when parallel exploration materially helps.';
+        return 'Subagent policy: not required for this task profile. Keep the work parent-owned unless a later, concrete decomposition reveals independent slices.';
     }
     return [
-        'Native multi-session policy: REQUIRED for code-changing or execution work in this route.',
-        'The selected SKS route itself authorizes route-owned worker/reviewer native sessions; the user does not need to separately ask for helper sessions when the default Naruto pipeline is active.',
-        'Before editing, the parent orchestrator must visibly state the SKS route, split independent write scopes, and run worker/reviewer native sessions whenever the route can be split safely.',
-        'Determine native tool availability from the callable tool manifest in the current turn and from actual call results. If functions.exec or functions.collaboration.spawn_agent is exposed, use it; never report those tools unavailable because an obsolete CLI alias is missing.',
-        'Run workers in parallel only with disjoint ownership. The parent owns integration, verification, and final evidence.',
-        'If native sessions are unavailable or the work cannot be safely split, record explicit unavailable/unsplittable native-session evidence before editing.',
+        'Codex subagent workflow: required for this explicit Naruto or parallel task.',
+        'The parent agent owns decomposition, integration, scoped verification, and the final answer.',
+        'Delegate only genuinely independent slices. Use Luna Max only for tiny short-context mechanical work, Sol High for ordinary implementation, Sol Max for review/debug/planning/architecture/integration/risk judgment, and Terra Medium for long-context or Computer Use, Browser/Chrome, and image-generation execution.',
+        'Parallel writes require disjoint paths; serialize overlapping paths, prohibit nested delegation, avoid duplicate work, wait for all requested agent threads, and close completed threads after collecting results.',
+        'Completion evidence comes from official SubagentStart/SubagentStop events plus the parent integration summary, not process counts or PID evidence.',
         noUnrequestedFallbackCodePolicyText()
     ].join(' ');
 }
@@ -1162,10 +1244,8 @@ export function routeReasoning(route, prompt = '') {
         return reasoning('low', 'route_policy_low');
     return reasoning('medium', 'simple_fulfillment');
 }
-function narutoRouteReasoning(text = '') {
-    if (/(frontier|autoresearch|novelty|hypothesis|falsify|forensic|from-chat-img|research|current docs?|library|framework|sdk|api|database|supabase|sql|migration|security|permission|mad|release|publish|deploy|commit|push|architecture|algorithm|strategy|planning|integration|refactor|가설|포렌식|리서치|문서|데이터베이스|마이그레이션|보안|권한|배포|커밋|푸쉬|전략|기획|통합|리팩터)/i.test(text))
-        return reasoning('max', 'naruto_complex_or_high_risk_signal');
-    return reasoning('xhigh', 'naruto_gpt56_baseline');
+function narutoRouteReasoning(_text = '') {
+    return reasoning('max', 'naruto_parent_sol_max');
 }
 export function reasoningProfileName(effort) {
     if (effort === 'low')