sneakoscope 2.0.13 → 2.0.15

package/dist/core/commands/team-command.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { appendJsonlBounded, exists, nowIso, readJson, sksRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { initProject } from '../init.js';
-import { createMission, loadMission, setCurrent } from '../mission.js';
+import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
 import { buildQuestionSchema, writeQuestions } from '../questions.js';
 import { CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, ROUTES, hasFromChatImgSignal, routePrompt, routeReasoning, triwikiContextTracking } from '../routes.js';
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, writeTeamRuntimeArtifacts } from '../team-dag.js';
@@ -18,11 +18,13 @@ import { attachZellijSessionInteractive, launchTeamZellijView } from '../zellij/
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { ambientGoalContinuation, flag, readBoundedIntegerFlag, readFlagValue } from './command-utils.js';
+import { narutoCommand } from './naruto-command.js';
 const TEAM_SESSION_CLEANUP_ARTIFACT = 'team-session-cleanup.json';
 export async function team(args = []) {
     const teamSubcommands = new Set(['log', 'tail', 'watch', 'lane', 'status', 'dashboard', 'event', 'message', 'open-zellij', 'attach-zellij', 'cleanup-zellij', 'open-tmux', 'attach-tmux', 'cleanup-tmux']);
     if (teamSubcommands.has(args[0]))
         return teamCommand(args[0], args.slice(1));
+    return redirectTeamCreateToNaruto(args);
     const jsonOutput = flag(args, '--json');
     const mock = flag(args, '--mock');
     const openZellij = !mock && !jsonOutput && !flag(args, '--no-open-zellij') && !flag(args, '--no-zellij');
@@ -200,6 +202,28 @@ export async function team(args = []) {
     console.log(`Watch: sks team watch ${id}`);
     console.log(`Artifacts: .sneakoscope/missions/${id}`);
 }
+async function redirectTeamCreateToNaruto(args = []) {
+    const root = await sksRoot();
+    const list = (args || []).map((arg) => String(arg));
+    const narutoArgs = list[0] === 'run' ? list : ['run', ...list];
+    console.warn('SKS Team is deprecated for new execution missions; redirecting to $Naruto.');
+    const result = await narutoCommand(narutoArgs);
+    const missionId = result?.mission_id || await findLatestMission(root);
+    if (missionId) {
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'missions', missionId, 'team-alias-to-naruto.json'), {
+            schema: 'sks.team-alias-to-naruto.v1',
+            ok: true,
+            mission_id: missionId,
+            source_command: 'sks team',
+            redirected_to: 'sks naruto run',
+            route_command: '$Naruto',
+            deprecated_route: '$Team',
+            created_at: nowIso(),
+            args: list
+        });
+    }
+    return result;
+}
 export function parseTeamCreateArgs(args) {
     const spec = parseTeamSpecArgs(args);
     const prompt = spec.cleanArgs.join(' ').trim();

package/dist/core/db-safety.js

@@ -2,6 +2,9 @@ import path from 'node:path';
 import { exists, readJson, writeJsonAtomic, readText, nowIso, appendJsonlBounded } from './fsx.js';
 import { missionDir, setCurrent } from './mission.js';
 import { evaluateMadSksPermissionGate, isMadSksRouteState } from './permission-gates.js';
+import { resolveMadDbMutationPolicy } from './mad-db/mad-db-policy-resolver.js';
+import { consumeMadDbCapability } from './mad-db/mad-db-capability.js';
+import { appendMadDbLedgerEvent } from './mad-db/mad-db-ledger.js';
 export const DEFAULT_DB_SAFETY_POLICY = Object.freeze({
     schema_version: 1,
     mode: 'read_only_default',
@@ -504,6 +507,29 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
     const policy = await loadDbSafetyPolicy(root);
     const contract = await loadMissionContract(root, state);
     const classification = classifyToolPayload(payload);
+    const madDb = await resolveMadDbMutationPolicy(root, state, classification);
+    if (madDb.allowed === true && state?.mission_id) {
+        const madDbDecision = madDb;
+        const decision = {
+            allowed: true,
+            action: 'allow',
+            reasons: madDb.reasons,
+            classification,
+            effective: { mode: 'mad-db-break-glass', env: 'operator_authorized_one_cycle', destructive: true, migrationApply: 'yes' },
+            mad_db: {
+                active: true,
+                priority: 'highest',
+                one_cycle_only: true,
+                cycle_id: madDbDecision.cycle_id,
+                capability_file: 'mad-db-capability.json',
+                consumed: true
+            }
+        };
+        await appendMadDbLedgerEvent(root, state.mission_id, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification });
+        await consumeMadDbCapability(root, state.mission_id, { consumedBy: 'db-safety-checkDbOperation', reason: 'db_mutation_allowed' });
+        await appendJsonlBounded(path.join(missionDir(root, state.mission_id), 'db-safety.jsonl'), { ts: nowIso(), decision });
+        return decision;
+    }
     const madSks = await madSksOverrideState(root, state);
     const decision = evaluateDbSafety({ classification, policy, contract, duringNoQuestion, madSks });
     if (decision.action === 'confirm')

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.13';
+export const PACKAGE_VERSION = '2.0.15';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/mad-db/mad-db-capability.js

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { findLatestMission, missionDir } from '../mission.js';
+export const MAD_DB_CAPABILITY_SCHEMA = 'sks.mad-db-capability.v1';
+export const MAD_DB_CAPABILITY_FILE = 'mad-db-capability.json';
+export const MAD_DB_ACK = 'I AUTHORIZE ONE-CYCLE DB BREAK-GLASS';
+export const MAD_DB_MAX_TTL_MS = 2 * 60 * 60 * 1000;
+export async function createMadDbCapability(root, input) {
+    if (input.ack !== MAD_DB_ACK)
+        throw new Error('mad_db_ack_phrase_mismatch');
+    const createdAt = nowIso();
+    const ttlMs = Math.min(MAD_DB_MAX_TTL_MS, Math.max(1, Math.floor(Number(input.ttlMs || MAD_DB_MAX_TTL_MS))));
+    const capability = {
+        schema: MAD_DB_CAPABILITY_SCHEMA,
+        mission_id: input.missionId,
+        cycle_id: input.cycleId || `mad-db-${Date.now().toString(36)}`,
+        enabled: true,
+        created_at: createdAt,
+        expires_at: new Date(Date.now() + ttlMs).toISOString(),
+        one_cycle_only: true,
+        priority: 'highest',
+        scope: 'all_database_mutations',
+        operator_ack: {
+            phrase: MAD_DB_ACK,
+            accepted_at: createdAt,
+            cwd: path.resolve(input.cwd || process.cwd())
+        },
+        consumed: false,
+        consumed_at: null,
+        consumed_by: null
+    };
+    const dir = missionDir(root, input.missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), capability);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.created', mission_id: capability.mission_id, cycle_id: capability.cycle_id, expires_at: capability.expires_at });
+    return capability;
+}
+export async function readMadDbCapability(root, missionId) {
+    const capability = await readJson(path.join(missionDir(root, missionId), MAD_DB_CAPABILITY_FILE), null);
+    return capability?.schema === MAD_DB_CAPABILITY_SCHEMA ? capability : null;
+}
+export async function resolveMadDbMissionId(root, state = {}, explicitMissionId = null) {
+    if (explicitMissionId && explicitMissionId !== 'latest')
+        return explicitMissionId;
+    if (state?.mission_id)
+        return String(state.mission_id);
+    return findLatestMission(root);
+}
+export function isMadDbCapabilityActive(capability, nowMs = Date.now()) {
+    if (!capability)
+        return false;
+    const expires = Date.parse(capability.expires_at || '');
+    return capability.enabled === true
+        && capability.consumed !== true
+        && capability.one_cycle_only === true
+        && Number.isFinite(expires)
+        && expires > nowMs;
+}
+export async function consumeMadDbCapability(root, missionId, input = {}) {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!isMadDbCapabilityActive(capability))
+        return capability;
+    const consumed = {
+        ...capability,
+        consumed: true,
+        consumed_at: nowIso(),
+        consumed_by: input.consumedBy || input.reason || 'db-safety-policy-resolver'
+    };
+    const dir = missionDir(root, missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), consumed);
+    await writeJsonAtomic(path.join(dir, 'mad-db-capability.consumed.json'), consumed);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.consumed', mission_id: missionId, cycle_id: consumed.cycle_id, consumed_by: consumed.consumed_by });
+    return consumed;
+}
+export async function revokeMadDbCapability(root, missionId, reason = 'operator_revoked') {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!capability)
+        return null;
+    const revoked = { ...capability, enabled: false, revoked_at: nowIso(), revoke_reason: reason };
+    const dir = missionDir(root, missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), revoked);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.revoked', mission_id: missionId, cycle_id: capability.cycle_id, reason });
+    return revoked;
+}
+//# sourceMappingURL=mad-db-capability.js.map

