sneakoscope 2.0.14 → 2.0.16

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');

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

@@ -13,20 +13,50 @@ const DEFAULT_SECTION_IDS = Object.freeze([
 ]);
 export function defaultImplementationBlueprint(plan = null) {
     const prompt = String(plan?.prompt || 'research mission');
+    const existingFiles = [
+        'src/core/research/research-stage-runner.ts',
+        'src/core/research/research-report-quality.ts',
+        'src/core/research/research-final-reviewer.ts',
+        'package.json',
+        'release-gates.v2.json',
+        'docs/research-pipeline.md'
+    ];
     return {
         schema: 'sks.research-implementation-blueprint.v1',
         generated_at: nowIso(),
         prompt,
         implementation_allowed_in_research: false,
-        handoff_route: '$Team',
+        handoff_route: '$Naruto',
+        repository_aware: true,
+        existing_files: existingFiles,
+        possible_new_files: [
+            'src/core/research/research-synthesis-writer.ts',
+            'src/core/research/research-repetition-detector.ts',
+            'src/scripts/research-handoff-consumability-check.ts'
+        ],
+        test_commands: [
+            'npm run research:implementation-blueprint',
+            'npm run research:blueprint-densifier',
+            'npm run research:handoff-consumability'
+        ],
+        rollback_steps: [
+            'Revert the research blueprint and handoff changes as one bounded patch.',
+            'Rerun the blueprint, handoff, and release DAG checks after rollback.'
+        ],
+        parallel_work_decomposition: [
+            'WS-A synthesis writer and schema wiring.',
+            'WS-B report quality and repetition checks.',
+            'WS-C final reviewer and gate validation.',
+            'WS-D CLI, release, and documentation closure.'
+        ],
         sections: DEFAULT_SECTION_IDS.map((id, index) => ({
             id,
             title: id.split('_').map((part) => part[0]?.toUpperCase() + part.slice(1)).join(' '),
             order: index + 1,
-            detail: `Research handoff detail for ${id} on: ${prompt}`,
-            evidence_claim_ids: [],
-            target_paths: [],
-            acceptance_checks: [`${id} is reviewed against cited research artifacts before implementation.`]
+            detail: sectionDetail(id, prompt, existingFiles),
+            evidence_claim_ids: [`claim-${(index % 8) + 1}`],
+            target_paths: existingFiles.slice(0, 3 + (index % 3)),
+            acceptance_checks: [`${id} is reviewed against cited source ids, claim ids, concrete files, and rollback evidence before implementation.`]
         })),
         dependencies: [],
         out_of_scope: ['Repository source mutation during $Research runs.'],
@@ -43,17 +73,38 @@ export function validateImplementationBlueprint(blueprint = null, contract = nul
             && Array.isArray(section?.acceptance_checks)
             && section.acceptance_checks.length > 0;
     });
+    const existingFiles = normalizeStringList(blueprint?.existing_files);
+    const testCommands = normalizeStringList(blueprint?.test_commands);
+    const rollbackSteps = normalizeStringList(blueprint?.rollback_steps);
+    const parallelWork = normalizeStringList(blueprint?.parallel_work_decomposition);
+    const thinSections = sections
+        .filter((section) => String(section?.detail || '').trim().length < 120)
+        .map((section) => String(section?.id || section?.title || 'unknown'));
+    const executionPlan = sections.find((section) => String(section?.id || '').trim() === 'execution_plan' || /execution|step/i.test(String(section?.title || '')));
+    const executionPlanHasNumberedSteps = /(?:^|\n)\s*(?:\d+\.|[-*]\s+\d+\.)\s+/.test(String(executionPlan?.detail || ''));
     const blockers = [
         ...(blueprint ? [] : ['implementation_blueprint_missing']),
         ...(sections.length < minSections ? ['implementation_blueprint_sections_below_contract'] : []),
-        ...(completeSections.length < minSections ? ['implementation_blueprint_incomplete_sections'] : [])
+        ...(completeSections.length < minSections ? ['implementation_blueprint_incomplete_sections'] : []),
+        ...(blueprint?.repository_aware === true ? [] : ['implementation_blueprint_not_repository_aware']),
+        ...(existingFiles.length >= 3 && existingFiles.some((file) => /^src\/|^package\.json$|^release-gates|^docs\//.test(file)) ? [] : ['implementation_blueprint_file_map_too_thin']),
+        ...(testCommands.length >= 3 ? [] : ['implementation_blueprint_test_plan_too_thin']),
+        ...(rollbackSteps.length >= 2 ? [] : ['implementation_blueprint_rollback_too_thin']),
+        ...(parallelWork.length >= 4 ? [] : ['implementation_blueprint_parallel_work_missing']),
+        ...thinSections.map((id) => `implementation_blueprint_section_too_thin:${id}`),
+        ...(executionPlanHasNumberedSteps ? [] : ['implementation_blueprint_execution_plan_not_numbered'])
     ];
     return {
         ok: blockers.length === 0,
         blockers,
         sections: sections.length,
         complete_sections: completeSections.length,
-        min_sections: minSections
+        min_sections: minSections,
+        existing_files: existingFiles.length,
+        test_commands: testCommands.length,
+        rollback_steps: rollbackSteps.length,
+        parallel_work_items: parallelWork.length,
+        thin_sections: thinSections
     };
 }
 export async function readImplementationBlueprint(dir) {
@@ -63,4 +114,14 @@ export async function writeImplementationBlueprint(dir, blueprint) {
     await writeJsonAtomic(path.join(dir, IMPLEMENTATION_BLUEPRINT_ARTIFACT), blueprint);
     return blueprint;
 }
+function normalizeStringList(value) {
+    return [...new Set((Array.isArray(value) ? value : value == null ? [] : [value]).map((item) => String(item || '').trim()).filter(Boolean))];
+}
+function sectionDetail(id, prompt, files) {
+    const fileList = files.slice(0, 4).join(', ');
+    if (id === 'execution_plan') {
+        return `1. Inspect the cited research artifacts for ${prompt}. 2. Apply the smallest implementation patch across ${fileList}. 3. Run the listed research and release gates. 4. Keep rollback scoped to the files named in this blueprint.`;
+    }
+    return `For ${prompt}, the ${id} section links source-backed claims to concrete repository files such as ${fileList}, names the acceptance evidence expected from tests, and keeps Research itself read-only while preparing a Naruto handoff.`;
+}
 //# sourceMappingURL=implementation-blueprint.js.map

package/dist/core/research/research-final-reviewer.js

@@ -68,6 +68,10 @@ export async function runResearchCodexFinalReviewer(input) {
             missing_evidence: [],
             blueprint_findings: [],
             falsification_findings: [],
+            template_like_prose: true,
+            source_density_ok: false,
+            implementation_concreteness_ok: false,
+            evidence_bound_synthesis_ok: false,
             required_revisions: ['static_review_failed'],
             confidence: 'low',
             skipped: true,
@@ -85,6 +89,10 @@ export async function runResearchCodexFinalReviewer(input) {
             missing_evidence: [],
             blueprint_findings: ['mock final reviewer approves the complete package fixture'],
             falsification_findings: ['mock counterevidence and falsification cases are present'],
+            template_like_prose: false,
+            source_density_ok: true,
+            implementation_concreteness_ok: true,
+            evidence_bound_synthesis_ok: true,
             required_revisions: [],
             confidence: 'high',
             mock: true
@@ -141,6 +149,10 @@ export async function runResearchFinalReviewer(dir, input = {}) {
         ...(Array.isArray(staticReview?.blockers) ? staticReview.blockers : []),
         ...(codexRequired && !codexReview ? ['research_codex_final_review_missing'] : []),
         ...(codexReview && !codexApproved ? ['research_codex_final_review_not_approved'] : []),
+        ...(codexReview?.template_like_prose === true ? ['research_codex_template_like_prose'] : []),
+        ...(codexReview && codexReview.source_density_ok === false ? ['research_codex_source_density_not_ok'] : []),
+        ...(codexReview && codexReview.implementation_concreteness_ok === false ? ['research_codex_implementation_concreteness_not_ok'] : []),
+        ...(codexReview && codexReview.evidence_bound_synthesis_ok === false ? ['research_codex_evidence_bound_synthesis_not_ok'] : []),
         ...(Array.isArray(codexReview?.required_revisions) ? codexReview.required_revisions.map((revision) => `codex_revision:${revision}`) : [])
     ];
     const review = {
@@ -162,6 +174,8 @@ function buildResearchFinalReviewPrompt(plan, staticReview) {
         `Prompt: ${plan?.prompt || ''}`,
         '',
         'Review the mission artifacts read-only. Reject if claims lack evidence, blueprint steps are template-like, falsification is missing, or the package is only a short summary.',
+        'Reject repeated paragraphs, template-like prose, unsupported synthesis, source IDs that do not exist in source-ledger, and implementation blueprints that lack concrete files/tests.',
+        'Set template_like_prose=true for repeated or boilerplate reports. Set source_density_ok=false for sparse source ids. Set implementation_concreteness_ok=false for weak file/test/rollback plans. Set evidence_bound_synthesis_ok=false when recommendations are not tied to evidence.',
         'Return only JSON matching sks.research-codex-final-review.v1 with verdict approve, revise, or reject.',
         '',
         `Static review summary:\n${JSON.stringify(staticReview, null, 2).slice(0, 12000)}`
@@ -177,6 +191,10 @@ function normalizeCodexReview(worker, result) {
             missing_evidence: [],
             blueprint_findings: [],
             falsification_findings: [],
+            template_like_prose: false,
+            source_density_ok: false,
+            implementation_concreteness_ok: false,
+            evidence_bound_synthesis_ok: false,
             required_revisions: Array.isArray(result?.blockers) ? result.blockers : ['codex_final_reviewer_unavailable'],
             confidence: 'low',
             worker_result_path: result?.workerResultPath || null
@@ -190,6 +208,10 @@ function normalizeCodexReview(worker, result) {
         missing_evidence: Array.isArray(worker?.missing_evidence) ? worker.missing_evidence.map(String) : [],
         blueprint_findings: Array.isArray(worker?.blueprint_findings) ? worker.blueprint_findings.map(String) : [],
         falsification_findings: Array.isArray(worker?.falsification_findings) ? worker.falsification_findings.map(String) : [],
+        template_like_prose: worker?.template_like_prose === true,
+        source_density_ok: worker?.source_density_ok === true,
+        implementation_concreteness_ok: worker?.implementation_concreteness_ok === true,
+        evidence_bound_synthesis_ok: worker?.evidence_bound_synthesis_ok === true,
         required_revisions: Array.isArray(worker?.required_revisions) ? worker.required_revisions.map(String) : [],
         confidence: ['low', 'medium', 'high'].includes(worker?.confidence) ? worker.confidence : 'medium',
         worker_result_path: result.workerResultPath
@@ -197,7 +219,7 @@ function normalizeCodexReview(worker, result) {
 }
 export const researchCodexFinalReviewSchema = {
     type: 'object',
-    required: ['schema', 'verdict', 'unsupported_claim_ids', 'missing_evidence', 'blueprint_findings', 'falsification_findings', 'required_revisions', 'confidence'],
+    required: ['schema', 'verdict', 'unsupported_claim_ids', 'missing_evidence', 'blueprint_findings', 'falsification_findings', 'template_like_prose', 'source_density_ok', 'implementation_concreteness_ok', 'evidence_bound_synthesis_ok', 'required_revisions', 'confidence'],
     properties: {
         schema: { const: 'sks.research-codex-final-review.v1' },
         verdict: { enum: ['approve', 'revise', 'reject'] },
@@ -205,6 +227,10 @@ export const researchCodexFinalReviewSchema = {
         missing_evidence: { type: 'array' },
         blueprint_findings: { type: 'array' },
         falsification_findings: { type: 'array' },
+        template_like_prose: { type: 'boolean' },
+        source_density_ok: { type: 'boolean' },
+        implementation_concreteness_ok: { type: 'boolean' },
+        evidence_bound_synthesis_ok: { type: 'boolean' },
         required_revisions: { type: 'array' },
         confidence: { enum: ['low', 'medium', 'high'] }
     }

package/dist/core/research/research-handoff.js

@@ -1,15 +1,23 @@
 import path from 'node:path';
-import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { nowIso, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 export const IMPLEMENTATION_HANDOFF_PATCH_PLAN_ARTIFACT = 'implementation-handoff.patch-plan.json';
 export const TEAM_HANDOFF_GOAL_ARTIFACT = 'team-handoff-goal.md';
 export const DECISION_LOG_ARTIFACT = 'decision-log.md';
 export async function writeResearchHandoffArtifacts(dir, plan = null, blueprint = null) {
+    const claimMatrix = await readJson(path.join(dir, 'claim-evidence-matrix.json'), null);
+    const sourceLedger = await readJson(path.join(dir, 'source-ledger.json'), null);
+    const claims = Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : [];
+    const sourceRows = [
+        ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+    ];
+    const workItems = parallelWorkItems(blueprint);
     const patchPlan = {
         schema: 'sks.research-implementation-handoff-patch-plan.v1',
         generated_at: nowIso(),
         mission_id: plan?.mission_id || null,
         implementation_allowed_in_research: false,
-        intended_route: '$Team',
+        intended_route: '$Naruto',
         prompt: plan?.prompt || '',
         source_artifacts: [
             'research-report.md',
@@ -20,20 +28,55 @@ export async function writeResearchHandoffArtifacts(dir, plan = null, blueprint
             'source-quality-report.json'
         ],
         proposed_changes: [],
+        parallel_work_items: workItems,
         notes: [
             'This is a handoff artifact. Research records implementation guidance but does not mutate repository source.'
         ]
     };
     const goalLines = [
-        '# Research-To-Team Handoff Goal',
+        '# Research-To-Naruto Handoff Goal',
+        '',
+        '## Context',
         '',
         `Mission: ${plan?.mission_id || 'unknown'}`,
         `Prompt: ${plan?.prompt || ''}`,
+        'Route: Use `$Naruto` for implementation, integration, and parallel non-overlapping lanes.',
         '',
         'Use the implementation blueprint, claim-evidence matrix, source-quality report, experiment plan, replication pack, and final reviewer output before changing code.',
         '',
-        'Blueprint sections:',
-        ...(Array.isArray(blueprint?.sections) ? blueprint.sections.map((section) => `- ${section.id}: ${section.title}`) : [])
+        '## Key Claims',
+        '',
+        ...(claims.length ? claims.slice(0, 8).map((claim) => `- ${claim.id}: ${claim.claim} Sources: ${normalizeList(claim.source_ids).join(', ') || 'explicit blocker: source ids missing'}. Counterevidence: ${normalizeList(claim.counterevidence_ids).join(', ') || 'explicit blocker: counterevidence missing'}.`) : ['- explicit blocker: claim-evidence-matrix.json has no claim rows.']),
+        '',
+        '## Evidence Summary',
+        '',
+        `- Source rows: ${sourceRows.length}.`,
+        `- Key claims: ${Array.isArray(claimMatrix?.key_claim_ids) ? claimMatrix.key_claim_ids.length : 0}.`,
+        `- Counterevidence rows: ${Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources.length : 0}.`,
+        '- Read `source-quality-report.json` and `research-final-review.json` before implementation.',
+        '',
+        '## Implementation Blueprint',
+        '',
+        ...(Array.isArray(blueprint?.sections) ? blueprint.sections.map((section) => `- ${section.id}: ${section.title}. Files: ${normalizeList(section.target_paths).join(', ') || 'explicit blocker: no target paths'}. Checks: ${normalizeList(section.acceptance_checks).join(' | ') || 'explicit blocker: no acceptance checks'}.`) : ['- explicit blocker: implementation-blueprint.json missing sections.']),
+        '',
+        '## Parallel Work Items',
+        '',
+        ...workItems.map((item, index) => `${index + 1}. ${item.title}. Files: ${item.files.length ? item.files.join(', ') : 'explicit blocker: file list missing'}. Tests: ${item.tests.length ? item.tests.join(', ') : 'explicit blocker: tests missing'}. Acceptance: ${item.acceptance}.`),
+        '',
+        '## Acceptance Tests',
+        '',
+        ...normalizeList(blueprint?.test_commands).map((command) => `- ${command}`),
+        ...(normalizeList(blueprint?.test_commands).length ? [] : ['- explicit blocker: no test commands in implementation blueprint.']),
+        '',
+        '## Rollback Plan',
+        '',
+        ...normalizeList(blueprint?.rollback_steps).map((step) => `- ${step}`),
+        ...(normalizeList(blueprint?.rollback_steps).length ? [] : ['- explicit blocker: no rollback steps in implementation blueprint.']),
+        '',
+        '## Source Appendix',
+        '',
+        ...sourceRows.slice(0, 20).map((source) => `- ${source.id}: ${source.title || source.locator || 'source row'}; claims=${normalizeList(source.claim_ids).join(', ') || 'none'}.`),
+        ...(sourceRows.length ? [] : ['- explicit blocker: source-ledger.json has no source rows.'])
     ];
     const decisionLog = [
         '# Research Decision Log',
@@ -48,4 +91,25 @@ export async function writeResearchHandoffArtifacts(dir, plan = null, blueprint
     await writeTextAtomic(path.join(dir, DECISION_LOG_ARTIFACT), `${decisionLog.join('\n')}\n`);
     return { patch_plan: patchPlan, goal_artifact: TEAM_HANDOFF_GOAL_ARTIFACT, decision_log: DECISION_LOG_ARTIFACT };
 }
+function parallelWorkItems(blueprint) {
+    const sections = Array.isArray(blueprint?.sections) ? blueprint.sections : [];
+    const fallbackFiles = normalizeList(blueprint?.existing_files).slice(0, 8);
+    const tests = normalizeList(blueprint?.test_commands);
+    const rows = normalizeList(blueprint?.parallel_work_decomposition);
+    const source = rows.length >= 4 ? rows : ['Synthesis writer lane', 'Report quality lane', 'Final reviewer lane', 'Release and docs lane'];
+    return source.slice(0, Math.max(4, source.length)).map((title, index) => {
+        const section = sections[index % Math.max(1, sections.length)] || {};
+        const files = normalizeList(section.target_paths).length ? normalizeList(section.target_paths) : fallbackFiles.slice(index, index + 3);
+        return {
+            id: `handoff-work-${index + 1}`,
+            title,
+            files,
+            tests: tests.slice(0, 3),
+            acceptance: normalizeList(section.acceptance_checks).join(' | ') || 'Complete the lane and rerun the relevant research gate.'
+        };
+    });
+}
+function normalizeList(value) {
+    return [...new Set((Array.isArray(value) ? value : value == null ? [] : [value]).map((item) => String(item || '').trim()).filter(Boolean))];
+}
 //# sourceMappingURL=research-handoff.js.map