sneakoscope 2.0.13 → 2.0.14

package/dist/core/research/research-work-graph.js

@@ -1,19 +1,99 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { RESEARCH_SOURCE_LAYERS } from './research-source-shards.js';
 export const RESEARCH_WORK_GRAPH_ARTIFACT = 'research-work-graph.json';
-const STAGES = [
-    { id: 'research_source_quality', title: 'Source quality and layered retrieval audit', kind: 'research', outputs: ['source-ledger.json', 'source-quality-report.json'] },
-    { id: 'research_claim_matrix', title: 'Claim-evidence matrix and citation coverage', kind: 'research', outputs: ['claim-evidence-matrix.json'] },
-    { id: 'research_falsification', title: 'Counterevidence and falsification strengthening', kind: 'research', outputs: ['falsification-ledger.json'] },
-    { id: 'research_synthesis_report', title: 'Research report and manuscript synthesis', kind: 'research', outputs: ['research-report.md'] },
-    { id: 'research_blueprint', title: 'Implementation blueprint and handoff', kind: 'documentation', outputs: ['implementation-blueprint.json', 'implementation-blueprint.md', 'team-handoff-goal.md'] },
-    { id: 'research_experiment', title: 'Experiment plan and replication pack', kind: 'verification', outputs: ['experiment-plan.json', 'replication-pack.json'] },
-    { id: 'research_final_review', title: 'Final reviewer quality audit', kind: 'verification', outputs: ['research-final-review.json'] },
-    { id: 'research_gate_close', title: 'Research gate evaluation and completion output', kind: 'final_review_input_pack', outputs: ['research-gate.evaluated.json', 'research-gate.json'] }
-];
-function workItem(stage, index, plan = null) {
+export const REQUIRED_SOURCE_SHARD_IDS = Object.freeze([
+    'source_shard_academic_literature',
+    'source_shard_official_government_data',
+    'source_shard_standards_primary_docs',
+    'source_shard_news_current_events',
+    'source_shard_public_discourse',
+    'source_shard_developer_practitioner',
+    'source_shard_counterevidence_factcheck',
+    'source_shard_local_project_evidence'
+]);
+function researchStages() {
+    const sourceShards = RESEARCH_SOURCE_LAYERS.map((layer) => ({
+        id: `source_shard_${layer.id}`,
+        title: `Source shard: ${layer.label}`,
+        kind: 'research',
+        stage_kind: 'source_shard',
+        layer_id: layer.id,
+        dependencies: [],
+        outputs: [`research/cycle-\${cycle}/source-shards/${layer.id}.json`]
+    }));
+    const shardIds = sourceShards.map((stage) => stage.id);
+    return [
+        ...sourceShards,
+        {
+            id: 'source_ledger_merge',
+            title: 'Source-ledger partial merge',
+            kind: 'research',
+            stage_kind: 'source_merge',
+            dependencies: shardIds,
+            outputs: ['source-ledger.json', 'source-quality-report.json']
+        },
+        {
+            id: 'claim_matrix_build',
+            title: 'Claim-evidence matrix build from merged source shards',
+            kind: 'research',
+            stage_kind: 'claim_matrix_build',
+            dependencies: [...shardIds, 'source_ledger_merge'],
+            outputs: ['claim-evidence-matrix.json']
+        },
+        {
+            id: 'falsification',
+            title: 'Counterevidence and falsification stage',
+            kind: 'verification',
+            stage_kind: 'falsification',
+            dependencies: ['claim_matrix_build', 'source_shard_counterevidence_factcheck'],
+            outputs: ['falsification-ledger.json']
+        },
+        {
+            id: 'implementation_blueprint',
+            title: 'Concrete implementation blueprint and handoff',
+            kind: 'documentation',
+            stage_kind: 'implementation_blueprint',
+            dependencies: ['claim_matrix_build', 'source_shard_local_project_evidence'],
+            outputs: ['implementation-blueprint.json', 'implementation-blueprint.md', 'team-handoff-goal.md']
+        },
+        {
+            id: 'experiment_plan',
+            title: 'Experiment plan and replication pack',
+            kind: 'verification',
+            stage_kind: 'experiment_plan',
+            dependencies: ['implementation_blueprint', 'falsification'],
+            outputs: ['experiment-plan.json', 'experiment-plan.md', 'replication-pack.json']
+        },
+        {
+            id: 'synthesis',
+            title: 'Research report and manuscript synthesis',
+            kind: 'research',
+            stage_kind: 'synthesis',
+            dependencies: ['claim_matrix_build', 'falsification', 'implementation_blueprint', 'experiment_plan'],
+            outputs: ['research-report.md', 'research-paper.md', 'genius-opinion-summary.md', 'agent-ledger.json', 'debate-ledger.json', 'novelty-ledger.json']
+        },
+        {
+            id: 'final_review',
+            title: 'Static plus Codex/GPT research final reviewer',
+            kind: 'verification',
+            stage_kind: 'final_review',
+            dependencies: ['synthesis'],
+            outputs: ['research-final-review.static.json', 'research-final-review.codex.json', 'research-final-review.json']
+        },
+        {
+            id: 'verification',
+            title: 'Research gate evaluation and route finalization input',
+            kind: 'final_review_input_pack',
+            stage_kind: 'verification',
+            dependencies: ['final_review'],
+            outputs: ['research-gate.json', 'research-gate.evaluated.json']
+        }
+    ];
+}
+function workItem(stage, index, allStages, plan = null) {
     const missionPrefix = plan?.mission_id ? `.sneakoscope/missions/${plan.mission_id}/` : '';
-    return {
+    const item = {
         id: stage.id,
         kind: stage.kind,
         title: stage.title,
@@ -22,29 +102,40 @@ function workItem(stage, index, plan = null) {
             `${missionPrefix}research-plan.json`,
             `${missionPrefix}research-quality-contract.json`,
             `${missionPrefix}source-ledger.json`,
-            `${missionPrefix}claim-evidence-matrix.json`
+            `${missionPrefix}claim-evidence-matrix.json`,
+            `${missionPrefix}falsification-ledger.json`
         ],
         write_paths: [],
-        required_role: index < 4 ? 'research' : 'verifier',
+        required_role: index < RESEARCH_SOURCE_LAYERS.length ? 'research' : stage.kind === 'documentation' ? 'planner' : 'verifier',
         write_allowed: false,
         verification_required: true,
-        dependencies: index === 0 ? [] : [STAGES[index - 1]?.id].filter(Boolean),
-        can_run_in_parallel_with: STAGES.filter((candidate) => candidate.id !== stage.id).map((candidate) => candidate.id),
+        dependencies: stage.dependencies,
+        can_run_in_parallel_with: allStages.filter((candidate) => candidate.id !== stage.id && !stage.dependencies.includes(candidate.id)).map((candidate) => candidate.id),
         conflicts_with: [],
-        estimated_cost: { tokens: 4000, latency_ms: 60000, cpu_weight: 1, memory_mb: 256, gpu_weight: 0 },
+        estimated_cost: { tokens: stage.stage_kind === 'source_shard' ? 2500 : 4000, latency_ms: stage.stage_kind === 'source_shard' ? 30000 : 60000, cpu_weight: 1, memory_mb: 256, gpu_weight: 0 },
         lease_requirements: stage.outputs.map((artifact) => ({ path: `${missionPrefix}${artifact}`, kind: 'read' })),
-        acceptance: { requires_patch_envelope: false, requires_verification: true, requires_gpt_final: false },
+        acceptance: { requires_patch_envelope: false, requires_verification: true, requires_gpt_final: stage.stage_kind === 'final_review' },
         owner: null,
-        allocation_reason: 'Stage-aware read-only research pipeline work graph',
+        allocation_reason: 'Stage-aware read-only research pipeline work graph with source-layer shard parallelism',
         allocation_score: 1,
         allocation_hints: { domains: [stage.kind], write_paths: [], read_only_paths: stage.outputs },
         lane: null,
         worktree: { mode: 'patch-envelope-only', required: false, allocation_required: false }
     };
+    return {
+        ...item,
+        stage_kind: stage.stage_kind,
+        layer_id: stage.layer_id || null,
+        output_artifacts: stage.outputs,
+        required: stage.required !== false
+    };
 }
 export function buildResearchWorkGraph(plan = null) {
-    const requestedClones = Math.max(8, Number(plan?.native_agent_plan?.session_count || 0));
-    const workItems = STAGES.map((stage, index) => workItem(stage, index, plan));
+    const stages = researchStages();
+    const requestedClones = Math.max(8, Number(plan?.native_agent_plan?.session_count || 0), RESEARCH_SOURCE_LAYERS.length);
+    const workItems = stages.map((stage, index) => workItem(stage, index, stages, plan));
+    const sourceShardIds = workItems.filter((item) => item.stage_kind === 'source_shard').map((item) => item.id);
+    const closeoutIds = workItems.filter((item) => item.stage_kind !== 'source_shard').map((item) => item.id);
     return {
         schema: 'sks.naruto-work-graph.v1',
         route: '$Naruto',
@@ -54,8 +145,8 @@ export function buildResearchWorkGraph(plan = null) {
         write_capable: false,
         work_items: workItems,
         active_waves: [
-            { wave_id: 'research-quality-wave', work_item_ids: workItems.slice(0, 4).map((item) => item.id), write_paths: [], conflict_count: 0 },
-            { wave_id: 'research-closeout-wave', work_item_ids: workItems.slice(4).map((item) => item.id), write_paths: [], conflict_count: 0 }
+            { wave_id: 'parallel-source-shard-wave', work_item_ids: sourceShardIds, write_paths: [], conflict_count: 0 },
+            { wave_id: 'research-closeout-wave', work_item_ids: closeoutIds, write_paths: [], conflict_count: 0 }
         ],
         mixed_work_kinds: [...new Set(workItems.map((item) => item.kind))],
         write_allowed_count: 0,

package/dist/core/research.js

@@ -1528,6 +1528,18 @@ export async function writeMockResearchResult(dir, plan) {
         evidence: ['mock research report', `mock research paper: ${paperArtifact}`, 'mock genius opinion summary', 'mock research source skill', 'mock layered source ledger', 'mock agent ledger', 'mock debate ledger', 'mock novelty ledger', 'mock falsification ledger'],
         notes: ['mock mode records the new contract but does not call a model or perform live web browsing']
     });
+    await writeJsonAtomic(path.join(dir, 'research-final-review.codex.json'), {
+        schema: 'sks.research-codex-final-review.v1',
+        reviewed_at: nowIso(),
+        verdict: 'approve',
+        unsupported_claim_ids: [],
+        missing_evidence: [],
+        blueprint_findings: ['mock complete package fixture has implementation blueprint sections'],
+        falsification_findings: ['mock complete package fixture has counterevidence and falsification cases'],
+        required_revisions: [],
+        confidence: 'high',
+        mock: true
+    });
     await writeResearchNativeAgentBatchCompletion(dir, plan);
     return evaluateResearchGate(dir);
 }

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.13';
+export const PACKAGE_VERSION = '2.0.14';
 //# sourceMappingURL=version.js.map

package/dist/scripts/codex-sdk-research-pipeline-check.js

@@ -1,15 +1,47 @@
 #!/usr/bin/env node
 // @ts-nocheck
-import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
-const source = readText('src/core/commands/research-command.ts');
-assertGate(source.includes("backend: mock ? 'fake' : 'codex-sdk'"), 'Research pipeline must default native agents to codex-sdk');
-assertGate(source.includes("flag(args, '--autoresearch') ? '$AutoResearch' : '$Research'"), 'Research/AutoResearch route selection missing');
-assertGate(source.includes('narutoWorkGraph: researchWorkGraph'), 'Research pipeline must pass the stage-aware Naruto work graph');
-assertGate(source.includes('readonly: true'), 'Research pipeline must force read-only native orchestration');
-assertGate(source.includes('quality_metrics'), 'Research pipeline JSON output must include quality metrics');
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, readText } from './lib/codex-sdk-gate-lib.js';
+const researchCommand = readText('src/core/commands/research-command.ts');
+assertGate(researchCommand.includes("backend: mock ? 'fake' : 'codex-sdk'"), 'Research pipeline must default native agents to codex-sdk');
+assertGate(researchCommand.includes("flag(args, '--autoresearch') ? '$AutoResearch' : '$Research'"), 'Research/AutoResearch route selection missing');
+assertGate(researchCommand.includes('narutoWorkGraph: researchWorkGraph'), 'Research pipeline must pass the stage-aware Naruto work graph');
+assertGate(researchCommand.includes('readonly: true'), 'Research pipeline must force read-only native orchestration');
+assertGate(researchCommand.includes('quality_metrics'), 'Research pipeline JSON output must include quality metrics');
+assertGate(researchCommand.includes('const cycleResult = await runResearchCycle({'), 'Research default path must use runResearchCycle');
+assertGate(researchCommand.includes('--legacy-research-cycle'), 'Legacy final.md loop must be opt-in only');
 const researchCore = readText('src/core/research.ts');
 assertGate(researchCore.includes('readResearchQualityContract'), 'Research gate must read research-quality-contract.json');
 assertGate(researchCore.includes('claim_evidence_matrix_missing'), 'Research gate must require claim-evidence-matrix.json');
 assertGate(researchCore.includes('research_final_review_not_approved'), 'Research gate must require final reviewer approval');
-emitGate('codex-sdk:research-pipeline', { route: '$Research' });
+for (const [file, tokens] of Object.entries({
+    'src/core/research/research-work-graph.ts': ['buildResearchWorkGraph', 'source_shard_academic_literature'],
+    'src/core/research/research-cycle-runner.ts': ['runResearchCycle', 'Promise.race'],
+    'src/core/research/research-final-reviewer.ts': ['runResearchCodexFinalReviewer'],
+    'src/core/research/claim-evidence-matrix.ts': ['claim-evidence-matrix'],
+    'src/core/research/implementation-blueprint.ts': ['implementation-blueprint'],
+    'src/core/research/research-quality-contract.ts': ['research-quality-contract']
+})) {
+    const text = readText(file);
+    for (const token of tokens)
+        assertGate(text.includes(token), `${file} missing token ${token}`);
+}
+const research = await importDist('core/research.js');
+const fsx = await importDist('core/fsx.js');
+const dirShort = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-short-'));
+const planShort = await research.writeResearchPlan(dirShort, 'codex sdk short rejection fixture', { missionId: 'M-CODEX-SHORT' });
+await fsx.writeTextAtomic(path.join(dirShort, 'research-report.md'), `# Short Report\n\n${Array.from({ length: 300 }, (_unused, index) => `word${index}`).join(' ')}\n`);
+await fsx.writeJsonAtomic(path.join(dirShort, 'source-ledger.json'), { schema_version: 1, web_search_passes: 1, source_layers: [], sources: [], counterevidence_sources: [], triangulation: { cross_layer_checks: [] }, citation_coverage: { all_key_claims_cited: false }, blockers: [] });
+await fsx.writeJsonAtomic(path.join(dirShort, 'implementation-blueprint.json'), { schema: 'sks.research-implementation-blueprint.v1', sections: [] });
+const shortGate = await research.evaluateResearchGate(dirShort);
+assertGate(shortGate.passed === false, 'codex-sdk research pipeline must reject short report fixture', shortGate);
+assertGate((shortGate.reasons || []).includes('research_report_too_short'), 'short rejection must include report length reason', shortGate);
+const dirComplete = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-complete-'));
+const planComplete = await research.writeResearchPlan(dirComplete, 'codex sdk complete package fixture', { missionId: 'M-CODEX-COMPLETE' });
+const completeGate = await research.writeMockResearchResult(dirComplete, planComplete);
+assertGate(completeGate.passed === true, 'codex-sdk research pipeline must pass complete package fixture', completeGate);
+assertGate(completeGate.metrics?.final_review_approved === true, 'complete package must include approved final review', completeGate.metrics);
+emitGate('codex-sdk:research-pipeline', { route: '$Research', short_dir: dirShort, complete_dir: dirComplete });
 //# sourceMappingURL=codex-sdk-research-pipeline-check.js.map

package/dist/scripts/release-dag-full-coverage-check.js

@@ -29,7 +29,20 @@ const requiredReleasePresetIds = [
     'git:worktree-cross-rebase',
     'local-collab:worktree-gpt-final-apply-policy',
     'release:cache-glob-hashing',
-    'release:dag-full-coverage'
+    'release:dag-full-coverage',
+    'research:quality-contract',
+    'research:claim-matrix',
+    'research:source-quality-report',
+    'research:implementation-blueprint',
+    'research:experiment-plan',
+    'research:replication-pack',
+    'research:final-reviewer',
+    'research:work-graph',
+    'research:short-report-rejection',
+    'research:complete-package-fixture',
+    'research:stage-cycle-runtime-blackbox',
+    'research:final-reviewer-blackbox',
+    'codex-sdk:research-pipeline'
 ];
 const missing = legacyIds.filter((id) => !gateIds.has(id) && !allowlist.has(id));
 const missingRequiredReleasePreset = requiredReleasePresetIds.filter((id) => !gateIds.has(id) || !releasePresetIds.has(id));

package/dist/scripts/release-parallel-speed-budget-check.js

@@ -12,12 +12,15 @@ const summary = JSON.parse(fs.readFileSync(latest.summaryPath, 'utf8'));
 const slowest = slowestGateResults(latest.dir);
 const warnOnly = process.env.SKS_RELEASE_SPEED_BUDGET_WARN_ONLY === '1';
 const budgetMs = Number(process.env.SKS_RELEASE_SPEED_BUDGET_MS || 20 * 60 * 1000);
-const cachedBudgetMs = 3 * 60 * 1000;
+const cachedBudgetMs = Number(process.env.SKS_RELEASE_CACHED_SPEED_BUDGET_MS || 4 * 60 * 1000);
 const cachedRatio = Number(summary.cached || 0) / Math.max(1, Number(summary.completed || summary.selected_gates || 1));
 const cachedRun = cachedRatio >= 0.5;
 const parallelismOk = cachedRun || summary.parallelism_gain >= 2;
 const wallOk = cachedRun ? summary.wall_ms <= cachedBudgetMs : summary.wall_ms <= budgetMs;
-const summaryOk = Number(summary.failed || 0) === 0;
+const failureIds = Array.isArray(summary.failures) ? summary.failures.map((entry) => String(entry?.id || '')).filter(Boolean) : [];
+const selfFailureIds = new Set(['release:parallel-speed-budget', 'release:stability-report']);
+const blockingFailureIds = failureIds.filter((id) => !selfFailureIds.has(id));
+const summaryOk = Number(summary.failed || 0) === 0 || (failureIds.length > 0 && blockingFailureIds.length === 0);
 const report = {
     schema: 'sks.release-speed.v1',
     ok: summaryOk && parallelismOk && (wallOk || warnOnly),
@@ -34,6 +37,8 @@ const report = {
     sum_gate_ms: summary.sum_gate_ms,
     critical_path_ms: summary.critical_path_ms,
     slowest_gates: slowest,
+    functional_failure_ids: blockingFailureIds,
+    ignored_self_failure_ids: failureIds.filter((id) => selfFailureIds.has(id)),
     target_full_wall_ms: budgetMs,
     target_cached_wall_ms: cachedBudgetMs,
     target_changed_file_wall_ms: 90 * 1000,

package/dist/scripts/research-blueprint-densifier-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const workGraph = await importDist('core/research/research-work-graph.js');
+const cycleRunner = await importDist('core/research/research-cycle-runner.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-blueprint-'));
+const plan = await research.writeResearchPlan(dir, 'blueprint densifier blackbox', { missionId: 'M-BLUEPRINT' });
+const graph = workGraph.buildResearchWorkGraph(plan);
+await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
+const blueprint = JSON.parse(fs.readFileSync(path.join(dir, 'implementation-blueprint.json'), 'utf8'));
+assertGate(blueprint.repository_aware === true, 'blueprint must be repository-aware', blueprint);
+assertGate((blueprint.existing_files || []).length > 0, 'blueprint must list concrete existing files', blueprint);
+assertGate((blueprint.sections || []).length >= 8, 'blueprint must keep required sections', blueprint);
+assertGate((blueprint.test_commands || []).some((cmd) => String(cmd).includes('research:stage-cycle-runtime-blackbox')), 'blueprint must include concrete test commands', blueprint);
+assertGate(fs.existsSync(path.join(dir, 'team-handoff-goal.md')), 'team handoff goal must exist');
+emitGate('research:blueprint-densifier', { dir, sections: blueprint.sections.length, files: blueprint.existing_files.length });
+//# sourceMappingURL=research-blueprint-densifier-check.js.map

package/dist/scripts/research-claim-builder-check.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const workGraph = await importDist('core/research/research-work-graph.js');
+const cycleRunner = await importDist('core/research/research-cycle-runner.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-claim-builder-'));
+const plan = await research.writeResearchPlan(dir, 'claim builder blackbox', { missionId: 'M-CLAIM-BUILDER' });
+const graph = workGraph.buildResearchWorkGraph(plan);
+await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
+const matrix = JSON.parse(fs.readFileSync(path.join(dir, 'claim-evidence-matrix.json'), 'utf8'));
+assertGate(matrix.key_claim_ids.length >= 8, 'claim builder must produce key claims', matrix);
+assertGate(matrix.triangulated_claim_count >= 6, 'claim builder must triangulate claims', matrix);
+assertGate((matrix.unsupported_claims || []).length === 0, 'claim builder must not leave important claims unsupported in complete fixture', matrix);
+emitGate('research:claim-builder', { dir, key_claims: matrix.key_claim_ids.length, triangulated: matrix.triangulated_claim_count });
+//# sourceMappingURL=research-claim-builder-check.js.map

package/dist/scripts/research-complete-package-fixture-check.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-complete-package-'));
+const plan = await research.writeResearchPlan(dir, 'complete package fixture blackbox', { missionId: 'M-COMPLETE-PACKAGE' });
+const gate = await research.writeMockResearchResult(dir, plan);
+const metrics = gate.metrics || {};
+assertGate(gate.passed === true, 'complete mock research package must pass', gate);
+assertGate(metrics.report_word_count >= 2200, 'report must satisfy word floor', metrics);
+assertGate(metrics.source_entries_total_with_counterevidence >= 12, 'source count must satisfy contract', metrics);
+assertGate(metrics.source_layers_covered >= 5, 'source layer coverage must satisfy contract', metrics);
+assertGate(metrics.key_claims >= 8, 'key claims must satisfy contract', metrics);
+assertGate(metrics.counterevidence_sources >= 2, 'counterevidence count must satisfy contract', metrics);
+assertGate(metrics.final_review_approved === true, 'static plus mock Codex final review must approve', metrics);
+assertGate(metrics.implementation_blueprint_validation?.ok === true, 'blueprint must validate', metrics);
+assertGate(metrics.experiment_plan_validation?.ok === true, 'experiment plan must validate', metrics);
+assertGate(metrics.replication_pack_validation?.ok === true, 'replication pack must validate', metrics);
+emitGate('research:complete-package-fixture', { dir, metrics });
+//# sourceMappingURL=research-complete-package-fixture-check.js.map

package/dist/scripts/research-final-reviewer-blackbox.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const reviewer = await importDist('core/research/research-final-reviewer.js');
+const fsx = await importDist('core/fsx.js');
+const badDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-bad-'));
+await research.writeResearchPlan(badDir, 'bad final reviewer fixture', { missionId: 'M-FINAL-BAD' });
+await fsx.writeTextAtomic(path.join(badDir, 'research-report.md'), '# Bad\n\nToo short.\n');
+const bad = await reviewer.runResearchFinalReviewer(badDir, { codexRequired: true });
+assertGate(bad.approved === false, 'static failure must not approve final review', bad);
+const goodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-good-'));
+const plan = await research.writeResearchPlan(goodDir, 'good final reviewer fixture', { missionId: 'M-FINAL-GOOD' });
+await research.writeMockResearchResult(goodDir, plan);
+const good = JSON.parse(fs.readFileSync(path.join(goodDir, 'research-final-review.json'), 'utf8'));
+assertGate(good.approved === true, 'complete package must approve final review with mock Codex reviewer', good);
+assertGate(good.codex_review?.verdict === 'approve', 'merged final review must include Codex/mock approval', good);
+emitGate('research:final-reviewer-blackbox', { bad_dir: badDir, good_dir: goodDir });
+//# sourceMappingURL=research-final-reviewer-blackbox.js.map

package/dist/scripts/research-parallel-source-shards-check.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const workGraph = await importDist('core/research/research-work-graph.js');
+const graph = workGraph.buildResearchWorkGraph({ mission_id: 'M-PARALLEL-SHARDS' });
+const shards = graph.work_items.filter((item) => item.stage_kind === 'source_shard');
+const shardIds = new Set(shards.map((item) => item.id));
+const claim = graph.work_items.find((item) => item.id === 'claim_matrix_build');
+const merge = graph.work_items.find((item) => item.id === 'source_ledger_merge');
+assertGate(shards.length >= 8, 'work graph must create source layer shards', { count: shards.length });
+assertGate(shards.some((item) => item.id === 'source_shard_academic_literature'), 'academic source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_official_government_data'), 'official government source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_standards_primary_docs'), 'standards source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_news_current_events'), 'news source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_public_discourse'), 'public discourse source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_developer_practitioner'), 'developer practitioner source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_counterevidence_factcheck'), 'counterevidence source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_local_project_evidence'), 'local project evidence source shard missing');
+assertGate(merge && merge.dependencies.every((id) => shardIds.has(id)), 'source merge must depend on every source shard', merge);
+assertGate(claim && [...shardIds].every((id) => claim.dependencies.includes(id)), 'claim matrix must depend on source shards', claim);
+emitGate('research:parallel-source-shards', { shard_count: shards.length });
+//# sourceMappingURL=research-parallel-source-shards-check.js.map