package/dist/core/mad-db/mad-db-ledger.js

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+export const MAD_DB_LEDGER_EVENT_SCHEMA = 'sks.mad-db-ledger-event.v1';
+export async function appendMadDbLedgerEvent(root, missionId, event) {
+    const row = {
+        schema: MAD_DB_LEDGER_EVENT_SCHEMA,
+        ts: nowIso(),
+        mission_id: missionId,
+        ...event
+    };
+    const dir = missionDir(root, missionId);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), row);
+    await writeJsonAtomic(path.join(dir, 'mad-db-ledger.latest.json'), row).catch(() => undefined);
+    return row;
+}
+//# sourceMappingURL=mad-db-ledger.js.map

package/dist/core/mad-db/mad-db-policy-resolver.js

@@ -0,0 +1,46 @@
+import { readMadDbCapability, isMadDbCapabilityActive } from './mad-db-capability.js';
+export const MAD_DB_POLICY_DECISION_SCHEMA = 'sks.mad-db-policy-decision.v1';
+export async function resolveMadDbMutationPolicy(root, state = {}, classification = {}) {
+    const missionId = state?.mission_id ? String(state.mission_id) : null;
+    if (!missionId)
+        return inactive('mission_id_missing');
+    const capability = await readMadDbCapability(root, missionId);
+    if (!isMadDbCapabilityActive(capability))
+        return inactive(capability?.consumed ? 'mad_db_capability_consumed' : 'mad_db_capability_inactive');
+    if (!isDbMutationOrDbTool(classification))
+        return inactive('not_a_database_mutation');
+    return {
+        schema: MAD_DB_POLICY_DECISION_SCHEMA,
+        allowed: true,
+        action: 'allow',
+        mode: 'mad-db-break-glass',
+        priority: 0,
+        priority_order: ['mad-db', 'mad-sks', 'sealed-contract', 'default-db-safety'],
+        reasons: ['mad_db_one_cycle_break_glass_capability_active'],
+        audit_required: true,
+        mission_id: missionId,
+        cycle_id: capability.cycle_id,
+        capability
+    };
+}
+function inactive(reason) {
+    return {
+        schema: MAD_DB_POLICY_DECISION_SCHEMA,
+        allowed: false,
+        action: 'defer',
+        mode: 'default-db-safety',
+        priority: 99,
+        reasons: [reason],
+        audit_required: false
+    };
+}
+function isDbMutationOrDbTool(classification = {}) {
+    if (classification.level === 'write' || classification.level === 'destructive')
+        return true;
+    if (classification.toolReasons?.includes?.('database_tool'))
+        return true;
+    if (classification.toolReasons?.includes?.('migration_apply_tool'))
+        return true;
+    return false;
+}
+//# sourceMappingURL=mad-db-policy-resolver.js.map

