sneakoscope 2.0.14 → 2.0.15

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

package/dist/core/release/release-gate-affected-selector.js

@@ -0,0 +1,113 @@
+import { spawnSync } from 'node:child_process';
+const ALWAYS_KEEP = new Set([
+    'release:version-truth',
+    'release:dag-full-coverage',
+    'runtime:ts-source-of-truth',
+    'typecheck',
+    'schema:check'
+]);
+export function selectAffectedReleaseGates(root, manifest, gates, input = {}) {
+    if (input.full) {
+        return selectionResult(gates, gates, [], 'full', {}, []);
+    }
+    const changedFiles = resolveChangedFiles(root, input.changedSince || 'auto');
+    const selected = [];
+    const reasons = {};
+    for (const gate of gates) {
+        const reason = gateSelectionReason(gate, changedFiles, input.preset || 'affected');
+        if (reason) {
+            selected.push(gate);
+            reasons[gate.id] = reason;
+        }
+    }
+    const byId = new Map(gates.map((gate) => [gate.id, gate]));
+    for (const id of ALWAYS_KEEP) {
+        const gate = byId.get(id) || manifest.gates.find((candidate) => candidate.id === id);
+        if (gate && !selected.some((row) => row.id === gate.id)) {
+            selected.push(gate);
+            reasons[gate.id] = 'always_keep_core_release_safety';
+        }
+    }
+    const expanded = expandWithDependencies(selected, manifest);
+    const ordered = manifest.gates.filter((gate) => expanded.some((row) => row.id === gate.id));
+    return selectionResult(gates, ordered, changedFiles, 'affected', reasons, gates.filter((gate) => !ordered.some((row) => row.id === gate.id)).map((gate) => gate.id));
+}
+function expandWithDependencies(selected, manifest) {
+    const byId = new Map(manifest.gates.map((gate) => [gate.id, gate]));
+    const out = new Map(selected.map((gate) => [gate.id, gate]));
+    const visit = (gate) => {
+        for (const dep of gate.deps || []) {
+            const depGate = byId.get(dep);
+            if (depGate && !out.has(depGate.id)) {
+                out.set(depGate.id, depGate);
+                visit(depGate);
+            }
+        }
+    };
+    for (const gate of selected)
+        visit(gate);
+    return [...out.values()];
+}
+function gateSelectionReason(gate, changedFiles, preset) {
+    if (ALWAYS_KEEP.has(gate.id))
+        return 'always_keep_core_release_safety';
+    if (!changedFiles.length)
+        return preset === 'fast' ? 'fast_no_diff_core_only_skip' : 'no_changed_files';
+    if (changedFiles.some((file) => file === 'package.json' || file === 'package-lock.json')) {
+        if (/^(release:|publish:|prepublish|runtime:|typecheck|schema:check)/.test(gate.id))
+            return 'package_metadata_changed';
+    }
+    if (changedFiles.some((file) => file === 'release-gates.v2.json' || file.startsWith('src/core/release/') || file.startsWith('src/scripts/release-')))
+        return 'release_gate_system_changed';
+    if (changedFiles.some((file) => file.startsWith('src/core/research/')))
+        return gate.id.startsWith('research:') ? 'research_source_changed' : null;
+    if (changedFiles.some((file) => file.startsWith('src/core/zellij/') || file.startsWith('src/commands/zellij')))
+        return gate.id.startsWith('zellij:') || gate.id.startsWith('agent:zellij') || gate.id.startsWith('naruto:zellij') ? 'zellij_source_changed' : null;
+    if (changedFiles.some((file) => file.includes('/db') || file.includes('mad-db') || file.includes('mcp')))
+        return /db|mcp|mad-db|mad-sks/.test(gate.id) ? 'db_mcp_or_mad_db_changed' : null;
+    const inputs = gate.cache?.inputs || [];
+    if (inputs.some((pattern) => changedFiles.some((file) => matchesGlobish(file, pattern))))
+        return 'cache_input_changed';
+    return null;
+}
+function selectionResult(all, selected, changedFiles, mode, reasons, skipped) {
+    return {
+        gates: selected,
+        selection: {
+            schema: 'sks.release-gate-affected-selection.v1',
+            mode,
+            changed_files: changedFiles,
+            selected_gate_ids: selected.map((gate) => gate.id),
+            skipped_gate_ids: skipped.length ? skipped : all.filter((gate) => !selected.some((row) => row.id === gate.id)).map((gate) => gate.id),
+            reasons
+        }
+    };
+}
+function resolveChangedFiles(root, changedSince) {
+    const base = changedSince === 'auto' ? 'HEAD' : changedSince;
+    const args = base === 'HEAD'
+        ? ['diff', '--name-only', 'HEAD']
+        : ['diff', '--name-only', String(base)];
+    const diff = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+    const status = spawnSync('git', ['status', '--short'], { cwd: root, encoding: 'utf8' });
+    const files = [
+        ...String(diff.stdout || '').split(/\n/),
+        ...String(status.stdout || '').split(/\n/).map((line) => line.slice(3))
+    ].map((file) => file.trim()).filter(Boolean);
+    return [...new Set(files)].sort();
+}
+function matchesGlobish(file, pattern) {
+    const normalized = pattern.replace(/\\/g, '/');
+    if (normalized === file)
+        return true;
+    if (normalized.endsWith('/**'))
+        return file.startsWith(normalized.slice(0, -3));
+    if (normalized.endsWith('/**/*'))
+        return file.startsWith(normalized.slice(0, -5));
+    if (normalized.includes('**'))
+        return file.startsWith(normalized.split('**')[0] || '');
+    if (normalized.endsWith('*'))
+        return file.startsWith(normalized.slice(0, -1));
+    return false;
+}
+//# sourceMappingURL=release-gate-affected-selector.js.map

