sneakoscope 2.0.13 → 2.0.15

package/dist/core/research/research-synthesis-writer.js

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import { readJson, writeJsonAtomic, writeTextAtomic, nowIso } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-task-runner.js';
+import { researchPaperArtifactForPlan } from '../research.js';
+import { analyzeResearchReportQuality, countWords } from './research-report-quality.js';
+import { analyzeResearchRepetition } from './research-repetition-detector.js';
+import { buildRealisticResearchPaper, buildRealisticResearchReport } from './research-realistic-report.js';
+import { buildResearchSynthesisPrompt } from './research-synthesis-prompt.js';
+export const researchSynthesisOutputSchema = {
+    type: 'object',
+    required: ['schema', 'mission_id', 'generated_at', 'report_markdown', 'paper_markdown', 'synthesis_summary', 'quality_signals', 'blockers'],
+    properties: {
+        schema: { const: 'sks.research-synthesis-output.v1' },
+        mission_id: { type: 'string' },
+        generated_at: { type: 'string' },
+        report_markdown: { type: 'string' },
+        paper_markdown: { type: 'string' },
+        synthesis_summary: {
+            type: 'object',
+            required: ['key_claim_ids', 'source_ids_used', 'counterevidence_ids_used', 'blueprint_sections_used', 'experiment_steps_used'],
+            properties: {
+                key_claim_ids: { type: 'array', items: { type: 'string' } },
+                source_ids_used: { type: 'array', items: { type: 'string' } },
+                counterevidence_ids_used: { type: 'array', items: { type: 'string' } },
+                blueprint_sections_used: { type: 'array', items: { type: 'string' } },
+                experiment_steps_used: { type: 'array', items: { type: 'string' } }
+            }
+        },
+        quality_signals: {
+            type: 'object',
+            required: ['report_word_count', 'source_citation_count', 'unique_source_ids_cited', 'key_claims_covered', 'repeated_paragraph_ratio', 'template_phrase_hits'],
+            properties: {
+                report_word_count: { type: 'number' },
+                source_citation_count: { type: 'number' },
+                unique_source_ids_cited: { type: 'number' },
+                key_claims_covered: { type: 'number' },
+                repeated_paragraph_ratio: { type: 'number' },
+                template_phrase_hits: { type: 'array', items: { type: 'string' } }
+            }
+        },
+        blockers: { type: 'array', items: { type: 'string' } }
+    }
+};
+export async function runResearchCodexSynthesisWriter(input) {
+    const artifacts = await readSynthesisInputs(input.dir);
+    if (input.mock === true || input.plan?.backend === 'mock' || input.plan?.backend === 'deterministic') {
+        const output = normalizeResearchSynthesisOutput(mockResearchSynthesisOutput(input.plan, artifacts));
+        const validation = validateResearchSynthesisOutput(output, artifacts.contract, artifacts.claimMatrix, artifacts.sourceLedger);
+        const merged = { ...output, blockers: [...new Set([...output.blockers, ...validation.blockers])] };
+        await writeSynthesisArtifacts(input.dir, input.plan, merged);
+        return merged;
+    }
+    const result = await runCodexTask({
+        route: '$Research',
+        tier: 'worker',
+        missionId: String(input.plan?.mission_id || 'research-synthesis'),
+        workItemId: 'research_synthesis',
+        cwd: input.root,
+        prompt: buildResearchSynthesisPrompt({ ...artifacts, plan: input.plan, cycle: input.cycle }),
+        outputSchema: researchSynthesisOutputSchema,
+        outputSchemaId: 'sks.research-synthesis-output.v1',
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: {
+            id: 'research-synthesis',
+            route: '$Research',
+            read_only: true,
+            allowed_paths: [`.sneakoscope/missions/${input.plan?.mission_id || ''}/`],
+            write_paths: [],
+            allowed_write_prefixes: [`.sneakoscope/missions/${input.plan?.mission_id || ''}/`],
+            source_mutation_allowed: false
+        },
+        backendPreference: input.backendPreference || ['codex-sdk', 'python-codex-sdk'],
+        allowLocalLlm: false,
+        localLlmPolicy: { mode: 'disabled', requiresGptFinal: true },
+        mutationLedgerRoot: path.join(input.dir, 'research', 'synthesis-codex-control'),
+        reliabilityPolicy: { timeoutClass: 'standard', idleTimeoutMs: input.timeoutMs || 120000 }
+    });
+    const worker = await readJson(result.workerResultPath, null);
+    const output = normalizeResearchSynthesisOutput(worker);
+    const validation = validateResearchSynthesisOutput(output, artifacts.contract, artifacts.claimMatrix, artifacts.sourceLedger);
+    const patchEnvelopeBlocker = Array.isArray(worker?.patch_envelopes) && worker.patch_envelopes.length ? ['research_synthesis_patch_envelope_forbidden'] : [];
+    const blockers = [...new Set([
+            ...output.blockers,
+            ...(Array.isArray(result.blockers) ? result.blockers.map(String) : []),
+            ...validation.blockers,
+            ...patchEnvelopeBlocker
+        ])];
+    const merged = { ...output, blockers };
+    await writeSynthesisArtifacts(input.dir, input.plan, merged);
+    return merged;
+}
+export function normalizeResearchSynthesisOutput(value) {
+    const reportMarkdown = String(value?.report_markdown || '');
+    const paperMarkdown = String(value?.paper_markdown || '');
+    const repetition = analyzeResearchRepetition(reportMarkdown);
+    const sourceIdsUsed = normalizeStringList(value?.synthesis_summary?.source_ids_used || value?.source_ids_used);
+    const keyClaimIds = normalizeStringList(value?.synthesis_summary?.key_claim_ids || value?.key_claim_ids);
+    return {
+        schema: 'sks.research-synthesis-output.v1',
+        mission_id: String(value?.mission_id || ''),
+        generated_at: String(value?.generated_at || nowIso()),
+        report_markdown: reportMarkdown,
+        paper_markdown: paperMarkdown,
+        synthesis_summary: {
+            key_claim_ids: keyClaimIds,
+            source_ids_used: sourceIdsUsed,
+            counterevidence_ids_used: normalizeStringList(value?.synthesis_summary?.counterevidence_ids_used || value?.counterevidence_ids_used),
+            blueprint_sections_used: normalizeStringList(value?.synthesis_summary?.blueprint_sections_used || value?.blueprint_sections_used),
+            experiment_steps_used: normalizeStringList(value?.synthesis_summary?.experiment_steps_used || value?.experiment_steps_used)
+        },
+        quality_signals: {
+            report_word_count: Number(value?.quality_signals?.report_word_count || countWords(reportMarkdown)),
+            source_citation_count: Number(value?.quality_signals?.source_citation_count || sourceCitationCount(reportMarkdown)),
+            unique_source_ids_cited: Number(value?.quality_signals?.unique_source_ids_cited || sourceIdsUsed.filter((id) => reportMarkdown.includes(id)).length),
+            key_claims_covered: Number(value?.quality_signals?.key_claims_covered || keyClaimIds.filter((id) => reportMarkdown.includes(id)).length),
+            repeated_paragraph_ratio: Number(value?.quality_signals?.repeated_paragraph_ratio ?? repetition.repeated_paragraph_ratio),
+            template_phrase_hits: normalizeStringList(value?.quality_signals?.template_phrase_hits || repetition.template_phrase_hits)
+        },
+        blockers: normalizeStringList(value?.blockers)
+    };
+}
+export function validateResearchSynthesisOutput(output, contract = null, claimMatrix = null, sourceLedger = null) {
+    const reportQuality = analyzeResearchReportQuality(output.report_markdown);
+    const repetition = analyzeResearchRepetition(output.report_markdown);
+    const sourceIds = sourceIdsFromLedger(sourceLedger);
+    const keyClaims = Array.isArray(claimMatrix?.key_claim_ids) ? claimMatrix.key_claim_ids.map(String) : [];
+    const report = output.report_markdown;
+    const paper = output.paper_markdown;
+    const sourceIdsCited = sourceIds.filter((id) => report.includes(id));
+    const keyClaimsCovered = keyClaims.filter((id) => report.includes(id) || claimSourceIds(claimMatrix, id).some((sourceId) => report.includes(sourceId)));
+    const paperSections = ['Abstract', 'Introduction', 'Methodology', 'Findings', 'Discussion', 'Limitations', 'Conclusion', 'References'];
+    const blockers = [
+        ...(output.schema === 'sks.research-synthesis-output.v1' ? [] : ['research_synthesis_schema_invalid']),
+        ...(output.mission_id ? [] : ['research_synthesis_mission_missing']),
+        ...(output.report_markdown.trim() ? [] : ['research_synthesis_report_missing']),
+        ...(output.paper_markdown.trim() ? [] : ['research_synthesis_paper_missing']),
+        ...(countWords(report) >= Number(contract?.min_report_words || 2200) ? [] : ['research_synthesis_report_too_short']),
+        ...reportQuality.blockers,
+        ...repetition.blockers,
+        ...(sourceIdsCited.length >= Math.min(8, sourceIds.length) ? [] : ['research_synthesis_unique_sources_below_contract']),
+        ...(keyClaimsCovered.length >= Number(contract?.min_key_claims || 8) ? [] : ['research_synthesis_key_claims_below_contract']),
+        ...(repetition.repeated_paragraph_ratio <= 0.18 ? [] : ['research_synthesis_repeated_paragraph_ratio_high']),
+        ...(repetition.template_phrase_hits.length ? ['research_synthesis_template_phrase_hits'] : []),
+        ...(paperSections.every((heading) => paper.toLowerCase().includes(heading.toLowerCase())) ? [] : ['research_synthesis_paper_sections_missing']),
+        ...output.blockers
+    ];
+    return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
+}
+async function readSynthesisInputs(dir) {
+    return {
+        sourceLedger: await readJson(path.join(dir, 'source-ledger.json'), null),
+        claimMatrix: await readJson(path.join(dir, 'claim-evidence-matrix.json'), null),
+        falsificationLedger: await readJson(path.join(dir, 'falsification-ledger.json'), null),
+        implementationBlueprint: await readJson(path.join(dir, 'implementation-blueprint.json'), null),
+        experimentPlan: await readJson(path.join(dir, 'experiment-plan.json'), null),
+        replicationPack: await readJson(path.join(dir, 'replication-pack.json'), null),
+        contract: await readJson(path.join(dir, 'research-quality-contract.json'), null)
+    };
+}
+function mockResearchSynthesisOutput(plan, artifacts) {
+    const claims = Array.isArray(artifacts.claimMatrix?.claims) ? artifacts.claimMatrix.claims : [];
+    const sourceIds = sourceIdsFromLedger(artifacts.sourceLedger);
+    const counterIds = counterevidenceIdsFromLedger(artifacts.sourceLedger);
+    const report = buildRealisticResearchReport({ plan, claims, sourceIds, counterevidenceIds: counterIds, blueprint: artifacts.implementationBlueprint, falsificationLedger: artifacts.falsificationLedger, experimentPlan: artifacts.experimentPlan, replicationPack: artifacts.replicationPack });
+    const paper = buildRealisticResearchPaper({ plan, claims, sourceIds, counterevidenceIds: counterIds });
+    return normalizeResearchSynthesisOutput({
+        schema: 'sks.research-synthesis-output.v1',
+        mission_id: String(plan?.mission_id || ''),
+        generated_at: nowIso(),
+        report_markdown: report,
+        paper_markdown: paper,
+        synthesis_summary: {
+            key_claim_ids: (Array.isArray(artifacts.claimMatrix?.key_claim_ids) ? artifacts.claimMatrix.key_claim_ids : claims.slice(0, 8).map((claim) => claim.id)).map(String),
+            source_ids_used: sourceIds,
+            counterevidence_ids_used: counterIds,
+            blueprint_sections_used: (Array.isArray(artifacts.implementationBlueprint?.sections) ? artifacts.implementationBlueprint.sections : []).map((section) => String(section.id || section.title || '')).filter(Boolean),
+            experiment_steps_used: (Array.isArray(artifacts.experimentPlan?.steps) ? artifacts.experimentPlan.steps : []).map((step) => String(step.id || '')).filter(Boolean)
+        },
+        blockers: []
+    });
+}
+async function writeSynthesisArtifacts(dir, plan, output) {
+    await writeJsonAtomic(path.join(dir, 'research-synthesis-output.json'), output);
+    if (output.report_markdown.trim())
+        await writeTextAtomic(path.join(dir, 'research-report.md'), `${output.report_markdown.trim()}\n`);
+    if (output.paper_markdown.trim())
+        await writeTextAtomic(path.join(dir, researchPaperArtifactForPlan(plan)), `${output.paper_markdown.trim()}\n`);
+}
+function sourceIdsFromLedger(sourceLedger) {
+    return normalizeStringList([
+        ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+    ].map((row) => row?.id));
+}
+function counterevidenceIdsFromLedger(sourceLedger) {
+    return normalizeStringList((Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : []).map((row) => row?.id));
+}
+function claimSourceIds(claimMatrix, claimId) {
+    const claim = (Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : []).find((row) => String(row?.id || '') === claimId);
+    return normalizeStringList([...(Array.isArray(claim?.source_ids) ? claim.source_ids : []), ...(Array.isArray(claim?.counterevidence_ids) ? claim.counterevidence_ids : [])]);
+}
+function sourceCitationCount(text) {
+    return [...String(text || '').matchAll(/\b(?:source|src|mock-source|shard-[A-Za-z0-9_-]+|counter|mock-counter)-[A-Za-z0-9_.:-]+\b/g)].length;
+}
+function normalizeStringList(value) {
+    return [...new Set((Array.isArray(value) ? value : value == null ? [] : [value]).flat().map((item) => String(item || '').trim()).filter(Boolean))];
+}
+//# sourceMappingURL=research-synthesis-writer.js.map

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