package/dist/core/naruto/naruto-real-worker-child.js

@@ -32,7 +32,7 @@ async function main() {
             generationIndex: 1,
             sessionId: String(intake.item.id || ''),
             cwd: String(intake.worktree_path || process.cwd()),
-            prompt: buildNarutoWorkerPrompt(intake.item),
+            prompt: buildNarutoWorkerPrompt(intake.item, intake.parent_prompt),
             outputSchemaId: CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
             outputSchema: codexAgentWorkerResultSchema,
             sandboxPolicy: intake.item.write_allowed === true ? 'workspace-write' : 'read-only',
@@ -109,10 +109,12 @@ function backendPreference(value) {
         return ['local-llm', 'codex-sdk'];
     return ['codex-sdk'];
 }
-function buildNarutoWorkerPrompt(item) {
+function buildNarutoWorkerPrompt(item, parentPrompt) {
     const writeAllowed = item?.write_allowed === true;
+    const parentObjective = normalizeWorkerPromptText(parentPrompt);
     return [
         'You are a Naruto route worker. Complete only this assigned work item and return JSON matching the required schema.',
+        parentObjective ? `Parent Naruto objective:\n${parentObjective}` : null,
         `Work item: ${String(item?.id || '')} ${String(item?.title || item?.kind || '')}`,
         `Role: ${String(item?.required_role || 'worker')}`,
         `Kind: ${String(item?.kind || 'verification')}`,
@@ -122,8 +124,14 @@ function buildNarutoWorkerPrompt(item) {
         writeAllowed
             ? 'If changes are needed, return model-authored patch_envelopes scoped to write paths.'
             : 'This is read-only work. Do not mutate files and return an empty patch_envelopes array.',
+        writeAllowed
+            ? null
+            : 'For read-only work, inspect requested files/artifacts only; do not run package scripts, build commands, tests, or temp-file-creating checks unless the parent objective explicitly requires them.',
         'Include verification checks, rollback notes, blockers, findings, and changed_files.'
-    ].join('\n');
+    ].filter(Boolean).join('\n');
+}
+function normalizeWorkerPromptText(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 4000);
 }
 main().then(() => {
     process.exit(0);

package/dist/core/naruto/naruto-real-worker-runtime.js

@@ -29,6 +29,7 @@ export async function spawnActualNarutoWorker(input) {
         generated_at: nowIso(),
         mission_id: input.missionId,
         item: input.item,
+        parent_prompt: normalizeWorkerPromptText(input.parentPrompt),
         placement: input.placement,
         backend: input.backend,
         result_path: resultPath,
@@ -85,6 +86,9 @@ export async function collectActualNarutoWorker(handle) {
         blockers
     };
 }
+function normalizeWorkerPromptText(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 4000);
+}
 function actualWorkerEntrypoint() {
     return fileURLToPath(new URL('./naruto-real-worker-child.js', import.meta.url));
 }

package/dist/core/pipeline/final-gpt-patch-stage.js

@@ -5,17 +5,18 @@ export function selectFinalGptPatchSource(gptFinal, localPatchEnvelopes = []) {
             schema: 'sks.final-gpt-patch-stage.v1',
             ok: true,
             final_patch_source: 'gpt_final_arbiter',
-            patch_envelopes: Array.isArray(gptFinal?.result?.modified_patch_envelopes) ? gptFinal.result.modified_patch_envelopes : [],
+            patch_envelopes: decodePatchDecisionItems(gptFinal?.result?.modified_patch_envelopes),
             blockers: []
         };
     }
     if (status === 'approved') {
+        const accepted = decodePatchDecisionItems(gptFinal?.result?.accepted_patch_envelopes);
         return {
             schema: 'sks.final-gpt-patch-stage.v1',
             ok: true,
             final_patch_source: 'gpt_final_arbiter',
-            patch_envelopes: Array.isArray(gptFinal?.result?.accepted_patch_envelopes) && gptFinal.result.accepted_patch_envelopes.length
-                ? gptFinal.result.accepted_patch_envelopes
+            patch_envelopes: accepted.length
+                ? accepted
                 : localPatchEnvelopes,
             blockers: []
         };
@@ -28,4 +29,20 @@ export function selectFinalGptPatchSource(gptFinal, localPatchEnvelopes = []) {
         blockers: ['gpt_final_not_approved']
     };
 }
+function decodePatchDecisionItems(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        if (entry && typeof entry === 'object' && typeof entry.patch_envelope_json === 'string') {
+            try {
+                const parsed = JSON.parse(entry.patch_envelope_json);
+                return parsed && typeof parsed === 'object' && Object.keys(parsed).length ? [parsed] : [];
+            }
+            catch {
+                return [];
+            }
+        }
+        return entry && typeof entry === 'object' ? [entry] : [];
+    });
+}
 //# sourceMappingURL=final-gpt-patch-stage.js.map

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