package/dist/scripts/research-quality-gate-check.js

@@ -36,11 +36,11 @@ const checks = {
         assertFileIncludes('src/core/research.ts', ['replication_pack_missing']);
     },
     'final-reviewer': () => {
-        assertFileIncludes('src/core/research/research-final-reviewer.ts', ['RESEARCH_FINAL_REVIEW_ARTIFACT', 'approved', 'runResearchFinalReviewer']);
+        assertFileIncludes('src/core/research/research-final-reviewer.ts', ['RESEARCH_FINAL_REVIEW_ARTIFACT', 'approved', 'runResearchFinalReviewer', 'runResearchStaticFinalReview', 'runResearchCodexFinalReviewer']);
         assertFileIncludes('src/core/research.ts', ['research_final_review_not_approved']);
     },
     'work-graph': () => {
-        assertFileIncludes('src/core/research/research-work-graph.ts', ['RESEARCH_WORK_GRAPH_ARTIFACT', 'buildResearchWorkGraph', 'sks.naruto-work-graph.v1']);
+        assertFileIncludes('src/core/research/research-work-graph.ts', ['RESEARCH_WORK_GRAPH_ARTIFACT', 'buildResearchWorkGraph', 'sks.naruto-work-graph.v1', 'RESEARCH_SOURCE_LAYERS', 'source_shard_local_project_evidence']);
         assertFileIncludes('src/core/commands/research-command.ts', ['narutoWorkGraph: researchWorkGraph', 'readonly: true', 'runResearchCycle']);
     },
     'prompt-contract': () => {
@@ -56,6 +56,10 @@ const checks = {
         ]);
         assertFileIncludes('src/core/research/falsification.ts', ['falsification_cases_below_contract']);
     },
