sneakoscope 2.0.14 → 2.0.16

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.14** is the public-ready research runtime stabilization release. It upgrades Research from a quality-contract package into a real stage-aware runtime with parallel source shards, source-ledger merge, claim matrix builder, repository-aware implementation blueprint, Codex/GPT final reviewer, and blackbox gates while preserving the 2.0.13 research artifact contract.
+SKS **2.0.16** is the real parallelism closure release. It proves Naruto/agent runtime concurrency with PID, launch overlap, wall-clock speedup, active/headless worker, model-call, worktree allocation, and incremental Zellij telemetry evidence while keeping Naruto as the execution SSOT.
 
 What changed:
 
@@ -44,6 +44,9 @@ What changed:
 - Zellij proof now links `pane_id`, `slot_id`, `generation_index`, `session_id`, `sdk_thread_id`, provider, and `service_tier`.
 - Production runtime scripts are TypeScript source under `src/scripts` and build to `dist/scripts`; Python remains optional diagnostics under `pytools`.
 - Release gates include `codex-control:*`, `ultra-router:*`, `codex-sdk:*`, Codex App Fast UI preservation, provider badges, Zellij spawn-on-demand, slot/pane binding, release truth, and real smoke checks.
+- Research synthesis is now evidence-bound in non-mock runs; deterministic report generation is mock/fallback only.
+- Research quality checks reject repeated paragraphs, template-like prose, low source density, low claim density, and thin implementation sections.
+- Research handoffs now include context, key claims, evidence summary, blueprint sections, parallel work items, acceptance tests, rollback, and source appendix for `$Team` or `$Naruto`.
 
 Quick checks:
 
@@ -466,7 +469,7 @@ sks code-structure scan --json
 
 `sks research` prepares a named genius-lens agent council, requires every agent to run at `xhigh`, records one literal `Eureka!` idea per agent, runs an evidence-bound debate, and creates `research-source-skill.md` as a route-local source collection skill before synthesis. Research is not a code-change route: real runs may write only their own mission artifacts under `.sneakoscope/missions/<id>/`, and source/package/docs/config mutations block the run with `research-code-mutation-blocker.json`. The required Research persona lenses are Einstein Agent, Feynman Agent, Turing Agent, von Neumann Agent, and Skeptic Agent; they are cognitive roles, not impersonations, and `agent-ledger.json` must include `display_name`, `persona`, `persona_boundary`, `reasoning_effort`, falsifiers, cheap probes, and `challenge_or_response`. Normal Research is not a fixed three-cycle flow: it repeats source gathering, Eureka ideas, debate, falsification, and synthesis pressure until every agent records final agreement, or pauses at the explicit max-cycle safety cap with an unpassed gate. `debate-ledger.json` must include `consensus_iterations`, `unanimous_consensus`, and per-agent agreements; `research-gate.json` cannot pass until unanimous consensus is true for all agents. Normal Research is intentionally allowed to take one or two hours when the problem needs it; `--mock` is only for selftests or dry harness checks, and a real run blocks with `research-blocker.json` instead of silently substituting mock output when the Codex execution path is unavailable. The source layer contract separates latest papers, official/government or leading-institution sources, standards/primary docs, current news such as BBC/CNN/GDELT-style sources, public discourse such as X/Reddit, developer/practitioner knowledge such as Stack Overflow/GitHub, traditional background sources, and counterevidence/fact-checking; `source-ledger.json` must record layer coverage, source quality, blockers, citations, and cross-layer triangulation. Context7 is optional for `$Research` and only becomes relevant when the research topic specifically depends on package, API, framework, or SDK documentation. Research runs require `research-report.md`, `research-paper.md`, `genius-opinion-summary.md`, `research-source-skill.md`, `source-ledger.json`, `agent-ledger.json`, `debate-ledger.json`, `novelty-ledger.json`, `falsification-ledger.json`, and `research-gate.json` so they stay source-backed, adversarially checked, falsifiable, paper-ready, and clear about every agent lens opinion. `research status` reports source entries, source-layer coverage, triangulation checks, counterevidence, xhigh agent count, Eureka moments, debate exchanges, consensus iterations, unanimous consensus, paper presence/sections, genius-opinion summary coverage, agent findings, and falsification cases alongside the gate.
 
