sneakoscope 2.0.12 → 2.0.13

package/dist/core/research/replication-pack.js

@@ -0,0 +1,50 @@
+import path from 'node:path';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+export const REPLICATION_PACK_ARTIFACT = 'replication-pack.json';
+export function defaultReplicationPack(plan = null) {
+    return {
+        schema: 'sks.research-replication-pack.v1',
+        generated_at: nowIso(),
+        mission_id: plan?.mission_id || null,
+        prompt: plan?.prompt || '',
+        inputs: ['research-plan.json', 'research-quality-contract.json', 'source-ledger.json', 'claim-evidence-matrix.json'],
+        commands: [
+            'sks research status latest',
+            'npm run research:quality-contract',
+            'npm run research:claim-matrix',
+            'npm run research:final-review'
+        ],
+        expected_artifacts: [
+            'research-report.md',
+            'claim-evidence-matrix.json',
+            'source-quality-report.json',
+            'implementation-blueprint.json',
+            'experiment-plan.json',
+            'replication-pack.json',
+            'research-final-review.json',
+            'research-gate.evaluated.json'
+        ],
+        assumptions: ['Live source retrieval must be recorded in source-ledger.json for real runs.'],
+        reproduction_notes: []
+    };
+}
+export function validateReplicationPack(replicationPack = null) {
+    const commands = Array.isArray(replicationPack?.commands) ? replicationPack.commands : [];
+    const artifacts = Array.isArray(replicationPack?.expected_artifacts) ? replicationPack.expected_artifacts : [];
+    const inputs = Array.isArray(replicationPack?.inputs) ? replicationPack.inputs : [];
+    const blockers = [
+        ...(replicationPack ? [] : ['replication_pack_missing']),
+        ...(commands.length < 3 ? ['replication_pack_commands_too_thin'] : []),
+        ...(artifacts.length < 6 ? ['replication_pack_artifacts_too_thin'] : []),
+        ...(inputs.length < 3 ? ['replication_pack_inputs_too_thin'] : [])
+    ];
+    return { ok: blockers.length === 0, blockers, commands: commands.length, artifacts: artifacts.length, inputs: inputs.length };
+}
+export async function readReplicationPack(dir) {
+    return readJson(path.join(dir, REPLICATION_PACK_ARTIFACT), null);
+}
+export async function writeReplicationPack(dir, replicationPack) {
+    await writeJsonAtomic(path.join(dir, REPLICATION_PACK_ARTIFACT), replicationPack);
+    return replicationPack;
+}
+//# sourceMappingURL=replication-pack.js.map

