sneakoscope 2.0.13 → 2.0.15

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

@@ -0,0 +1,124 @@
+import path from 'node:path';
+import { nowIso, runProcess } from '../fsx.js';
+import {} from '../codex-control/codex-control-plane.js';
+import { defaultImplementationBlueprint } from './implementation-blueprint.js';
+export async function densifyImplementationBlueprint(input) {
+    const fileMap = await repositoryFileMap(input.root);
+    const likelyFiles = likelyTargetFiles(fileMap, input.plan, input.claimMatrix);
+    const possibleNewFiles = possibleNewResearchFiles(fileMap);
+    const base = input.existingBlueprint || defaultImplementationBlueprint(input.plan);
+    const claims = Array.isArray(input.claimMatrix?.claims) ? input.claimMatrix.claims : [];
+    const keyClaimIds = Array.isArray(input.claimMatrix?.key_claim_ids) ? input.claimMatrix.key_claim_ids : claims.slice(0, 8).map((claim) => claim.id);
+    const sections = [
+        section('problem', 'Problem', `Research currently must prove it executes stage-aware source shard runtime instead of relying on summary-style final.md output. The handoff should preserve ${keyClaimIds.length} key claim ids and all source-ledger evidence before code work begins.`, keyClaimIds, likelyFiles.slice(0, 8), ['Confirm the follow-up route reads claim-evidence-matrix.json and source-ledger.json before implementation.']),
+        section('decision', 'Decision', 'Use a dependency-aware research cycle with source_shard, source_merge, claim_matrix_build, falsification, implementation_blueprint, experiment_plan, synthesis, final_review, and verification stages. Keep Research read-only against repository source and write only mission artifacts.', keyClaimIds, likelyFiles.slice(0, 8), ['Default research run calls runResearchCycle; legacy final.md loop is opt-in only.']),
+        section('architecture', 'Architecture', 'The runtime is split into source shard generation, source-ledger merge, claim builder, blueprint densifier, final reviewer, blackbox scripts, and CLI status output. Each stage writes a ResearchStageResult under research/cycle-N/stages.', keyClaimIds, likelyFiles, ['Stage result artifacts list concrete output_artifacts for every passed stage.']),
+        section('interfaces', 'API And Schema Changes', `Existing files should expose typed contracts for shard outputs, stage results, merged source ledgers, Codex final review outputs, and concrete blueprint fields. Possible new files: ${possibleNewFiles.join(', ')}.`, keyClaimIds, likelyFiles, ['Schemas exist for research-source-shard and research-final-review.']),
+        section('data_contracts', 'Data Contracts', 'Source rows must preserve id, layer, kind, title, locator, publisher_or_author, accessed_at, reliability, credibility, stance, and claim_ids. Claim rows must preserve source_ids, counterevidence_ids, triangulation layers, confidence, and test_or_probe.', keyClaimIds, ['schemas/research/research-source-shard.schema.json', 'schemas/research/claim-evidence-matrix.schema.json'], ['Source quality report returns ok only when source metadata and citation coverage are complete.']),
+        section('execution_plan', 'Step By Step Implementation', implementationSteps(likelyFiles, possibleNewFiles).join('\n'), keyClaimIds, likelyFiles, ['Run research stage runtime blackbox, short-report rejection, complete-package fixture, and codex-sdk research pipeline gates.']),
+        section('verification_plan', 'Verification Plan', 'Run the release truth, research quality, source shard, source merge, claim builder, blueprint densifier, final reviewer, codex-sdk research pipeline, release DAG, and release check commands listed in the directive.', keyClaimIds, ['package.json', 'release-gates.v2.json', 'src/scripts/release-dag-full-coverage-check.ts'], ['All directive final checklist commands either pass or have a documented blocker.']),
+        section('risks_and_rollbacks', 'Risks And Rollbacks', 'The main risk is accepting deterministic fixture text as public-ready proof. Roll back by disabling new release gates only if the gate itself is wrong, not if implementation is incomplete. Research must block when live Codex/GPT final review is unavailable outside mock fixtures.', keyClaimIds, likelyFiles, ['A rollback keeps source mutation outside Research and restores package version metadata consistently.'])
+    ];
+    return {
+        ...base,
+        schema: 'sks.research-implementation-blueprint.v1',
+        generated_at: nowIso(),
+        prompt: input.plan?.prompt || base.prompt || '',
+        implementation_allowed_in_research: false,
+        handoff_route: '$Naruto',
+        repository_aware: true,
+        existing_files: likelyFiles,
+        possible_new_files: possibleNewFiles,
+        api_schema_changes: [
+            'ResearchStageResult contract for every executed stage.',
+            'ResearchSourceShardOutput contract for source layer partials.',
+            'Codex/GPT final reviewer merged with static review.'
+        ],
+        test_commands: [
+            'npm run research:stage-cycle-runtime-blackbox',
+            'npm run research:short-report-rejection',
+            'npm run research:complete-package-fixture',
+            'npm run codex-sdk:research-pipeline',
+            'npm run release:check'
+        ],
+        rollback_steps: [
+            'Revert only the files listed in the follow-up patch plan.',
+            'Restore package version metadata with npm install --package-lock-only if package-lock drift occurs.',
+            'Run npm run release:version-truth and the research blackbox gates after rollback.'
+        ],
+        parallel_work_decomposition: [
+            'WS-A stage runtime and research run integration.',
+            'WS-B source shards and ledger merge.',
+            'WS-C claim matrix builder.',
+            'WS-D blueprint and handoff densifier.',
+            'WS-E final reviewer.',
+            'WS-F blackbox gates and release DAG.',
+            'WS-G CLI/docs.',
+            'WS-H integration and verification.'
+        ],
+        sections,
+        dependencies: ['claim-evidence-matrix.json', 'source-ledger.json', 'falsification-ledger.json'],
+        out_of_scope: ['Repository source mutation during $Research runs.'],
+        open_questions: []
+    };
+}
+async function repositoryFileMap(root) {
+    const result = await runProcess('git', ['ls-files'], { cwd: root, timeoutMs: 15000, maxOutputBytes: 2 * 1024 * 1024 }).catch(() => ({ code: 1, stdout: '' }));
+    return String(result.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function likelyTargetFiles(files, plan, claimMatrix) {
+    const promptTerms = new Set(String(plan?.prompt || '').toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 3));
+    const guidanceTerms = new Set((Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : []).flatMap((claim) => String(claim?.claim || '').toLowerCase().split(/[^a-z0-9]+/)).filter((term) => term.length > 5));
+    const preferred = [
+        'src/core/research/research-cycle-runner.ts',
+        'src/core/research/research-stage-runner.ts',
+        'src/core/research/research-work-graph.ts',
+        'src/core/commands/research-command.ts',
+        'src/core/research/claim-evidence-matrix.ts',
+        'src/core/research/implementation-blueprint.ts',
+        'src/core/research/research-final-reviewer.ts',
+        'package.json',
+        'release-gates.v2.json',
+        'docs/research-pipeline.md',
+        'docs/research-artifacts.md',
+        'docs/research-implementation-handoff.md'
+    ].filter((file) => files.includes(file));
+    const matched = files.filter((file) => {
+        const lower = file.toLowerCase();
+        return lower.includes('research') || [...promptTerms, ...guidanceTerms].some((term) => lower.includes(term));
+    }).slice(0, 30);
+    return [...new Set([...preferred, ...matched])].slice(0, 40);
+}
+function possibleNewResearchFiles(files) {
+    return [
+        'src/core/research/research-source-shards.ts',
+        'src/core/research/research-source-ledger-merge.ts',
+        'src/core/research/research-claim-builder.ts',
+        'src/core/research/implementation-blueprint-densifier.ts',
+        'src/scripts/research-stage-cycle-runtime-blackbox.ts',
+        'src/scripts/research-short-report-rejection-check.ts',
+        'schemas/research/research-source-shard.schema.json'
+    ].filter((file) => !files.includes(file));
+}
+function section(id, title, detail, claimIds, targetPaths, acceptanceChecks) {
+    return {
+        id,
+        title,
+        order: ['problem', 'decision', 'architecture', 'interfaces', 'data_contracts', 'execution_plan', 'verification_plan', 'risks_and_rollbacks'].indexOf(id) + 1,
+        detail,
+        evidence_claim_ids: claimIds.slice(0, 8),
+        target_paths: targetPaths,
+        acceptance_checks: acceptanceChecks
+    };
+}
+function implementationSteps(existingFiles, newFiles) {
+    return [
+        `1. Update runtime files: ${existingFiles.filter((file) => file.includes('research-cycle-runner') || file.includes('research-stage-runner') || file.includes('research-work-graph')).join(', ')}.`,
+        `2. Add or verify source/claim/blueprint helper files: ${newFiles.filter((file) => file.includes('research')).join(', ')}.`,
+        '3. Wire sks research run so default execution uses runResearchCycle and the final.md Codex exec loop is legacy-only.',
+        '4. Add blackbox scripts that create temporary missions and verify rejection/pass/runtime behavior.',
+        '5. Update package scripts, release-gates.v2.json, docs, changelog, and version metadata.',
+        '6. Run the directive final checklist and record any hard blocker instead of claiming completion.'
+    ];
+}
+//# sourceMappingURL=implementation-blueprint-densifier.js.map

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