-In 2.0.14, Research also writes a quality contract and handoff package: `research-quality-contract.json`, parallel `research/cycle-N/source-shards/*.json`, `source-ledger.json`, `claim-evidence-matrix.json`, `source-quality-report.json`, `implementation-blueprint.json`/`.md`, `team-handoff-goal.md`, `experiment-plan.json`/`.md`, `replication-pack.json`, `research-work-graph.json`, `research-final-review.static.json`, `research-final-review.codex.json`, and `research-final-review.json`. The default gate requires 12 total sources, 5 source layers, 2 counterevidence sources, 8 key claims, 6 triangulated claims, 8 blueprint sections, 4 falsification cases, 5 experiment steps, a 2200-word report, and approved static plus Codex/GPT final review before `research-gate.json` can pass. See `docs/research-pipeline.md`, `docs/research-artifacts.md`, and `docs/research-implementation-handoff.md`.
+In 2.0.15, Research also writes a quality contract and handoff package: `research-quality-contract.json`, parallel `research/cycle-N/source-shards/*.json`, `source-ledger.json`, `claim-evidence-matrix.json`, `source-quality-report.json`, `research-synthesis-output.json`, `implementation-blueprint.json`/`.md`, `team-handoff-goal.md`, `experiment-plan.json`/`.md`, `replication-pack.json`, `research-work-graph.json`, `research-final-review.static.json`, `research-final-review.codex.json`, and `research-final-review.json`. The default gate requires 12 total sources, 5 source layers, 2 counterevidence sources, 8 key claims, 6 triangulated claims, 8 blueprint sections, 4 falsification cases, 5 experiment steps, a 2200-word report, approved static plus Codex/GPT final review, and anti-template/source-density report quality before `research-gate.json` can pass. See `docs/research-pipeline.md`, `docs/research-artifacts.md`, and `docs/research-implementation-handoff.md`.
 
 `sks recallpulse` is the 0.8.0 report-only RecallPulse utility. It writes `recallpulse-decision.json`, `mission-status-ledger.json`, `route-proof-capsule.json`, `evidence-envelope.json`, `recallpulse-governance-report.json`, `recallpulse-task-goal-ledger.json`, and `recallpulse-eval-report.json` for the current mission. RecallPulse does not replace route gates, Honest Mode, DB safety, imagegen evidence, or TriWiki validation; it records cache hits, hydration needs, duplicate suppression, route-governance risks, and final-summary-ready durable status so later releases can promote only measured improvements. Checklist updates are sequential: every `Txxx` row is treated as a child `$Goal` checkpoint, and `sks recallpulse checklist ... --task T001 --apply` refuses out-of-order checks unless explicitly overridden.
 