package/dist/core/research/research-cycle-runner.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
+import { runResearchStage } from './research-stage-runner.js';
+export async function runResearchCycle(dir, graph = null, opts = {}) {
+    const startedAt = nowIso();
+    const stages = Array.isArray(graph?.work_items) ? graph.work_items : [];
+    const stageResults = [];
+    for (const stage of stages) {
+        stageResults.push(await runResearchStage(dir, stage, { status: opts.status || 'planned', startedAt }));
+    }
+    const record = {
+        schema: 'sks.research-cycle-runner.v1',
+        cycle: opts.cycle || 0,
+        readonly: true,
+        started_at: startedAt,
+        completed_at: nowIso(),
+        stage_count: stageResults.length,
+        status: opts.status || 'planned',
+        stages: stageResults.map((stage) => stage.stage_id)
+    };
+    await writeJsonAtomic(path.join(dir, 'research-cycle-runner.json'), record);
+    await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle_runner.recorded', cycle: record.cycle, stage_count: record.stage_count });
+    return record;
+}
+//# sourceMappingURL=research-cycle-runner.js.map

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

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import { analyzeResearchReportQuality } from './research-report-quality.js';
+import { validateClaimEvidenceMatrix } from './claim-evidence-matrix.js';
+import { validateImplementationBlueprint } from './implementation-blueprint.js';
+import { validateExperimentPlan } from './experiment-plan.js';
+import { validateReplicationPack } from './replication-pack.js';
+import { validateFalsificationCoverage } from './falsification.js';
+export const RESEARCH_FINAL_REVIEW_ARTIFACT = 'research-final-review.json';
+export async function readResearchFinalReview(dir) {
+    return readJson(path.join(dir, RESEARCH_FINAL_REVIEW_ARTIFACT), null);
+}
+export async function runResearchFinalReviewer(dir, input = {}) {
+    const contract = input.contract || await readJson(path.join(dir, 'research-quality-contract.json'), null);
+    const sourceLedger = input.sourceLedger || await readJson(path.join(dir, 'source-ledger.json'), null);
+    const claimMatrix = input.claimMatrix || await readJson(path.join(dir, 'claim-evidence-matrix.json'), null);
+    const blueprint = input.blueprint || await readJson(path.join(dir, 'implementation-blueprint.json'), null);
+    const experimentPlan = input.experimentPlan || await readJson(path.join(dir, 'experiment-plan.json'), null);
+    const replicationPack = input.replicationPack || await readJson(path.join(dir, 'replication-pack.json'), null);
+    const falsificationLedger = input.falsificationLedger || await readJson(path.join(dir, 'falsification-ledger.json'), null);
+    const reportText = input.reportText || await readText(path.join(dir, 'research-report.md'), '');
+    const claimValidation = validateClaimEvidenceMatrix(claimMatrix, sourceLedger, falsificationLedger);
+    const blueprintValidation = validateImplementationBlueprint(blueprint, contract);
+    const experimentValidation = validateExperimentPlan(experimentPlan, contract);
+    const replicationValidation = validateReplicationPack(replicationPack);
+    const falsificationValidation = validateFalsificationCoverage(falsificationLedger, contract);
+    const reportQuality = analyzeResearchReportQuality(reportText);
+    const preliminaryReasons = Array.isArray(input.preliminaryReasons) ? input.preliminaryReasons : [];
+    const blockers = [
+        ...preliminaryReasons,
+        ...claimValidation.blockers,
+        ...blueprintValidation.blockers,
+        ...experimentValidation.blockers,
+        ...replicationValidation.blockers,
+        ...falsificationValidation.blockers,
+        ...reportQuality.blockers
+    ];
+    const uniqueBlockers = [...new Set(blockers)];
+    const review = {
+        schema: 'sks.research-final-reviewer.v1',
+        reviewed_at: nowIso(),
+        approved: uniqueBlockers.length === 0,
+        blockers: uniqueBlockers,
+        contract_summary: contract || null,
+        checks: {
+            claim_matrix: claimValidation,
+            implementation_blueprint: blueprintValidation,
+            experiment_plan: experimentValidation,
+            replication_pack: replicationValidation,
+            falsification: falsificationValidation,
+            report_quality: reportQuality
+        },
+        reviewer: 'research_final_reviewer_static_gate'
+    };
+    await writeJsonAtomic(path.join(dir, RESEARCH_FINAL_REVIEW_ARTIFACT), review);
+    return review;
+}
+//# sourceMappingURL=research-final-reviewer.js.map

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

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+export const IMPLEMENTATION_HANDOFF_PATCH_PLAN_ARTIFACT = 'implementation-handoff.patch-plan.json';
+export const TEAM_HANDOFF_GOAL_ARTIFACT = 'team-handoff-goal.md';
+export const DECISION_LOG_ARTIFACT = 'decision-log.md';
+export async function writeResearchHandoffArtifacts(dir, plan = null, blueprint = null) {
+    const patchPlan = {
+        schema: 'sks.research-implementation-handoff-patch-plan.v1',
+        generated_at: nowIso(),
+        mission_id: plan?.mission_id || null,
+        implementation_allowed_in_research: false,
+        intended_route: '$Team',
+        prompt: plan?.prompt || '',
+        source_artifacts: [
+            'research-report.md',
+            'claim-evidence-matrix.json',
+            'implementation-blueprint.json',
+            'experiment-plan.json',
+            'replication-pack.json',
+            'source-quality-report.json'
+        ],
+        proposed_changes: [],
+        notes: [
+            'This is a handoff artifact. Research records implementation guidance but does not mutate repository source.'
+        ]
+    };
+    const goalLines = [
+        '# Research-To-Team Handoff Goal',
+        '',
+        `Mission: ${plan?.mission_id || 'unknown'}`,
+        `Prompt: ${plan?.prompt || ''}`,
+        '',
+        'Use the implementation blueprint, claim-evidence matrix, source-quality report, experiment plan, replication pack, and final reviewer output before changing code.',
+        '',
+        'Blueprint sections:',
+        ...(Array.isArray(blueprint?.sections) ? blueprint.sections.map((section) => `- ${section.id}: ${section.title}`) : [])
+    ];
+    const decisionLog = [
+        '# Research Decision Log',
+        '',
+        `Created: ${nowIso()}`,
+        '',
+        '- Research may write route-local artifacts only.',
+        '- Implementation decisions must be revalidated in the follow-up execution route.'
+    ];
+    await writeJsonAtomic(path.join(dir, IMPLEMENTATION_HANDOFF_PATCH_PLAN_ARTIFACT), patchPlan);
+    await writeTextAtomic(path.join(dir, TEAM_HANDOFF_GOAL_ARTIFACT), `${goalLines.join('\n')}\n`);
+    await writeTextAtomic(path.join(dir, DECISION_LOG_ARTIFACT), `${decisionLog.join('\n')}\n`);
+    return { patch_plan: patchPlan, goal_artifact: TEAM_HANDOFF_GOAL_ARTIFACT, decision_log: DECISION_LOG_ARTIFACT };
+}
+//# sourceMappingURL=research-handoff.js.map