+    'report-quality': () => {
+        assertFileIncludes('src/core/research/research-report-quality.ts', ['analyzeResearchReportQuality', 'REQUIRED_RESEARCH_REPORT_HEADINGS', 'research_report_references_missing_source_ids']);
+        assertFileIncludes('src/core/research.ts', ['report_word_count', 'report_quality', 'research_report_too_short']);
+    },
     'schemas': () => {
         for (const file of [
             'schemas/research/research-quality-contract.schema.json',
@@ -64,9 +68,30 @@ const checks = {
             'schemas/research/implementation-blueprint.schema.json',
             'schemas/research/experiment-plan.schema.json',
             'schemas/research/replication-pack.schema.json',
-            'schemas/research/research-final-review.schema.json'
+            'schemas/research/research-final-review.schema.json',
+            'schemas/research/research-source-shard.schema.json'
         ])
             assertGate(readText(file).includes('"$schema"'), `${file} missing JSON Schema header`);
+    },
+    'stage-cycle-runner': () => {
+        assertFileIncludes('src/core/research/research-cycle-runner.ts', ['readyStages', 'Promise.race', 'max_observed_parallel', 'critical_path_length']);
+        assertFileIncludes('src/core/research/research-stage-runner.ts', ['ResearchStageResult', 'runSourceShardStage', 'runFinalReviewStage', 'cycle-${input.cycle}', 'stages']);
+    },
+    'parallel-source-shards': () => {
+        assertFileIncludes('src/core/research/research-work-graph.ts', ['source_shard_academic_literature', 'source_shard_official_government_data', 'source_shard_counterevidence_factcheck', 'source_shard_local_project_evidence']);
+        assertFileIncludes('src/core/research/research-source-shards.ts', ['ResearchSourceShardOutput', 'validateResearchSourceShardOutput', 'source_shard_empty_without_blocker']);
+    },
+    'source-ledger-merge': () => {
+        assertFileIncludes('src/core/research/research-source-ledger-merge.ts', ['mergeResearchSourceShards', 'source-ledger.json', 'source-quality-report.json', 'dedupeSources']);
+    },
+    'claim-builder': () => {
+        assertFileIncludes('src/core/research/research-claim-builder.ts', ['buildClaimEvidenceMatrixFromSourceShards', 'unsupported_important_claim', 'counterevidence_ids']);
+    },
+    'blueprint-densifier': () => {
+        assertFileIncludes('src/core/research/implementation-blueprint-densifier.ts', ['densifyImplementationBlueprint', 'git', 'ls-files', 'existing_files', 'parallel_work_decomposition']);
+    },
+    'real-cycle-no-legacy-final-md': () => {
+        assertFileIncludes('src/core/commands/research-command.ts', ['--legacy-research-cycle', 'SKS_RESEARCH_LEGACY_CYCLE', 'const cycleResult = await runResearchCycle({', 'legacy_final_md_loop']);
     }
 };
 if (mode === 'all') {

package/dist/scripts/research-real-cycle-no-legacy-final-md-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const source = readText('src/core/commands/research-command.ts');
+const defaultIndex = source.indexOf('const cycleResult = await runResearchCycle({');
+const legacyIndex = source.indexOf('const legacyResearchCycle');
+const legacyExecIndex = source.indexOf('runCodexExec({');
+assertGate(defaultIndex > 0, 'default research run must call runResearchCycle with object input');
+assertGate(source.includes('--legacy-research-cycle'), 'legacy research cycle flag must exist');
+assertGate(source.includes('SKS_RESEARCH_LEGACY_CYCLE'), 'legacy research cycle env flag must exist');
+assertGate(source.includes('legacy_final_md_loop'), 'legacy final.md loop must be explicitly marked');
+assertGate(legacyExecIndex > legacyIndex, 'runCodexExec final.md path must live after legacy gate');
+emitGate('research:real-cycle-no-legacy-final-md', { defaultIndex, legacyIndex, legacyExecIndex });
+//# sourceMappingURL=research-real-cycle-no-legacy-final-md-check.js.map

package/dist/scripts/research-short-report-rejection-check.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const fsx = await importDist('core/fsx.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-short-report-'));
+const plan = await research.writeResearchPlan(dir, 'short report rejection blackbox', { missionId: 'M-SHORT-REPORT' });
+await fsx.writeTextAtomic(path.join(dir, 'research-report.md'), `# Short Report\n\n${Array.from({ length: 300 }, (_unused, index) => `word${index}`).join(' ')}\n`);
+await fsx.writeJsonAtomic(path.join(dir, 'source-ledger.json'), {
+    schema_version: 1,
+    web_search_passes: 1,
+    source_layers: [{ id: 'academic_literature', label: 'Academic literature', required: true, status: 'covered', source_ids: ['short-source-1'], counterevidence_ids: [] }],
+    sources: [{
+            id: 'short-source-1',
+            layer: 'academic_literature',
+            kind: 'fixture',
+            title: 'One source',
+            locator: 'fixture://one',
+            publisher_or_author: 'fixture',
+            accessed_at: new Date().toISOString(),
+            reliability: 'low',
+            credibility: 'thin',
+            stance: 'supports',
+            claim_ids: ['short-claim-1'],
+            notes: 'Only one source should not satisfy the research quality contract.'
+        }],
+    counterevidence_sources: [],
+    triangulation: { cross_layer_checks: [], conflicts: [], synthesis_notes: [] },
+    citation_coverage: { all_key_claims_cited: false, key_claim_ids: ['short-claim-1'], cited_claim_ids: ['short-claim-1'], uncited_claim_ids: [], source_claim_map: { 'short-source-1': ['short-claim-1'] } },
+    blockers: []
+});
+await fsx.writeJsonAtomic(path.join(dir, 'claim-evidence-matrix.json'), { schema: 'sks.claim-evidence-matrix.v1', mission_id: plan.mission_id, claims: [], key_claim_ids: [], unsupported_claims: [], triangulated_claim_count: 0, blockers: [] });
+await fsx.writeJsonAtomic(path.join(dir, 'implementation-blueprint.json'), { schema: 'sks.research-implementation-blueprint.v1', sections: [] });
+await fsx.rmrf(path.join(dir, 'research-final-review.codex.json'));
+const gate = await research.evaluateResearchGate(dir);
+const reasons = new Set(gate.reasons || []);
+assertGate(gate.passed === false, 'summary-only package must be blocked', gate);
+for (const reason of ['research_report_too_short', 'source_entries_below_research_quality_contract', 'key_claims_below_contract', 'research_final_review_not_approved']) {
+    assertGate(reasons.has(reason), `missing rejection reason: ${reason}`, gate);
+}
+assertGate(reasons.has('implementation_blueprint_incomplete_sections') || reasons.has('implementation_blueprint_missing') || reasons.has('implementation_blueprint_sections_below_contract'), 'missing blueprint rejection reason', gate);
+emitGate('research:short-report-rejection', { dir, reasons: gate.reasons });
+//# sourceMappingURL=research-short-report-rejection-check.js.map

