sneakoscope 2.0.14 → 2.0.16

package/dist/core/git/git-worktree-manager.js

@@ -4,7 +4,21 @@ import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { evaluateGitWorktreeCapability } from './git-worktree-capability.js';
 import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
 import { sanitizePathPart } from './git-worktree-root.js';
+import { appendParallelRuntimeEvent } from '../agents/parallel-runtime-proof.js';
 export async function allocateWorkerWorktree(input) {
+    const eventRoot = input.repoRoot || process.cwd();
+    const writeProofEvents = await shouldWriteWorktreeAllocationProof(eventRoot, input.missionId);
+    if (writeProofEvents)
+        await appendParallelRuntimeEvent(eventRoot, input.missionId, {
+            event_type: 'worktree_allocation_started',
+            slot_id: input.slotId || input.workerId || null,
+            generation_index: input.generationIndex || 1,
+            session_id: null,
+            pid: null,
+            backend: 'git-worktree',
+            placement: 'unknown',
+            worktree_id: input.workerId || null
+        }).catch(() => undefined);
     const capability = await evaluateGitWorktreeCapability({
         root: input.repoRoot || process.cwd(),
         missionId: input.missionId,
@@ -64,8 +78,63 @@ export async function allocateWorkerWorktree(input) {
         blockers: [...new Set(blockers)]
     };
     await appendWorktreeManifest(allocation);
+    if (writeProofEvents)
+        await appendParallelRuntimeEvent(eventRoot, input.missionId, {
+            event_type: 'worktree_allocation_completed',
+            slot_id: allocation.slot_id,
+            generation_index: allocation.generation_index,
+            session_id: null,
+            pid: null,
+            backend: 'git-worktree',
+            placement: 'unknown',
+            worktree_id: `${allocation.slot_id}-gen-${allocation.generation_index}`,
+            meta: {
+                ok: allocation.ok,
+                worktree_path: allocation.worktree_path,
+                branch: allocation.branch,
+                blockers: allocation.blockers
+            }
+        }).catch(() => undefined);
     return allocation;
 }
+export async function allocateWorkerWorktreesBatch(input) {
+    const maxParallel = Math.max(1, Math.floor(Number(input.maxParallel || 1)));
+    const queue = uniqueWorktreeAllocationInputs(input.workers);
+    const allocations = [];
+    const workers = Array.from({ length: Math.min(maxParallel, queue.length) }, async () => {
+        while (queue.length) {
+            const next = queue.shift();
+            if (!next)
+                continue;
+            allocations.push(await allocateWorkerWorktree({
+                repoRoot: input.root,
+                missionId: input.missionId,
+                workerId: next.workerId,
+                ...(next.slotId === undefined ? {} : { slotId: next.slotId }),
+                ...(next.generationIndex === undefined ? {} : { generationIndex: next.generationIndex }),
+                ...(next.baseRef === undefined ? {} : { baseRef: next.baseRef }),
+                ...(next.branchPrefix === undefined ? {} : { branchPrefix: next.branchPrefix })
+            }));
+        }
+    });
+    await Promise.all(workers);
+    return allocations;
+}
+function uniqueWorktreeAllocationInputs(workers = []) {
+    const seen = new Set();
+    const unique = [];
+    for (const worker of workers) {
+        const workerId = sanitizePathPart(worker.workerId || 'worker');
+        const slotId = sanitizePathPart(worker.slotId || workerId);
+        const generationIndex = Math.max(1, Math.floor(Number(worker.generationIndex || 1)));
+        const key = `${workerId}:${slotId}:${generationIndex}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push({ ...worker, workerId, slotId, generationIndex });
+    }
+    return unique;
+}
 async function appendWorktreeManifest(allocation) {
     const current = await readJson(allocation.manifest_path, null).catch(() => null);
     const allocations = Array.isArray(current?.allocations) ? current.allocations : [];
@@ -84,6 +153,17 @@ async function appendWorktreeManifest(allocation) {
     };
     await writeJsonAtomic(allocation.manifest_path, manifest);
 }
+async function shouldWriteWorktreeAllocationProof(root, missionId) {
+    if (process.env.SKS_GIT_WORKTREE_ALLOCATION_PROOF === '0')
+        return false;
+    try {
+        const stat = await fsp.stat(path.join(root, '.sneakoscope', 'missions', missionId, 'agents'));
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function sanitizeBranchPart(value) {
     return sanitizePathPart(value).replace(/\./g, '-').slice(0, 48) || 'item';
 }

package/dist/core/git/git-worktree-pool.js

@@ -1,4 +1,5 @@
 import { nowIso } from '../fsx.js';
+import { allocateWorkerWorktreesBatch as allocateBatch } from './git-worktree-manager.js';
 export function planGitWorktreePool(input) {
     const reusable = [...(input.reusableWorktrees || [])];
     const assignments = input.workerIds.map((workerId) => {
@@ -20,4 +21,7 @@ export function planGitWorktreePool(input) {
         blockers: []
     };
 }
+export async function allocateWorkerWorktreesBatch(input) {
+    return allocateBatch(input);
+}
 //# sourceMappingURL=git-worktree-pool.js.map

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

@@ -0,0 +1,116 @@
+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,
+        max_operations: Math.max(1, Math.floor(Number(process.env.SKS_MAD_DB_MAX_OPERATIONS || 20))),
+        operation_count: 0
+    };
+    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(capability.operation_count || 0) < Number(capability.max_operations || 20)
+        && Number.isFinite(expires)
+        && expires > nowMs;
+}
+export async function recordMadDbOperation(root, missionId, input = {}) {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!isMadDbCapabilityActive(capability))
+        return capability;
+    const operationCount = Number(capability.operation_count || 0) + 1;
+    const maxOperations = Math.max(1, Number(capability.max_operations || 20));
+    const updated = {
+        ...capability,
+        operation_count: operationCount,
+        max_operations: maxOperations
+    };
+    const dir = missionDir(root, missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), updated);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), {
+        ts: nowIso(),
+        type: 'db_operation.counted',
+        mission_id: missionId,
+        cycle_id: updated.cycle_id,
+        operation_id: input.operationId || null,
+        tool_name: input.toolName || null,
+        sql_hash: input.sqlHash || null,
+        operation_count: operationCount,
+        max_operations: maxOperations
+    });
+    if (operationCount >= maxOperations) {
+        return consumeMadDbCapability(root, missionId, { consumedBy: 'db-safety-checkDbOperation', reason: 'mad_db_max_operations_reached' });
+    }
+    return updated;
+}
+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,31 @@
+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;
+}
+export async function appendMadDbOperationLifecycle(root, missionId, input) {
+    return appendMadDbLedgerEvent(root, missionId, {
+        type: input.type,
+        operation_id: input.operationId,
+        cycle_id: input.cycleId || null,
+        mcp_server: input.mcpServer || null,
+        tool_name: input.toolName || null,
+        sql_hash: input.sqlHash || null,
+        destructive: input.destructive === true,
+        result_status: input.resultStatus || 'unknown_pending_tool_result',
+        row_count: input.rowCount ?? null,
+        error: input.error || null
+    });
+}
+//# sourceMappingURL=mad-db-ledger.js.map

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

@@ -0,0 +1,48 @@
+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,
+        operation_count: capability.operation_count || 0,
+        max_operations: capability.max_operations || 20,
+        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-concurrency-governor.js

@@ -9,6 +9,7 @@ export function decideNarutoConcurrency(input = {}) {
     const hardware = probeHardwareCapacity(input.hardware || {});
     const zellijVisiblePaneCap = normalizePositiveInt(input.zellijVisiblePaneCap, Math.min(8, Math.max(4, Math.floor(hardware.terminal_rows / 5))));
     const backend = String(input.backend || 'codex-sdk');
+    const parallelismMode = normalizeParallelismMode(input.parallelismMode);
     const freeGb = hardware.free_memory_bytes / (1024 * 1024 * 1024);
     const totalGb = hardware.total_memory_bytes / (1024 * 1024 * 1024);
     const reclaimableFloorGb = totalGb >= 32 ? 16 : totalGb >= 16 ? 8 : totalGb >= 8 ? 4 : Math.max(1, freeGb);
@@ -33,7 +34,12 @@ export function decideNarutoConcurrency(input = {}) {
     const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, cpuCap + ioCap, gitWorktreeCap + processCap, backendBudget, queueCap, leaseCap, 100));
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
-    const safeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
+    const currentSafeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
+    const safeActiveWorkers = parallelismMode === 'extreme'
+        ? rawSafe
+        : parallelismMode === 'balanced'
+            ? Math.max(1, Math.min(rawSafe, Math.max(16, Math.floor(rawSafe * 0.75))))
+            : currentSafeActiveWorkers;
     const safeVisible = Math.min(safeActiveWorkers, zellijVisiblePaneCap);
     const reasons = [
         ...(memoryCap < requestedClones ? ['memory_cap'] : []),
@@ -60,11 +66,18 @@ export function decideNarutoConcurrency(input = {}) {
         git_worktree_parallel: gitWorktreeCap,
         cpu_io_parallel: cpuCap + ioCap,
         verification_parallel: Math.max(1, Math.min(hardware.cpu_core_count * 2, safeActiveWorkers, 16)),
+        parallelism_mode: parallelismMode,
         reasons: [...new Set(reasons)],
         backpressure: backpressure.backpressure,
         hardware
     };
 }
+function normalizeParallelismMode(value) {
+    const text = String(value || process.env.SKS_NARUTO_PARALLELISM || 'extreme').toLowerCase();
+    if (text === 'safe' || text === 'balanced' || text === 'extreme')
+        return text;
+    return 'extreme';
+}
 function normalizePositiveInt(value, fallback) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 1)

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',