@@ -16,6 +16,7 @@ import { validateFalsificationCoverage } from './research/falsification.js';
 import { writeResearchHandoffArtifacts } from './research/research-handoff.js';
 import { RESEARCH_WORK_GRAPH_ARTIFACT, writeResearchWorkGraph } from './research/research-work-graph.js';
 import { researchPromptContractText, validateResearchPromptContract } from './research/research-prompt-contract.js';
+import { buildRealisticResearchPaper, buildRealisticResearchReport } from './research/research-realistic-report.js';
 export const RESEARCH_PAPER_ARTIFACT = 'research-paper.md';
 export const RESEARCH_SOURCE_SKILL_ARTIFACT = 'research-source-skill.md';
 export const RESEARCH_GENIUS_SUMMARY_ARTIFACT = 'genius-opinion-summary.md';
@@ -904,6 +905,7 @@ export async function evaluateResearchGate(dir) {
     const reportPresent = await exists(path.join(dir, 'research-report.md'));
     const reportText = reportPresent ? await readText(path.join(dir, 'research-report.md'), '') : '';
     const reportQuality = analyzeResearchReportQuality(reportText);
+    const synthesisOutput = await readJson(path.join(dir, 'research-synthesis-output.json'), null);
     const reportWordCount = countWords(reportText);
     const paperArtifact = await findResearchPaperArtifact(dir, plan);
     const paperPresent = paperArtifact.exists;
@@ -1095,6 +1097,18 @@ export async function evaluateResearchGate(dir) {
             report_word_count: reportWordCount,
             report_min_words: contract.min_report_words,
             report_quality: reportQuality,
+            report_repetition: reportQuality.repetition,
+            source_density_per_1000_words: reportQuality.source_density_per_1000_words,
+            claim_density_per_1000_words: reportQuality.claim_density_per_1000_words,
+            template_phrase_hits: reportQuality.repetition?.template_phrase_hits || [],
+            synthesis: {
+                writer: synthesisOutput ? (sourceLedger?.mode === 'selftest_mock' ? 'mock' : 'codex-sdk evidence-bound writer') : 'missing',
+                repetition_ratio: reportQuality.repetition?.repeated_paragraph_ratio ?? null,
+                source_density_per_1000_words: reportQuality.source_density_per_1000_words,
+                claim_density_per_1000_words: reportQuality.claim_density_per_1000_words,
+                template_phrase_hits: reportQuality.repetition?.template_phrase_hits || [],
+                codex_final_review_verdict: finalReview?.codex_review?.verdict || null
+            },
             web_search_passes: webSearchPasses,
             paper_sections: Math.max(Number(gate.paper_sections || 0), paperSections),
             genius_opinion_summary_present: geniusSummaryPresent || gate.genius_opinion_summary_present === true,
@@ -1441,56 +1455,50 @@ export async function writeMockResearchResult(dir, plan) {
     await writeJsonAtomic(path.join(dir, 'falsification-ledger.json'), falsificationLedger);
     await writeJsonAtomic(path.join(dir, 'novelty-ledger.json'), ledger);
     await writeTextAtomic(path.join(dir, RESEARCH_GENIUS_SUMMARY_ARTIFACT), `${geniusSummary}\n`);
-    const evidenceParagraphs = Array.from({ length: 72 }, (_unused, index) => {
-        const claimId = mockClaimIds[index % mockClaimIds.length];
-        const sourceA = `mock-source-${(index % RESEARCH_SOURCE_LAYERS.length) + 1}`;
-        const sourceB = `mock-source-${(index % RESEARCH_SOURCE_LAYERS.length) + 8}`;
-        const counter = index % 2 === 0 ? 'mock-counter-1' : 'mock-counter-2';
-        return `Quality note ${index + 1}: claim ${claimId} is treated as a falsifiable research-pipeline assertion, not a fact about live web evidence. The mock run cites ${sourceA} and ${sourceB}, compares the claim with ${counter}, and preserves the implementation handoff as read-only evidence. This repeated fixture text deliberately keeps the selftest report above the quality-contract word floor while still naming the same source-ledger ids that the gate verifies.`;
+    const mockSourceIds = [...mockLayerSources.map((source) => source.id), 'mock-counter-1', 'mock-counter-2'];
+    const mockCounterIds = ['mock-counter-1', 'mock-counter-2'];
+    const researchReportText = buildRealisticResearchReport({
+        plan,
+        claims: claimMatrix.claims,
+        sourceIds: mockSourceIds,
+        counterevidenceIds: mockCounterIds,
+        blueprint,
+        falsificationLedger,
+        experimentPlan,
+        replicationPack
+    });
+    const researchPaperText = buildRealisticResearchPaper({
+        plan,
+        claims: claimMatrix.claims,
+        sourceIds: mockSourceIds,
+        counterevidenceIds: mockCounterIds
+    });
+    const reportQuality = analyzeResearchReportQuality(researchReportText);
+    await writeJsonAtomic(path.join(dir, 'research-synthesis-output.json'), {
+        schema: 'sks.research-synthesis-output.v1',
+        mission_id: plan?.mission_id || '',
+        generated_at: nowIso(),
+        report_markdown: researchReportText,
+        paper_markdown: researchPaperText,
+        synthesis_summary: {
+            key_claim_ids: claimMatrix.key_claim_ids,
+            source_ids_used: mockSourceIds,
+            counterevidence_ids_used: mockCounterIds,
+            blueprint_sections_used: blueprint.sections.map((section) => section.id),
+            experiment_steps_used: experimentPlan.steps.map((step) => step.id)
+        },
+        quality_signals: {
+            report_word_count: reportQuality.word_count,
+            source_citation_count: reportQuality.source_id_mentions.length,
+            unique_source_ids_cited: mockSourceIds.filter((id) => researchReportText.includes(id)).length,
+            key_claims_covered: claimMatrix.key_claim_ids.filter((id) => researchReportText.includes(id)).length,
+            repeated_paragraph_ratio: reportQuality.repetition.repeated_paragraph_ratio,
+            template_phrase_hits: reportQuality.repetition.template_phrase_hits
+        },
+        blockers: reportQuality.blockers
     });
-    const researchReportText = [
-        '# SKS Research Report',
-        '',
-        `Prompt: ${plan.prompt}`,
-        '',
-        '## Question',
-        'Can SKS Research Mode close a research mission only when it has enough sourced claims, counterevidence, falsification, implementation handoff material, and replication evidence to support a downstream execution route?',
-        '',
-        '## Methodology',
-        'This mock run is a selftest fixture, so it does not claim live web retrieval. It exercises the same artifact contract that real research must satisfy: layered source ledger entries, source quality fields, claim-evidence matrix rows, falsification cases, a blueprint, an experiment plan, a replication pack, and a final reviewer decision.',
-        '',
-        '## Source Map',
-        'The source ledger contains two mock sources per source layer plus two counterevidence records. The source ids include mock-source-1 through mock-source-14, and the counterevidence ids include mock-counter-1 and mock-counter-2. Each source row includes layer, kind, locator, publisher_or_author, accessed_at, reliability, credibility, stance, and claim_ids.',
-        '',
-        '## Key Claims',
-        ...ledger.entries.map((entry) => `- ${entry.id}: ${entry.claim} Sources: ${(entry.source_ids || []).join(', ')}. Counterevidence: ${(entry.counterevidence_ids || entry.falsifiers || []).join(', ')}.`),
-        '',
-        '## Evidence Matrix Summary',
-        `The claim-evidence matrix records ${claimMatrix.key_claim_ids.length} key claims and ${claimMatrix.triangulated_claim_count} triangulated claims. Each critical or high-importance claim has at least one source id and one counterevidence id, and each hypothesis has a test_or_probe field for follow-up validation.`,
-        '',
-        '## Counterevidence',
-        'The first counterexample, mock-counter-1, attacks overclaiming without decisive tests. The second counterexample, mock-counter-2, attacks missing replication and thin experiment plans. Both are intentionally simple but give the gate two independent counterevidence entries to verify.',
-        '',
-        '## Falsification',
-        'The falsification ledger includes four cases. They attack summary-only output, missing independent confirmation, absent counterevidence, and absent replication. The cases survive only as gate-backed requirements, not as proof that the mock topic was researched on the live web.',
-        '',
-        '## Implementation Blueprint',
-        'The implementation blueprint has eight sections: problem, decision, architecture, interfaces, data contracts, execution plan, verification plan, and risks and rollbacks. The key point is that Research does not change repository source. It creates a handoff for a later $Team route that can validate the research and then decide what to implement.',
-        '',
-        '## Experiment / Validation Plan',
-        'The experiment plan contains five steps: compare a baseline and research output, score cited key claims, run the smallest implementation probe, compare falsification outcomes, and record replication commands. The replication pack lists the commands and expected artifacts needed to reproduce the gate.',
-        '',
-        '## Limitations',
-        'This is mock evidence for harness verification. It proves the local artifact contract and gate behavior, not live research accuracy. A normal non-mock run must still collect real sources and must keep the gate blocked if source access is unavailable.',
-        '',
-        '## References',
-        '- mock-source-1 through mock-source-14: layered mock sources generated by writeMockResearchResult.',
-        '- mock-counter-1 and mock-counter-2: counterevidence fixtures generated by writeMockResearchResult.',
-        '',
-        ...evidenceParagraphs
-    ].join('\n\n');
     await writeTextAtomic(path.join(dir, 'research-report.md'), `${researchReportText}\n`);
-    await writeTextAtomic(path.join(dir, paperArtifact), `# Research Paper: ${plan.prompt}\n\n## Abstract\nA source-cited research run should produce cross-layer, falsifiable novelty rather than only summarize known material.\n\n## Introduction\nThe mock topic is evaluated as a research workflow outcome with layered source coverage [mock-source-1].\n\n## Methodology\nFive xhigh agents produce Eureka ideas, debate, triangulate source layers, and falsify the strongest claim.\n\n## Findings\nThe surviving finding is that useful research needs cited novelty, source-layer coverage, cross-layer triangulation, and a cheap decisive probe.\n\n## Discussion\nThe debate favors gate-backed evidence over narrative confidence, and treats public discourse as signal rather than truth.\n\n## Limitations and Falsification\nThe claim fails without sources, counterevidence, triangulation checks, or testable predictions [mock-counter-1].\n\n## Conclusion and Next Experiment\nCompare this loop against a summary-only baseline and score testable insights.\n\n## References\n- [mock-source-1] Mock academic literature coverage.\n- [mock-source-2] Mock official government and leading-institution knowledge coverage.\n- [mock-source-3] Mock standards and primary documents coverage.\n- [mock-source-4] Mock current news and global reporting coverage.\n- [mock-source-5] Mock public discourse coverage.\n- [mock-source-6] Mock developer and practitioner knowledge coverage.\n- [mock-source-7] Mock counterevidence and fact-checking coverage.\n- [mock-counter-1] Mock overclaim counterexample.\n`);
+    await writeTextAtomic(path.join(dir, paperArtifact), `${researchPaperText}\n`);
     await writeJsonAtomic(path.join(dir, 'research-gate.json'), {
         ...defaultResearchGate(),
         passed: true,
@@ -1528,6 +1536,22 @@ 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'],
+        template_like_prose: false,
+        source_density_ok: true,
+        implementation_concreteness_ok: true,
+        evidence_bound_synthesis_ok: true,
+        required_revisions: [],
+        confidence: 'high',
+        mock: true
+    });
     await writeResearchNativeAgentBatchCompletion(dir, plan);
     return evaluateResearchGate(dir);
 }