package/dist/core/research/research-prompt-contract.js

@@ -0,0 +1,24 @@
+export const RESEARCH_PROMPT_CONTRACT_LINES = Object.freeze([
+    'QUALITY CONTRACT: satisfy research-quality-contract.json before setting research-gate.json passed=true.',
+    'CLAIM MATRIX: create claim-evidence-matrix.json with key claims, source ids, counterevidence ids, triangulation, and hypothesis status.',
+    'SOURCE QUALITY: create source-quality-report.json and record claim_ids on source-ledger sources.',
+    'BLUEPRINT: create implementation-blueprint.json and implementation-blueprint.md with at least eight sections.',
+    'EXPERIMENT: create experiment-plan.json/.md with at least five steps and a replication-pack.json.',
+    'FINAL REVIEW: create research-final-review.json and keep the gate blocked unless approved=true.',
+    'READ ONLY: do not mutate repository source during Research; write only route-local mission artifacts.'
+]);
+export function researchPromptContractText() {
+    return RESEARCH_PROMPT_CONTRACT_LINES.join('\n');
+}
+export function validateResearchPromptContract(promptText = '') {
+    const text = String(promptText || '');
+    const requiredTokens = ['research-quality-contract.json', 'claim-evidence-matrix.json', 'source-quality-report.json', 'implementation-blueprint.json', 'experiment-plan.json', 'replication-pack.json', 'research-final-review.json'];
+    const missing = requiredTokens.filter((token) => !text.includes(token));
+    return {
+        ok: missing.length === 0,
+        blockers: missing.map((token) => `research_prompt_contract_missing:${token}`),
+        required_tokens: requiredTokens,
+        missing_tokens: missing
+    };
+}
+//# sourceMappingURL=research-prompt-contract.js.map