package/dist/core/release/release-gate-batch-runner.js

@@ -0,0 +1,67 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { writeReleaseGateJson } from './release-gate-report.js';
+const DISALLOWED_BATCH_RESOURCES = new Set(['zellij-real', 'git-worktree', 'local-llm-real', 'remote-model-real', 'publish', 'global-config']);
+export function isReleaseGateBatchable(gate) {
+    if (gate.side_effect !== 'hermetic')
+        return false;
+    if (!gate.resource.includes('cpu-light') || !gate.resource.includes('fs-read'))
+        return false;
+    return gate.resource.every((resource) => resource === 'cpu-light' || resource === 'fs-read') && !gate.resource.some((resource) => DISALLOWED_BATCH_RESOURCES.has(resource));
+}
+export async function runReleaseGateBatch(root, gates, input = {}) {
+    const concurrency = Math.max(1, Math.floor(Number(input.concurrency || process.env.SKS_RELEASE_BATCH_CONCURRENCY || 4)));
+    const nonBatchable = gates.filter((gate) => !isReleaseGateBatchable(gate));
+    if (nonBatchable.length) {
+        return {
+            schema: 'sks.release-gate-batch-result.v1',
+            ok: false,
+            batch_size: gates.length,
+            completed: 0,
+            failed: nonBatchable.length,
+            results: nonBatchable.map((gate) => ({ id: gate.id, ok: false, exit_code: null, duration_ms: 0 }))
+        };
+    }
+    const queue = [...gates];
+    const results = [];
+    const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+        while (queue.length) {
+            const gate = queue.shift();
+            if (!gate)
+                continue;
+            const result = await runOne(root, gate);
+            results.push(result);
+            if (input.reportRoot)
+                writeChildResult(input.reportRoot, result);
+        }
+    });
+    await Promise.all(workers);
+    const failed = results.filter((row) => !row.ok).length;
+    return {
+        schema: 'sks.release-gate-batch-result.v1',
+        ok: failed === 0,
+        batch_size: gates.length,
+        completed: results.length - failed,
+        failed,
+        results
+    };
+}
+function runOne(root, gate) {
+    const started = Date.now();
+    return new Promise((resolve) => {
+        const child = spawn(gate.command, { cwd: root, shell: true, stdio: ['ignore', 'ignore', 'ignore'] });
+        const timer = setTimeout(() => child.kill('SIGTERM'), gate.timeout_ms);
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ id: gate.id, ok: code === 0, exit_code: code, duration_ms: Date.now() - started });
+        });
+    });
+}
+function writeChildResult(reportRoot, result) {
+    const dir = path.join(reportRoot, result.id.replace(/[^A-Za-z0-9_.:-]/g, '_'));
+    writeReleaseGateJson(path.join(dir, 'result.json'), {
+        schema: 'sks.release-gate-batch-child-result.v1',
+        ...result
+    });
+}
+//# sourceMappingURL=release-gate-batch-runner.js.map