@@ -39,7 +39,7 @@ function ambientGoalContinuation() {
         mode: 'ambient_codex_native_goal_overlay',
         native_slash_command: '/goal',
         non_disruptive: true,
-        rule: 'Use Codex native goal persistence when available to keep work resumable until completion; it never replaces the selected SKS route, Team, TriWiki, verification, reflection, or Honest Mode gates.'
+        rule: 'Use Codex native goal persistence when available to keep work resumable until completion; it never replaces the selected SKS route, Naruto, TriWiki, verification, reflection, or Honest Mode gates.'
     };
 }
 const REFLECTION_ARTIFACT = 'reflection.md';
@@ -279,7 +279,7 @@ function selectPipelineLane(route, task, proof) {
     if (LIGHTWEIGHT_ROUTES.has(route?.id))
         return { lane: `${String(route.id).toLowerCase()}_lightweight_lane`, source: 'route_policy', fast_lane_allowed: true, reason: 'Lightweight route bypasses full mission orchestration by design.', blockers: [], skip_when_fast: SPEED_LANE_POLICY.skip_when_fast, keep: ['focused_implementation', 'listed_verification', 'honest_mode'] };
     if (routeRequiresSubagents(route, task))
-        return { lane: SPEED_LANE_POLICY.full_lane, source: 'route_policy', fast_lane_allowed: false, reason: 'No Proof Field attached and this route normally requires full Team evidence.', blockers: ['proof_field_not_attached'], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
+        return { lane: SPEED_LANE_POLICY.full_lane, source: 'route_policy', fast_lane_allowed: false, reason: 'No Proof Field attached and this route normally requires full Naruto evidence.', blockers: ['proof_field_not_attached'], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
     return { lane: SPEED_LANE_POLICY.balanced_lane, source: 'route_policy', fast_lane_allowed: false, reason: 'Balanced parent-owned route until Proof Field proves a narrower lane.', blockers: ['proof_field_not_attached'], skip_when_fast: [], keep: SPEED_LANE_POLICY.always_keep };
 }
 function buildPipelineStages(route, task, ambiguity, lane, context7Required, agentPolicy = normalizeAgentPolicy(route, task, {})) {
@@ -343,8 +343,11 @@ function planNextActions(route, task, ambiguity, lane, agentPolicy = normalizeAg
     const actions = ['read pipeline-plan.json before work', 'execute kept stages only', 'run listed verification'];
     if (agentPolicy.required)
         actions.splice(1, 0, 'run sks agents run latest --json before implementation');
-    if (!lane.fast_lane_allowed && routeRequiresSubagents(route, task))
-        actions.splice(1, 0, 'materialize full Team artifacts before implementation');
+    if (!lane.fast_lane_allowed && routeRequiresSubagents(route, task)) {
+        actions.splice(1, 0, route?.id === 'Naruto'
+            ? 'materialize Naruto clone roster, work graph, worker proof, and naruto-gate.json before implementation'
+            : 'materialize full Team artifacts before implementation');
+    }
     if (looksLikeProblemSolvingRequest(task))
         actions.splice(1, 0, 'run Solution Scout web search for similar fixes before editing');
     actions.push('refresh/validate TriWiki when required', 'finish with completion summary and Honest Mode');
@@ -372,10 +375,10 @@ export function promptPipelineContext(prompt, route = null) {
         '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.',
         'Plan-first interaction: when ambiguity questions are truly required, show the user only the missing human decision(s), then seal the decision contract internally and execute/verify.',
-        'Question-shaped directive policy: before using Answer, decide whether a question is a real information request or an implicit instruction/complaint about broken behavior. Rhetorical bug reports, mandatory-policy statements, and "why is this not happening?" execution complaints must route to Team, not Answer.',
+        'Question-shaped directive policy: before using Answer, decide whether a question is a real information request or an implicit instruction/complaint about broken behavior. Rhetorical bug reports, mandatory-policy statements, and "why is this not happening?" execution complaints must route to Naruto, not Answer.',
         'Best-practice prompt shape: extract Goal, Context, Constraints, and Done-when before implementation; keep questions compact and only ask for answers that can change scope, safety, user-facing behavior, or acceptance criteria.',
         chatCaptureIntakeText(),
-        'Default execution routing: general implementation/code-changing prompts promote to Team so the normal path is parallel analysis, TriWiki refresh, debate/consensus, then fresh parallel executors. Answer, DFix, Help, Wiki maintenance, and safety-specific routes are intentional exceptions.',
+        'Default execution routing: general implementation/code-changing prompts promote to Naruto so the normal path is shadow-clone fan-out, hardware-safe concurrency, patch envelopes, verification DAG, and GPT final arbitration. Answer, DFix, Help, Wiki maintenance, and safety-specific routes are intentional exceptions.',
         'Stance: infer the user intent aggressively from rough wording, local context, TriWiki, and conservative defaults; do not surface prequestion sheets before work.',
         subagentExecutionPolicyText(route, cleanPrompt),
         solutionScoutPolicyText(cleanPrompt),
@@ -397,8 +400,10 @@ export function promptPipelineContext(prompt, route = null) {
     ];
     if (reflectionRequiredForRoute(route))
         lines.push(reflectionInstructionText());
+    if (route?.id === 'Naruto')
+        lines.push(`Naruto route: build clone roster, massive work graph, hardware-safe governor, active pool, allocation/rebalance policy, parallel verification DAG, GPT final pack, per-clone proof, session cleanup, reflection, and Honest Mode. $Team is deprecated for new execution missions.`);
     if (route?.id === 'Team')
-        lines.push(`Team route: agents, TriWiki refresh, debate, consensus, runtime graph compile with concrete task ids and worker inboxes, close planning agents, fresh executors, minimum ${MIN_TEAM_REVIEWER_LANES}-lane review/integration, ${TEAM_SESSION_CLEANUP_ARTIFACT}, reflection, and Honest Mode. ${MIN_TEAM_REVIEW_POLICY_TEXT}`);
+        lines.push(`Team route is a deprecated compatibility surface; use $Naruto for new execution missions. Existing Team mission observation commands remain available.`);
     if (route?.id === 'Goal')
         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')
@@ -473,8 +478,10 @@ export async function prepareRoute(root, prompt, state = {}) {
     const nativeSessionsRequired = routeRequiresSubagents(route, cleanPrompt);
     if (QUESTION_GATE_ROUTES.has(route.id) || route.id === 'MadSKS')
         return withSkillDreamContext(await prepareClarificationGate(root, route, task, required, { madSksAuthorization }), dreamContext);
+    if (route.id === 'Naruto')
+        return withSkillDreamContext(await prepareNaruto(root, route, task, required, { madSksAuthorization }), dreamContext);
     if (route.id === 'Team')
-        return withSkillDreamContext(await prepareTeam(root, route, task, required, { madSksAuthorization }), dreamContext);
+        return withSkillDreamContext(await prepareNaruto(root, { ...route, id: 'Naruto', command: '$Naruto', mode: 'NARUTO', stopGate: 'naruto-gate.json', requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'] }, task, required, { madSksAuthorization, teamAlias: true }), dreamContext);
     if (route.id === 'Research')
         return withSkillDreamContext(await prepareResearch(root, route, task, required), dreamContext);
     if (route.id === 'AutoResearch')
@@ -626,6 +633,10 @@ export async function activeRouteContext(root, state) {
         const roles = state.role_counts ? ` Role counts: ${formatRoleCounts(state.role_counts)}.` : '';
         return `Active Team mission ${state.mission_id || 'latest'} must keep the user-visible live transcript updated. Native session budget: ${state.agent_sessions || MIN_TEAM_REVIEWER_LANES}.${roles} Run native sessions, TriWiki refresh, debate, consensus, fresh development, minimum ${MIN_TEAM_REVIEWER_LANES}-lane review/integration, then close or account for every Team native session and write ${TEAM_SESSION_CLEANUP_ARTIFACT} before reflection/final. ${MIN_TEAM_REVIEW_POLICY_TEXT} After each native-session status/result/handoff, run: sks team event ${state.mission_id || 'latest'} --agent <name> --phase <phase> --message "...". Inspect with sks team log/watch ${state.mission_id || 'latest'}.${reasoningNote}${context7}${planNote}`;
     }
+    if (state.mode === 'NARUTO') {
+        const clones = state.clone_count ? ` Clone count: ${state.clone_count}.` : '';
+        return `Active Naruto mission ${state.mission_id || 'latest'} must keep clone/worker evidence current.${clones} Use sks naruto status ${state.mission_id || 'latest'} --json, inspect .sneakoscope/missions/${state.mission_id || 'latest'}/naruto-gate.json and agents/agent-proof-evidence.json, then continue until the Naruto gate passes or a hard blocker is recorded.${reasoningNote}${planNote}`;
+    }
     if (state.subagents_required && !(await hasSubagentEvidence(root, state))) {
         return `Active SKS route ${id} requires native multi-session evidence before code-changing work can be considered complete. Run worker/reviewer native sessions for disjoint write scopes, or record explicit unavailable/unsplittable native-session evidence before editing.${reasoningNote}${planNote}`;
     }
@@ -1069,6 +1080,61 @@ async function prepareLightRoute(root, route, task, required) {
     await setCurrent(root, routeState(id, route, 'ROUTE_CONTEXT_READY', required, { prompt: task, stop_gate: 'none', pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }));
     return routeContext(route, id, task, required, 'Load the route skill context, execute the smallest matching action, and finish with Honest Mode.');
 }
+async function prepareNaruto(root, route, task, required, opts = {}) {
+    const cleanTask = stripDollarCommand(task) || String(task || '').trim();
+    const { id, dir } = await createMission(root, { mode: 'naruto', prompt: cleanTask });
+    const routeContextPayload = {
+        route: 'Naruto',
+        command: '$Naruto',
+        mode: 'NARUTO',
+        task: cleanTask,
+        required_skills: route.requiredSkills || ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
+        context7_required: required,
+        context_tracking: triwikiContextTracking(),
+        stop_gate: 'naruto-gate.json',
+        team_alias: opts.teamAlias === true,
+        mad_sks_authorization: Boolean(opts.madSksAuthorization)
+    };
+    await writeJsonAtomic(path.join(dir, 'route-context.json'), routeContextPayload);
+    await writeJsonAtomic(path.join(dir, 'naruto-gate.json'), {
+        schema: 'sks.naruto-gate.v1',
+        passed: false,
+        mission_id: id,
+        clone_roster_built: false,
+        work_graph_ready: false,
+        role_distribution_ready: false,
+        allocation_ready: false,
+        rebalance_ready: false,
+        concurrency_governor_ready: false,
+        active_pool_simulated: false,
+        verification_dag_ready: false,
+        gpt_final_pack_ready: false,
+        zellij_dashboard_ready: false,
+        native_agent_proof: false,
+        final_arbiter_accepted: false,
+        session_cleanup: false,
+        blockers: ['naruto_run_not_started'],
+        updated_at: nowIso()
+    });
+    const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: cleanTask, required, ambiguity: { required: false, status: opts.teamAlias ? 'team_alias_to_naruto' : 'direct_naruto' } });
+    await setCurrent(root, routeState(id, route, 'NARUTO_READY', required, {
+        prompt: cleanTask,
+        route: 'Naruto',
+        route_command: '$Naruto',
+        mode: 'NARUTO',
+        implementation_allowed: true,
+        ambiguity_gate_required: false,
+        ambiguity_gate_passed: true,
+        stop_gate: 'naruto-gate.json',
+        required_skills: routeContextPayload.required_skills,
+        subagents_required: true,
+        native_sessions_required: true,
+        naruto_gate_file: 'naruto-gate.json',
+        pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
+        pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
+    }));
+    return routeContext(route, id, cleanTask, required, `Run sks naruto run ${JSON.stringify(cleanTask)} --json (or continue with Codex native workers for the same mission), then update naruto-gate.json from the worker proof and verification DAG.`);
+}
 function routeState(id, route, phase, context7Required, extra = {}) {
     const reasoning = routeReasoning(route, extra.prompt || '');
     const nativeSessionsRequired = routeRequiresSubagents(route, extra.prompt || '');

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

@@ -371,6 +371,24 @@ function missingRequiredGateFields(file, state, gate = {}) {
         return required
             .filter((key) => gate[key] !== true);
     }
+    if (file === 'naruto-gate.json' || mode === 'NARUTO') {
+        const required = [
+            'clone_roster_built',
+            'work_graph_ready',
+            'role_distribution_ready',
+            'allocation_ready',
+            'rebalance_ready',
+            'concurrency_governor_ready',
+            'active_pool_simulated',
+            'verification_dag_ready',
+            'gpt_final_pack_ready',
+            'zellij_dashboard_ready',
+            'native_agent_proof',
+            'final_arbiter_accepted',
+            'session_cleanup'
+        ];
+        return required.filter((key) => gate[key] !== true);
+    }
     if (file === 'qa-gate.json' || mode === 'QALOOP') {
         const required = ['clarification_contract_sealed', 'qa_report_written', 'qa_ledger_complete', 'checklist_completed', 'safety_reviewed', 'deployed_destructive_tests_blocked', 'credentials_not_persisted', 'honest_mode_complete'];
         if (gate.ui_e2e_required === true)
@@ -405,6 +423,8 @@ async function missingRequiredGateArtifacts(root, file, state, gate = {}) {
     }
     if (file === IMAGE_UX_REVIEW_GATE_ARTIFACT || mode === 'IMAGE_UX_REVIEW')
         return missingImageUxReviewArtifacts(root, state, gate);
+    if (file === 'naruto-gate.json' || mode === 'NARUTO')
+        return missingNarutoArtifacts(root, state, gate);
     if (file !== 'team-gate.json' && mode !== 'TEAM')
         return [];
     const missing = [];
@@ -611,6 +631,8 @@ function gateFilesForState(state) {
         return ['goal-workflow.json'];
     if (state.mode === 'RESEARCH')
         return ['research-gate.json', 'research-gate.evaluated.json'];
+    if (state.mode === 'NARUTO')
+        return ['naruto-gate.json'];
     if (state.mode === 'TEAM')
         return ['team-gate.json'];
     if (state.mode === 'AUTORESEARCH')
@@ -627,6 +649,28 @@ function gateFilesForState(state) {
         return [IMAGE_UX_REVIEW_GATE_ARTIFACT];
     return ['done-gate.json'];
 }
+async function missingNarutoArtifacts(root, state = {}, gate = {}) {
+    const id = state?.mission_id;
+    if (!id)
+        return ['mission_id'];
+    const dir = missionDir(root, id);
+    const required = [
+        'naruto-gate.json',
+        'agents/naruto-work-graph.json',
+        'agents/naruto-role-distribution.json',
+        'agents/naruto-concurrency-governor.json',
+        'agents/naruto-verification-dag.json',
+        'agents/naruto-gpt-final-pack.json'
+    ];
+    const missing = [];
+    for (const file of required) {
+        if (!(await exists(path.join(dir, file))))
+            missing.push(file);
+    }
+    if (gate.native_agent_proof === true && !(await exists(path.join(dir, 'agents', 'agent-proof-evidence.json'))))
+        missing.push('agents/agent-proof-evidence.json');
+    return missing;
+}
 function extractLastMessage(payload) {
     return payload.last_assistant_message || payload.assistant_message || payload.message || payload.response || payload.raw || '';
 }

package/dist/core/proof/route-proof-gate.js

@@ -1,7 +1,7 @@
 import { containsPlaintextSecret } from '../secret-redaction.js';
 import { readRouteProof } from './proof-reader.js';
 import { validateCompletionProof } from './validation.js';
-import { proofStatusBlocks, routeRequiresCompletionProof, routeRequiresImageVoxelAnchors } from './route-proof-policy.js';
+import { normalizeProofRoute, proofStatusBlocks, routeRequiresCompletionProof, routeRequiresImageVoxelAnchors } from './route-proof-policy.js';
 import { routeRequiresAgentIntake } from '../agents/agent-plan.js';
 export async function validateRouteCompletionProof(root, { missionId = null, route = null, state = {}, visualClaim = undefined } = {}) {
     const proofRequired = state.proof_required === true || routeRequiresCompletionProof(route);
@@ -34,11 +34,13 @@ export async function validateRouteCompletionProof(root, { missionId = null, rou
         else {
             if (agents.status !== 'passed' || agents.ok !== true)
                 issues.push('agent_gate_not_passed');
+            const normalizedRoute = normalizeProofRoute(route || proof.route);
+            const maxAgentCount = normalizedRoute === '$Naruto' ? 100 : 20;
             const agentCount = Number(agents.agent_count || 0);
             if (agentCount < 5)
                 issues.push('agent_count_below_5');
-            if (agentCount > 20)
-                issues.push('agent_count_above_20');
+            if (agentCount > maxAgentCount)
+                issues.push(`agent_count_above_${maxAgentCount}`);
             if (agents.all_sessions_closed !== true)
                 issues.push('agent_sessions_not_closed');
             if (agents.no_overlap_ok !== true)

package/dist/core/proof/route-proof-policy.js

@@ -1,5 +1,8 @@
 export const SERIOUS_ROUTE_ALIASES = Object.freeze([
     '$Team',
+    '$Naruto',
+    '$ShadowClone',
+    '$Kagebunshin',
     '$DFix',
     '$QA-LOOP',
     '$Research',
@@ -35,7 +38,12 @@ export const VISUAL_ROUTE_ALIASES = Object.freeze([
     '$GX'
 ]);
 const ROUTE_NORMALIZATION = Object.freeze({
-    team: '$Team',
+    team: '$Naruto',
+    naruto: '$Naruto',
+    shadowclone: '$Naruto',
+    'shadow-clone': '$Naruto',
+    kagebunshin: '$Naruto',
+    'kage-bunshin': '$Naruto',
     dfix: '$DFix',
     qaloop: '$QA-LOOP',
     'qa-loop': '$QA-LOOP',