package/dist/core/research/research-quality-contract.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+export const RESEARCH_QUALITY_CONTRACT_ARTIFACT = 'research-quality-contract.json';
+export const DEFAULT_RESEARCH_QUALITY_CONTRACT = {
+    schema: 'sks.research-quality-contract.v1',
+    min_sources_total: 12,
+    min_source_layers_covered: 5,
+    min_counterevidence_sources: 2,
+    min_trianguled_claims: 6,
+    min_key_claims: 8,
+    min_implementation_blueprint_sections: 8,
+    min_falsification_cases: 4,
+    min_experiment_steps: 5,
+    min_report_words: 2200,
+    required_artifacts: [
+        'research-report.md',
+        'implementation-blueprint.md',
+        'implementation-blueprint.json',
+        'claim-evidence-matrix.json',
+        'source-ledger.json',
+        'source-quality-report.json',
+        'falsification-ledger.json',
+        'experiment-plan.md',
+        'replication-pack.json',
+        'research-gate.json'
+    ]
+};
+export function normalizeResearchQualityContract(input = {}) {
+    const source = input && typeof input === 'object' ? input : {};
+    return {
+        ...DEFAULT_RESEARCH_QUALITY_CONTRACT,
+        ...source,
+        schema: 'sks.research-quality-contract.v1',
+        min_sources_total: positiveInt(source.min_sources_total, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_sources_total),
+        min_source_layers_covered: positiveInt(source.min_source_layers_covered, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_source_layers_covered),
+        min_counterevidence_sources: positiveInt(source.min_counterevidence_sources, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_counterevidence_sources),
+        min_trianguled_claims: positiveInt(source.min_trianguled_claims ?? source.min_triangulated_claims, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_trianguled_claims),
+        min_key_claims: positiveInt(source.min_key_claims, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_key_claims),
+        min_implementation_blueprint_sections: positiveInt(source.min_implementation_blueprint_sections, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_implementation_blueprint_sections),
+        min_falsification_cases: positiveInt(source.min_falsification_cases, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_falsification_cases),
+        min_experiment_steps: positiveInt(source.min_experiment_steps, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_experiment_steps),
+        min_report_words: positiveInt(source.min_report_words, DEFAULT_RESEARCH_QUALITY_CONTRACT.min_report_words),
+        required_artifacts: Array.isArray(source.required_artifacts) && source.required_artifacts.length
+            ? source.required_artifacts.map(String)
+            : [...DEFAULT_RESEARCH_QUALITY_CONTRACT.required_artifacts]
+    };
+}
+export async function readResearchQualityContract(dir) {
+    const contract = await readJson(path.join(dir, RESEARCH_QUALITY_CONTRACT_ARTIFACT), null);
+    return normalizeResearchQualityContract(contract || {});
+}
+export async function writeResearchQualityContract(dir, contract = {}) {
+    const normalized = normalizeResearchQualityContract(contract);
+    await writeJsonAtomic(path.join(dir, RESEARCH_QUALITY_CONTRACT_ARTIFACT), normalized);
+    return normalized;
+}
+function positiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+//# sourceMappingURL=research-quality-contract.js.map

package/dist/core/research/research-report-quality.js