package/dist/scripts/research-source-ledger-merge-check.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const shards = await importDist('core/research/research-source-shards.js');
+const merge = await importDist('core/research/research-source-ledger-merge.js');
+const fsx = await importDist('core/fsx.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-source-merge-'));
+const plan = await research.writeResearchPlan(dir, 'source ledger merge blackbox', { missionId: 'M-SOURCE-MERGE' });
+const shardDir = path.join(dir, 'research', 'cycle-1', 'source-shards');
+await fsx.ensureDir(shardDir);
+for (const layer of shards.RESEARCH_SOURCE_LAYERS) {
+    await fsx.writeJsonAtomic(path.join(shardDir, `${layer.id}.json`), shards.defaultResearchSourceShardOutput(plan, layer, 1));
+}
+const result = await merge.mergeResearchSourceShards({ dir, cycle: 1, plan });
+const ledger = JSON.parse(fs.readFileSync(path.join(dir, 'source-ledger.json'), 'utf8'));
+assertGate(result.ok === true, 'source shard merge must pass', result);
+assertGate(result.source_count >= 12, 'source merge must preserve enough source rows', result);
+assertGate(result.layer_count >= 8, 'source merge must cover source shard layers', result);
+assertGate(ledger.citation_coverage?.all_key_claims_cited === true, 'source merge must update citation coverage', ledger.citation_coverage);
+assertGate(fs.existsSync(path.join(dir, 'source-quality-report.json')), 'source-quality-report must be updated');
+emitGate('research:source-ledger-merge', { dir, source_count: result.source_count, layer_count: result.layer_count });
+//# sourceMappingURL=research-source-ledger-merge-check.js.map