@@ -756,7 +759,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the current 1.21.x release-closure DAG, writes a source digest stamp under `.sneakoscope/reports/`, then refreshes release readiness so publish commands can verify the same stamp. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, and Goal mode propagation checks. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` verifies the fresh release stamp instead of rerunning the full gate, and `prepack` only rebuilds `dist`; publish no longer repeats the expensive release suite during packaging. `npm run publish:dry` remains the explicit dry-run helper.
+`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` and `npm run publish:dry` both run `release:check:full`, verify the fresh stamp, and then run provenance/registry checks before the real or dry-run publish step.
 
 Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "2.0.14"
+version = "2.0.16"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.14"
+version = "2.0.16"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 2.0.14"),
+        Some("--version") => println!("sks-rs 2.0.16"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "2.0.14",
-  "source_digest": "e559602363886e06dc0d079905dacbaddcadccd0617447573f90240aa9b8f2f4",
-  "source_file_count": 2104,
-  "built_at_source_time": 1780852294757
+  "package_version": "2.0.16",
+  "source_digest": "cafc32cad87d3b6c7aeb0ec0e8e56258f830b35e71fd919440a8c1b95b78432a",
+  "source_file_count": 2187,
+  "built_at_source_time": 1780927200051
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '2.0.14';
+const FAST_PACKAGE_VERSION = '2.0.16';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/command-registry.js

@@ -109,6 +109,7 @@ export const COMMANDS = {
     zellij: entry('beta', 'Inspect Zellij runtime status and explain repair (no auto-install)', 'dist/commands/zellij.js', directCommand(() => import('../commands/zellij.js'), 'dist/commands/zellij.js')),
     mad: entry('beta', 'MAD-SKS Zellij permission launcher', 'dist/commands/mad-sks.js', directCommand(() => import('../commands/mad-sks.js'), 'dist/commands/mad-sks.js')),
     'mad-sks': entry('beta', 'MAD-SKS scoped permission modifier', 'dist/commands/mad-sks.js', directCommand(() => import('../commands/mad-sks.js'), 'dist/commands/mad-sks.js')),
+    'mad-db': entry('beta', 'Create or inspect one-cycle Mad-DB break-glass capability tokens', 'dist/commands/mad-db.js', directCommand(() => import('../commands/mad-db.js'), 'dist/commands/mad-db.js')),
     'auto-review': entry('beta', 'Manage auto-review profile', 'dist/commands/auto-review.js', directCommand(() => import('../commands/auto-review.js'), 'dist/commands/auto-review.js')),
     autoreview: entry('beta', 'Alias for auto-review', 'dist/commands/auto-review.js', directCommand(() => import('../commands/auto-review.js'), 'dist/commands/auto-review.js')),
     'dollar-commands': entry('stable', 'List Codex App dollar commands', 'dist/core/commands/basic-cli.js', basicArgs('dollarCommandsCommand')),
@@ -118,7 +119,7 @@ export const COMMANDS = {
     commit: entry('stable', 'Create a simple git commit', 'dist/commands/commit.js', directCommand(() => import('../commands/commit.js'), 'dist/commands/commit.js')),
     'commit-and-push': entry('stable', 'Create a simple git commit and push', 'dist/commands/commit-and-push.js', directCommand(() => import('../commands/commit-and-push.js'), 'dist/commands/commit-and-push.js')),
     dfix: entry('stable', 'Run DFix diagnose/plan/patch/verify loop', 'dist/core/commands/dfix-command.js', commandArgsCommand(() => import('../core/commands/dfix-command.js'), 'dfixCommand', 'dist/core/commands/dfix-command.js')),
-    team: entry('beta', 'Create and observe Team missions', 'dist/core/commands/team-command.js', argsCommand(() => import('../core/commands/team-command.js'), 'team', 'dist/core/commands/team-command.js')),
+    team: entry('beta', 'Deprecated Team alias; create redirects to Naruto, observe legacy Team missions', 'dist/core/commands/team-command.js', argsCommand(() => import('../core/commands/team-command.js'), 'team', 'dist/core/commands/team-command.js')),
     agent: entry('beta', 'Run native multi-session agent missions', 'dist/core/commands/agent-command.js', argsCommand(() => import('../core/commands/agent-command.js'), 'agentCommand', 'dist/core/commands/agent-command.js')),
     'with-local-llm': entry('beta', 'Enable or inspect local Ollama worker backend', 'dist/core/commands/local-model-command.js', argsCommand(() => import('../core/commands/local-model-command.js'), 'localModelCommand', 'dist/core/commands/local-model-command.js')),
     naruto: entry('labs', 'Run $Naruto shadow-clone swarm (up to 100 parallel sessions)', 'dist/core/commands/naruto-command.js', argsCommand(() => import('../core/commands/naruto-command.js'), 'narutoCommand', 'dist/core/commands/naruto-command.js')),

package/dist/commands/mad-db.js

@@ -0,0 +1,5 @@
+import { madDbCommand } from '../core/commands/mad-db-command.js';
+export async function run(_command = 'mad-db', args = []) {
+    return madDbCommand(args);
+}
+//# sourceMappingURL=mad-db.js.map

package/dist/commands/zellij-slot-pane.js

@@ -1,6 +1,8 @@
 import { renderZellijSlotPaneFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
 export async function run(_command = 'zellij-slot-pane', args = []) {
     const artifactDir = readOption(args, '--artifact-dir', process.cwd()) || process.cwd();
+    const artifactRoot = readOption(args, '--artifact-root', artifactDir) || artifactDir;
+    const missionId = readOption(args, '--mission', '') || '';
     const slotId = readOption(args, '--slot', 'slot-001') || 'slot-001';
     const generationIndex = Number(readOption(args, '--generation', '1') || 1);
     const backend = readOption(args, '--backend', null);
@@ -9,7 +11,7 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
     const watch = hasFlag(args, '--watch');
     const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000') || 1000));
     for (;;) {
-        const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, slotId, generationIndex, backend, role, mode });
+        const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
         process.stdout.write('\x1Bc' + text + '\n');
         if (!watch)
             break;

package/dist/core/agents/agent-orchestrator.js

@@ -54,7 +54,7 @@ import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } fro
 import { resolveLocalCollaborationPolicy, localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
 import { runFinalGptReviewStage } from '../pipeline/final-gpt-review-stage.js';
 import { selectFinalGptPatchSource } from '../pipeline/final-gpt-patch-stage.js';
-import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { allocateWorkerWorktree, allocateWorkerWorktreesBatch } from '../git/git-worktree-manager.js';
 import { exportGitWorktreeDiff } from '../git/git-worktree-diff.js';
 import { buildGitWorktreePatchEnvelope } from '../git/git-worktree-patch-envelope.js';
 import { checkpointWorkerWorktree } from '../git/git-worktree-checkpoint.js';
@@ -63,6 +63,7 @@ import { createGitIntegrationWorktree } from '../git/git-integration-worktree.js
 import { applyGitWorktreeMergeQueue } from '../git/git-worktree-merge-queue.js';
 import { crossRebaseIdleWorktrees } from '../git/git-worktree-cross-rebase.js';
 import { gitOutputLine, runGitCommand } from '../git/git-worktree-runner.js';
+import { writeParallelRuntimeProof } from './parallel-runtime-proof.js';
 export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const prompt = String(opts.prompt || 'Native agent run');
@@ -289,9 +290,46 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         diffs: [],
         checkpoints: [],
         cleanup: [],
+        prewarmed_allocations: [],
         blockers: []
     };
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-git-worktree-runtime.json'), gitWorktreeRuntime);
+    const preparedWorktreeAllocations = new Map();
+    if (gitWorktreePolicy?.mode === 'git-worktree') {
+        const writeSlices = uniqueWritableSlicesForWorktrees(partition.slices, Math.max(1, targetActiveSlots));
+        if (writeSlices.length) {
+            const prewarmed = await allocateWorkerWorktreesBatch({
+                root: gitWorktreePolicy.main_repo_root || root,
+                missionId,
+                workers: writeSlices.map((slice, index) => ({
+                    workerId: String(slice.owner_agent_id || slice.owner || `worker-${index + 1}`),
+                    slotId: String(slice.owner_agent_id || slice.owner || `slot-${index + 1}`),
+                    generationIndex: 1
+                })),
+                maxParallel: Math.min(targetActiveSlots, Number(process.env.SKS_NARUTO_GIT_WORKTREE_CAP || targetActiveSlots))
+            }).catch((err) => {
+                gitWorktreeRuntime.blockers.push('git_worktree_batch_prewarm_failed:' + (err instanceof Error ? err.message : String(err)));
+                gitWorktreeRuntime.ok = false;
+                return [];
+            });
+            gitWorktreeRuntime.prewarmed_allocations = prewarmed.map((allocation) => ({
+                worker_id: allocation.worker_id,
+                slot_id: allocation.slot_id,
+                ok: allocation.ok,
+                worktree_path: allocation.worktree_path,
+                branch: allocation.branch,
+                blockers: allocation.blockers
+            }));
+            for (const allocation of prewarmed) {
+                if (allocation.ok)
+                    preparedWorktreeAllocations.set(String(allocation.worker_id), allocation);
+                else
+                    gitWorktreeRuntime.blockers.push(...allocation.blockers);
+            }
+            gitWorktreeRuntime.ok = gitWorktreeRuntime.blockers.length === 0;
+            await writeJsonAtomic(path.join(ledgerRoot, 'agent-git-worktree-runtime.json'), gitWorktreeRuntime);
+        }
+    }
     const nativeCliSwarm = createNativeCliSessionSwarmRecorder(ledgerRoot, {
         missionId,
         requestedAgents: Number(opts.agents || roster.agent_count || targetActiveSlots),
@@ -329,7 +367,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
                 agent,
                 slice,
                 policy: gitWorktreePolicy,
-                runtime: gitWorktreeRuntime
+                runtime: gitWorktreeRuntime,
+                preparedAllocation: preparedWorktreeAllocations.get(String(agent.id || '')) || null
             });
             const runtimeAgent = workerWorktree ? { ...agent, worktree: workerWorktree.context } : agent;
             const runtimeSlice = workerWorktree ? { ...slice, worktree: workerWorktree.context } : slice;
@@ -432,6 +471,13 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         }
     });
     await nativeCliSwarm.finalize();
+    const parallelRuntimeProof = await writeParallelRuntimeProof(ledgerRoot, missionId, {
+        requestedWorkers: Number(opts.agents || roster.agent_count || targetActiveSlots),
+        targetActiveSlots,
+        visiblePanes: visualLaneCount,
+        expectedWorkerRuntimeMs: targetActiveSlots >= 10 ? 8000 : targetActiveSlots >= 2 ? 2000 : 25,
+        minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount)
+    });
     const results = scheduler.results;
     const nativeCliSessionProof = await writeNativeCliSessionProof(ledgerRoot, {
         requestedAgents: Number(opts.agents || roster.agent_count || targetActiveSlots),
@@ -600,6 +646,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         gpt_final_arbiter: gptFinalArbiter,
         final_gpt_patch_stage: finalGptPatchStage,
         patch_swarm: patchSwarm,
+        parallel_runtime_proof: parallelRuntimeProof,
         proof
     };
 }
@@ -620,6 +667,22 @@ function withFinalGptPatchEnvelopes(results, patchEnvelopes = []) {
         next[0] = { ...next[0], patch_envelopes: patchEnvelopes };
     return next;
 }
+function uniqueWritableSlicesForWorktrees(slices = [], limit) {
+    const selected = [];
+    const seenOwners = new Set();
+    for (const slice of Array.isArray(slices) ? slices : []) {
+        if (!Array.isArray(slice?.write_paths) || slice.write_paths.length === 0)
+            continue;
+        const owner = String(slice.owner_agent_id || slice.owner || slice.id || '');
+        if (!owner || seenOwners.has(owner))
+            continue;
+        seenOwners.add(owner);
+        selected.push(slice);
+        if (selected.length >= Math.max(1, limit))
+            break;
+    }
+    return selected;
+}
 function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveSlots, parentPrompt = '') {
     const activeRoster = (Array.isArray(roster?.roster) ? roster.roster : []).slice(0, Math.max(1, targetActiveSlots));
     const activeAgentIds = new Set(activeRoster.map((row) => String(row.id || '')).filter(Boolean));
@@ -873,7 +936,7 @@ async function prepareWorkerGitWorktree(input) {
     if (!sliceHasWritePaths && !agentWriteCapable)
         return null;
     const generationIndex = Math.max(1, Math.floor(Number(input.agent.generation_index || 1)));
-    const allocation = await allocateWorkerWorktree({
+    const allocation = input.preparedAllocation || await allocateWorkerWorktree({
         repoRoot: input.policy.main_repo_root || input.root,
         missionId: input.missionId,
         workerId: String(input.agent.id || input.slice.id || 'worker'),

package/dist/core/agents/agent-plan.js

@@ -1,6 +1,7 @@
 import { AGENT_INTAKE_STAGE_ID, DEFAULT_AGENT_COUNT } from './agent-schema.js';
 const AGENT_REQUIRED_ROUTE_KEYS = new Set([
-    'team', '$team', 'research', '$research', 'autoresearch', '$autoresearch', 'qa-loop', '$qa-loop', 'review', '$review', 'release-review', '$release-review'
+    'team', '$team', 'naruto', '$naruto', 'shadowclone', '$shadowclone', 'shadow-clone', '$shadow-clone', 'kagebunshin', '$kagebunshin', 'kage-bunshin', '$kage-bunshin',
+    'research', '$research', 'autoresearch', '$autoresearch', 'qa-loop', '$qa-loop', 'review', '$review', 'release-review', '$release-review'
 ]);
 function routeKey(route) {
     return String(route?.id || route?.command || route?.name || route || '').trim().toLowerCase();
@@ -14,7 +15,7 @@ export function routeRequiresAgentIntake(route, input = {}) {
     if (AGENT_REQUIRED_ROUTE_KEYS.has(key))
         return true;
     const task = String(input.task || '');
-    return /\$(Team|Research|AutoResearch|QA-LOOP|Review|Release-Review)\b/i.test(task);
+    return /\$(Team|Naruto|ShadowClone|Kagebunshin|Research|AutoResearch|QA-LOOP|Review|Release-Review)\b/i.test(task);
 }
 export function normalizeAgentPolicy(route, task = '', input = {}) {
     const required = routeRequiresAgentIntake(route, { task, ...(typeof input === 'object' && input ? input : {}) });