@@ -0,0 +1,67 @@
+export const REQUIRED_RESEARCH_REPORT_HEADINGS = [
+    'Question',
+    'Methodology',
+    'Source Map',
+    'Key Claims',
+    'Evidence Matrix Summary',
+    'Counterevidence',
+    'Falsification',
+    'Implementation Blueprint',
+    'Experiment / Validation Plan',
+    'Limitations',
+    'References'
+];
+export function analyzeResearchReportQuality(text) {
+    const body = String(text || '');
+    const headings = body.split(/\r?\n/)
+        .map((line) => line.match(/^#{1,6}\s+(.+?)\s*#*\s*$/)?.[1]?.trim())
+        .filter((value) => Boolean(value));
+    const lowerHeadings = headings.map((heading) => normalizeHeading(heading));
+    const headingsPresent = REQUIRED_RESEARCH_REPORT_HEADINGS.filter((heading) => lowerHeadings.some((value) => value.includes(normalizeHeading(heading))));
+    const missingHeadings = REQUIRED_RESEARCH_REPORT_HEADINGS.filter((heading) => !headingsPresent.includes(heading));
+    const implementationText = sectionText(body, 'Implementation Blueprint');
+    const referencesText = sectionText(body, 'References');
+    const referencesSourceIds = [...new Set([
+            ...body.matchAll(/\b(?:source|src|mock-source|counter|mock-counter)-[A-Za-z0-9_.:-]+\b/g)
+        ].map((match) => match[0]))];
+    const blockers = [
+        ...missingHeadings.map((heading) => `research_report_heading_missing:${normalizeHeading(heading).replace(/\s+/g, '_')}`),
+        ...(referencesSourceIds.length ? [] : ['research_report_references_missing_source_ids'])
+    ];
+    return {
+        schema: 'sks.research-report-quality.v1',
+        word_count: countWords(body),
+        headings_present: headingsPresent,
+        missing_headings: missingHeadings,
+        implementation_section_words: countWords(implementationText),
+        references_source_ids: referencesText ? referencesSourceIds : [],
+        blockers,
+        ok: blockers.length === 0
+    };
+}
+export function countWords(text) {
+    return String(text || '').trim().split(/\s+/).filter(Boolean).length;
+}
+function normalizeHeading(value) {
+    return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
+function sectionText(text, heading) {
+    const lines = String(text || '').split(/\r?\n/);
+    const target = normalizeHeading(heading);
+    let capture = false;
+    const out = [];
+    for (const line of lines) {
+        const match = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+        if (match) {
+            const normalized = normalizeHeading(match[2] || '');
+            if (capture)
+                break;
+            capture = normalized.includes(target);
+            continue;
+        }
+        if (capture)
+            out.push(line);
+    }
+    return out.join('\n');
+}
+//# sourceMappingURL=research-report-quality.js.map

package/dist/core/research/research-stage-runner.js

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export async function runResearchStage(dir, stage, opts = {}) {
+    const record = {
+        schema: 'sks.research-stage-run.v1',
+        stage_id: stage?.id || opts.stageId || 'unknown',
+        status: opts.status || 'recorded',
+        readonly: true,
+        started_at: opts.startedAt || nowIso(),
+        completed_at: nowIso(),
+        notes: opts.notes || []
+    };
+    await writeJsonAtomic(path.join(dir, 'research', 'stages', `${record.stage_id}.json`), record);
+    return record;
+}
+//# sourceMappingURL=research-stage-runner.js.map

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

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.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) {
+    const missionPrefix = plan?.mission_id ? `.sneakoscope/missions/${plan.mission_id}/` : '';
+    return {
+        id: stage.id,
+        kind: stage.kind,
+        title: stage.title,
+        target_paths: stage.outputs.map((artifact) => `${missionPrefix}${artifact}`),
+        readonly_paths: [
+            `${missionPrefix}research-plan.json`,
+            `${missionPrefix}research-quality-contract.json`,
+            `${missionPrefix}source-ledger.json`,
+            `${missionPrefix}claim-evidence-matrix.json`
+        ],
+        write_paths: [],
+        required_role: index < 4 ? 'research' : '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),
+        conflicts_with: [],
+        estimated_cost: { tokens: 4000, latency_ms: 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 },
+        owner: null,
+        allocation_reason: 'Stage-aware read-only research pipeline work graph',
+        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 }
+    };
+}
+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));
+    return {
+        schema: 'sks.naruto-work-graph.v1',
+        route: '$Naruto',
+        requested_clones: requestedClones,
+        total_work_items: workItems.length,
+        readonly: true,
+        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 }
+        ],
+        mixed_work_kinds: [...new Set(workItems.map((item) => item.kind))],
+        write_allowed_count: 0,
+        worktree_policy: { mode: 'patch-envelope-only', required: false, main_repo_root: null, worktree_root: null, fallback_reason: 'Research route is read-only.' },
+        blockers: [],
+        ok: true
+    };
+}
+export async function writeResearchWorkGraph(dir, plan = null) {
+    const graph = buildResearchWorkGraph(plan);
+    await writeJsonAtomic(path.join(dir, RESEARCH_WORK_GRAPH_ARTIFACT), {
+        ...graph,
+        generated_at: nowIso()
+    });
+    return graph;
+}
+//# sourceMappingURL=research-work-graph.js.map