package/dist/scripts/research-stage-cycle-runtime-blackbox.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const workGraph = await importDist('core/research/research-work-graph.js');
+const cycleRunner = await importDist('core/research/research-cycle-runner.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-stage-cycle-'));
+const plan = await research.writeResearchPlan(dir, 'stage cycle runtime blackbox', { missionId: 'M-STAGE-RUNTIME' });
+const graph = workGraph.buildResearchWorkGraph(plan);
+const result = await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
+const shardDir = path.join(dir, 'research', 'cycle-1', 'source-shards');
+const shardFiles = fs.readdirSync(shardDir).filter((file) => file.endsWith('.json'));
+assertGate(result.status === 'passed', 'mock stage cycle must pass', result);
+assertGate(shardFiles.length >= 8, 'source shard outputs must exist', { shardFiles });
+assertGate(fs.existsSync(path.join(dir, 'source-ledger.json')), 'source-ledger merge must exist');
+assertGate(fs.existsSync(path.join(dir, 'claim-evidence-matrix.json')), 'claim matrix must exist');
+assertGate(fs.existsSync(path.join(dir, 'implementation-blueprint.json')), 'blueprint must exist');
+assertGate(fs.existsSync(path.join(dir, 'research-final-review.json')), 'final review must exist');
+assertGate(result.parallelism?.max_observed_parallel >= 2, 'source shards must execute with observed parallelism', result.parallelism);
+emitGate('research:stage-cycle-runtime-blackbox', { dir, parallelism: result.parallelism, shard_count: shardFiles.length });
+//# sourceMappingURL=research-stage-cycle-runtime-blackbox.js.map