package/dist/core/release/release-gate-dag.js

@@ -7,6 +7,7 @@ import { findReadyReleaseGateNodes, findReleaseGatesBlockedByFailedDeps, pickRea
 import { readReleaseGateCacheHit, writeReleaseGateCacheHit } from './release-gate-cache-v2.js';
 import { RELEASE_GATE_NODE_SCHEMA, validateReleaseGateManifest } from './release-gate-node.js';
 import { countReleaseGateResources, defaultReleaseGateBudget, summarizeReleaseGateBudget } from './release-gate-resource-governor.js';
+import { selectAffectedReleaseGates } from './release-gate-affected-selector.js';
 export function loadReleaseGateManifest(root, file = 'release-gates.v2.json') {
     const manifestPath = path.join(root, file);
     const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
@@ -20,7 +21,11 @@ export async function runReleaseGateDag(input) {
     const root = path.resolve(input.root);
     const preset = input.preset || 'release';
     const manifest = loadReleaseGateManifest(root);
-    const selected = selectPreset(manifest, preset);
+    const presetGates = selectReleaseGatePreset(manifest, preset);
+    const affected = (preset === 'affected' || preset === 'fast') && input.full !== true
+        ? selectAffectedReleaseGates(root, manifest, presetGates, { changedSince: input.changedSince || 'auto', preset })
+        : selectAffectedReleaseGates(root, manifest, presetGates, { full: true, preset });
+    const selected = affected.gates;
     const runId = `rg-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
     const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
     fs.mkdirSync(reportDir, { recursive: true });
@@ -33,6 +38,8 @@ export async function runReleaseGateDag(input) {
     const budget = defaultReleaseGateBudget();
     const peakResources = {};
     let cached = 0;
+    const cachedGates = [];
+    const executedGates = [];
     let sumGateMs = 0;
     let peakRunning = 0;
     const writeSummarySnapshot = (finished = false) => {
@@ -45,6 +52,9 @@ export async function runReleaseGateDag(input) {
             selected_preset: preset,
             total_gates: manifest.gates.length,
             selected_gates: selected.length,
+            selected_gate_ids: selected.map((gate) => gate.id),
+            skipped_by_affected: affected.selection.mode === 'affected' ? affected.selection.skipped_gate_ids : [],
+            affected_selection: affected.selection,
             completed: completed.size,
             failed: failed.size,
             cached,
@@ -55,6 +65,12 @@ export async function runReleaseGateDag(input) {
             critical_path_ms: estimateCriticalPath(selected, completed),
             peak_running: peakRunning,
             peak_resources: peakResources,
+            cached_gates: cachedGates,
+            executed_gates: executedGates,
+            slowest_gates: [...completed.values(), ...failed.values()]
+                .sort((a, b) => b.duration_ms - a.duration_ms)
+                .slice(0, 10)
+                .map((row) => ({ id: row.id, duration_ms: row.duration_ms, cached: row.cached })),
             budget_snapshot: budget,
             budget_summary: summarizeReleaseGateBudget(budget),
             report_dir: reportDir,
@@ -82,12 +98,14 @@ export async function runReleaseGateDag(input) {
                 const result = { id: gate.id, ok: true, exit_code: 0, duration_ms: 0, cached: true, stderr_tail: '' };
                 completed.set(gate.id, result);
                 cached += 1;
+                cachedGates.push(gate.id);
                 progressed = true;
                 appendReleaseGateJsonl(timeline, { event: 'cache_hit', gate_id: gate.id, at: new Date().toISOString() });
                 writeSummarySnapshot(false);
                 continue;
             }
             appendReleaseGateJsonl(timeline, { event: 'start', gate_id: gate.id, resource: gate.resource, at: new Date().toISOString() });
+            executedGates.push(gate.id);
             running.set(gate.id, { gate, promise: runGate(root, runId, reportDir, gate) });
             peakRunning = Math.max(peakRunning, running.size);
             const used = countReleaseGateResources([...running.values()].map((row) => row.gate));
@@ -141,8 +159,9 @@ export async function runReleaseGateDag(input) {
     const result = writeSummarySnapshot(true);
     return result;
 }
-function selectPreset(manifest, preset) {
-    return manifest.gates.filter((gate) => gate.preset.includes(preset));
+export function selectReleaseGatePreset(manifest, preset) {
+    const effectivePreset = preset === 'affected' || preset === 'fast' ? 'release' : preset;
+    return manifest.gates.filter((gate) => gate.preset.includes(effectivePreset));
 }
 function runGate(root, runId, reportRoot, gate) {
     const started = Date.now();

package/dist/core/release/release-gate-resource-governor.js

@@ -1,22 +1,27 @@
 import os from 'node:os';
 export function defaultReleaseGateBudget() {
     const cores = Math.max(1, os.cpus().length || 1);
-    return {
-        'cpu-light': Math.min(32, cores * 4),
-        'cpu-heavy': Math.max(1, cores - 1),
-        'io-light': Math.min(64, cores * 8),
-        'io-heavy': Math.min(8, cores),
-        git: Math.min(8, cores),
-        'git-worktree': Math.min(6, cores),
-        python: Math.min(8, cores),
-        network: 8,
+    const base = {
+        'cpu-light': Math.min(48, cores * 6),
+        'cpu-heavy': Math.max(1, cores),
+        'io-light': Math.min(96, cores * 10),
+        'io-heavy': Math.min(12, Math.max(1, cores)),
+        git: Math.min(12, Math.max(1, cores)),
+        'git-worktree': Math.min(8, Math.max(1, cores)),
+        python: Math.min(12, Math.max(1, cores)),
+        network: 12,
         'zellij-real': 1,
         'local-llm-real': Math.max(1, Number(process.env.SKS_LOCAL_LLM_MAX_PARALLEL || 1)),
-        'remote-model-real': 4,
+        'remote-model-real': 6,
         'global-config': 1,
         publish: 1,
-        'fs-read': Math.min(64, cores * 8)
+        'fs-read': Math.min(96, cores * 10)
     };
+    for (const key of Object.keys(base)) {
+        const envName = `SKS_RELEASE_MAX_${key.toUpperCase().replace(/[^A-Z0-9]+/g, '_')}`;
+        base[key] = envInt(envName, base[key]);
+    }
+    return base;
 }
 export function summarizeReleaseGateBudget(budget = defaultReleaseGateBudget()) {
     return Object.entries(budget)
@@ -31,7 +36,10 @@ export function pickLaunchableReleaseGates(input) {
     const budget = input.budget || defaultReleaseGateBudget();
     const used = usedResources(input.running);
     const launchable = [];
+    const maxTotal = envInt('SKS_RELEASE_MAX_TOTAL', Number.POSITIVE_INFINITY);
     for (const gate of input.ready) {
+        if (input.running.length + launchable.length >= maxTotal)
+            break;
         if (fits(gate, used, budget)) {
             launchable.push(gate);
             for (const resource of gate.resource)
@@ -40,6 +48,10 @@ export function pickLaunchableReleaseGates(input) {
     }
     return launchable;
 }
+function envInt(name, fallback) {
+    const parsed = Number(process.env[name]);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
 function usedResources(running) {
     const used = {};
     for (const gate of running) {

package/dist/core/research/implementation-blueprint-densifier.js

@@ -25,7 +25,7 @@ export async function densifyImplementationBlueprint(input) {
         generated_at: nowIso(),
         prompt: input.plan?.prompt || base.prompt || '',
         implementation_allowed_in_research: false,
-        handoff_route: '$Team',
+        handoff_route: '$Naruto',
         repository_aware: true,
         existing_files: likelyFiles,
         possible_new_files: possibleNewFiles,

package/dist/core/research/implementation-blueprint-markdown.js

@@ -4,7 +4,7 @@ export function renderImplementationBlueprintMarkdown(blueprint = null) {
     lines.push('# Research Implementation Blueprint');
     lines.push('');
     lines.push(`Prompt: ${blueprint?.prompt || ''}`);
-    lines.push(`Handoff route: ${blueprint?.handoff_route || '$Team'}`);
+    lines.push(`Handoff route: ${blueprint?.handoff_route || '$Naruto'}`);
     lines.push(`Implementation allowed in Research: ${blueprint?.implementation_allowed_in_research === true ? 'yes' : 'no'}`);
     lines.push('');
     lines.push('## Sections');