package/dist/core/research/source-quality-report.js

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+export const SOURCE_QUALITY_REPORT_ARTIFACT = 'source-quality-report.json';
+const REQUIRED_SOURCE_FIELDS = Object.freeze([
+    'id',
+    'layer',
+    'kind',
+    'title',
+    'locator',
+    'publisher_or_author',
+    'accessed_at',
+    'reliability',
+    'credibility',
+    'stance',
+    'claim_ids'
+]);
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function sourceRows(sourceLedger = null) {
+    return [
+        ...asArray(sourceLedger?.sources),
+        ...asArray(sourceLedger?.counterevidence_sources)
+    ];
+}
+function missingFields(row) {
+    return REQUIRED_SOURCE_FIELDS.filter((field) => {
+        const value = row?.[field];
+        if (Array.isArray(value))
+            return value.length === 0;
+        return value === undefined || value === null || String(value).trim() === '';
+    });
+}
+export function buildSourceQualityReport(sourceLedger = null, claimMatrix = null) {
+    const rows = sourceRows(sourceLedger);
+    const rowReports = rows.map((row) => {
+        const missing = missingFields(row);
+        return {
+            id: String(row?.id || ''),
+            layer: row?.layer || row?.layer_id || row?.source_layer || null,
+            stance: row?.stance || null,
+            claim_ids: asArray(row?.claim_ids).map(String),
+            reliability: row?.reliability || null,
+            credibility: row?.credibility || null,
+            missing_fields: missing,
+            ok: missing.length === 0
+        };
+    });
+    const sourceLayerRows = asArray(sourceLedger?.source_layers);
+    const coveredLayerIds = sourceLayerRows
+        .filter((layer) => layer?.status === 'covered')
+        .map((layer) => String(layer.id || layer.layer || ''))
+        .filter(Boolean);
+    const keyClaimIds = asArray(claimMatrix?.key_claim_ids).map(String);
+    const citedClaimIds = new Set(rows.flatMap((row) => asArray(row?.claim_ids).map(String)));
+    const uncitedKeyClaimIds = keyClaimIds.filter((id) => !citedClaimIds.has(id));
+    const blockers = [
+        ...rowReports.flatMap((row) => row.ok ? [] : [`source_metadata_incomplete:${row.id || 'unknown'}`]),
+        ...(keyClaimIds.length && uncitedKeyClaimIds.length ? ['key_claim_citation_coverage_incomplete'] : []),
+        ...(sourceLedger?.citation_coverage?.all_key_claims_cited === false ? ['source_ledger_reports_uncited_key_claims'] : [])
+    ];
+    return {
+        schema: 'sks.research-source-quality-report.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        blockers,
+        required_source_fields: [...REQUIRED_SOURCE_FIELDS],
+        summary: {
+            source_entries: asArray(sourceLedger?.sources).length,
+            counterevidence_entries: asArray(sourceLedger?.counterevidence_sources).length,
+            total_entries: rows.length,
+            rows_with_complete_metadata: rowReports.filter((row) => row.ok).length,
+            source_layers_covered: coveredLayerIds.length,
+            key_claims: keyClaimIds.length,
+            cited_key_claims: keyClaimIds.length - uncitedKeyClaimIds.length,
+            uncited_key_claims: uncitedKeyClaimIds.length
+        },
+        citation_coverage: {
+            all_key_claims_cited: uncitedKeyClaimIds.length === 0 && sourceLedger?.citation_coverage?.all_key_claims_cited === true,
+            cited_claim_ids: [...citedClaimIds].sort(),
+            uncited_key_claim_ids: uncitedKeyClaimIds
+        },
+        sources: rowReports
+    };
+}
+export async function readSourceQualityReport(dir) {
+    return readJson(path.join(dir, SOURCE_QUALITY_REPORT_ARTIFACT), null);
+}
+export async function writeSourceQualityReport(dir, sourceLedger = null, claimMatrix = null) {
+    const report = buildSourceQualityReport(sourceLedger, claimMatrix);
+    await writeJsonAtomic(path.join(dir, SOURCE_QUALITY_REPORT_ARTIFACT), report);
+    return report;
+}
+//# sourceMappingURL=source-quality-report.js.map