sneakoscope 6.0.3 → 6.1.2

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

@@ -0,0 +1,176 @@
+import path from 'node:path';
+import { nowIso, readJson } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-task-runner.js';
+import { THINKING_SUBAGENT_MODEL, SUBAGENT_EFFORT } from '../subagents/model-policy.js';
+export async function runResearchFalsification(input) {
+    const result = await runCodexTask({
+        route: '$Research',
+        tier: 'orchestrator',
+        missionId: String(input.plan?.mission_id || 'research-falsification'),
+        workItemId: 'research_falsification',
+        cwd: input.root,
+        prompt: buildResearchFalsificationPrompt(input),
+        inputFiles: [path.join(input.dir, 'claim-evidence-matrix.json'), path.join(input.dir, 'source-ledger.json')],
+        outputSchema: researchFalsificationOutputSchema,
+        outputSchemaId: 'sks.falsification-ledger.v1',
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: {
+            id: 'research-falsification',
+            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', 'falsification-codex-control'),
+        reliabilityPolicy: {
+            timeoutClass: 'standard',
+            idleTimeoutMs: input.timeoutMs,
+            hardTimeoutMs: input.timeoutMs,
+            ...(input.deadlineMs === undefined ? {} : { deadlineEpochMs: input.deadlineMs })
+        },
+        model: THINKING_SUBAGENT_MODEL,
+        reasoningEffort: SUBAGENT_EFFORT,
+        modelReasoningEffort: SUBAGENT_EFFORT,
+        serviceTier: 'fast'
+    });
+    const worker = await readJson(result.workerResultPath, null);
+    const normalized = normalizeResearchFalsification(worker, input.claimMatrix, input.sourceLedger);
+    const blockers = unique([
+        ...(Array.isArray(result.blockers) ? result.blockers.map(String) : []),
+        ...normalized.blockers
+    ]);
+    return {
+        ...normalized,
+        blockers,
+        worker_result_path: typeof result.workerResultPath === 'string' ? result.workerResultPath : null
+    };
+}
+export function normalizeResearchFalsification(value, claimMatrix, sourceLedger) {
+    const knownClaimIds = new Set((Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : []).map((claim) => String(claim?.id || '')).filter(Boolean));
+    const knownSourceIds = new Set([
+        ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+    ].map((source) => String(source?.id || '')).filter(Boolean));
+    const blockers = normalizeStrings(value?.blockers);
+    const cases = (Array.isArray(value?.cases) ? value.cases : []).map((row, index) => {
+        const id = String(row?.id || `falsification-${index + 1}`).trim();
+        const targetClaim = String(row?.target_claim || row?.claim_id || '').trim();
+        const sourceIds = normalizeStrings(row?.source_ids).filter((sourceId) => knownSourceIds.has(sourceId));
+        const result = ['survives', 'weakened', 'refuted', 'inconclusive'].includes(row?.result) ? row.result : 'inconclusive';
+        if (!knownClaimIds.has(targetClaim))
+            blockers.push(`falsification_target_claim_unknown:${id}:${targetClaim || 'missing'}`);
+        for (const sourceId of normalizeStrings(row?.source_ids)) {
+            if (!knownSourceIds.has(sourceId))
+                blockers.push(`falsification_source_unknown:${id}:${sourceId}`);
+        }
+        if (!String(row?.attack || '').trim())
+            blockers.push(`falsification_attack_missing:${id}`);
+        if (!sourceIds.length)
+            blockers.push(`falsification_source_missing:${id}`);
+        if (!String(row?.next_decisive_test || '').trim())
+            blockers.push(`falsification_next_test_missing:${id}`);
+        return {
+            id,
+            target_claim: targetClaim,
+            attack: String(row?.attack || '').trim(),
+            source_ids: sourceIds,
+            result,
+            reasoning: String(row?.reasoning || '').trim(),
+            limitations: normalizeStrings(row?.limitations),
+            next_decisive_test: String(row?.next_decisive_test || '').trim()
+        };
+    });
+    const unresolvedFailures = cases
+        .filter((row) => row.result !== 'survives')
+        .map((row) => `${row.target_claim}:${row.result}`);
+    if (cases.length < 4)
+        blockers.push('falsification_cases_below_contract');
+    if (new Set(cases.map((row) => row.target_claim)).size < Math.min(4, knownClaimIds.size))
+        blockers.push('falsification_claim_coverage_below_contract');
+    if (unresolvedFailures.length)
+        blockers.push(...unresolvedFailures.map((row) => `falsification_unresolved:${row}`));
+    return {
+        schema_version: 1,
+        schema: 'sks.falsification-ledger.v1',
+        created_at: String(value?.created_at || nowIso()),
+        execution_class: 'real',
+        cases,
+        unresolved_failures: unresolvedFailures,
+        next_decisive_tests: unique(cases.map((row) => row.next_decisive_test).filter(Boolean)),
+        blockers: unique(blockers)
+    };
+}
+function buildResearchFalsificationPrompt(input) {
+    return [
+        'Attempt to falsify the key claims in this Research mission before manuscript synthesis.',
+        'This is a judgment-heavy task: use GPT-5.6 Sol with max reasoning.',
+        'Return exactly one JSON object matching sks.falsification-ledger.v1.',
+        'Do not mark a claim as surviving by default. Compare the written claim with actual source notes/content and counterevidence.',
+        'Use only known claim IDs and source IDs. A generic attack with no source-linked reasoning is invalid.',
+        'Allowed result values are survives, weakened, refuted, and inconclusive.',
+        'If evidence is missing, use inconclusive and identify the decisive next test.',
+        `Mission: ${input.plan?.mission_id || 'unknown'}`,
+        `Question: ${input.plan?.prompt || ''}`,
+        '',
+        'Claim matrix and evidence:',
+        JSON.stringify({
+            claims: input.claimMatrix?.claims || [],
+            sources: [
+                ...(Array.isArray(input.sourceLedger?.sources) ? input.sourceLedger.sources : []),
+                ...(Array.isArray(input.sourceLedger?.counterevidence_sources) ? input.sourceLedger.counterevidence_sources : [])
+            ].map((source) => ({
+                id: source.id,
+                layer: source.layer,
+                title: source.title,
+                locator: source.locator,
+                publisher_or_author: source.publisher_or_author,
+                credibility: source.credibility,
+                stance: source.stance,
+                notes: source.notes,
+                content_artifact: source.content_artifact || null,
+                content_sha256: source.content_sha256 || null
+            }))
+        }, null, 2).slice(0, 30000)
+    ].join('\n');
+}
+function normalizeStrings(value) {
+    return unique((Array.isArray(value) ? value : value == null ? [] : [value]).map((entry) => String(entry || '').trim()).filter(Boolean));
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+export const researchFalsificationOutputSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['schema', 'cases', 'unresolved_failures', 'next_decisive_tests', 'blockers'],
+    properties: {
+        schema: { const: 'sks.falsification-ledger.v1' },
+        cases: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['id', 'target_claim', 'attack', 'source_ids', 'result', 'reasoning', 'limitations', 'next_decisive_test'],
+                properties: {
+                    id: { type: 'string' },
+                    target_claim: { type: 'string' },
+                    attack: { type: 'string' },
+                    source_ids: { type: 'array', items: { type: 'string' } },
+                    result: { enum: ['survives', 'weakened', 'refuted', 'inconclusive'] },
+                    reasoning: { type: 'string' },
+                    limitations: { type: 'array', items: { type: 'string' } },
+                    next_decisive_test: { type: 'string' }
+                }
+            }
+        },
+        unresolved_failures: { type: 'array', items: { type: 'string' } },
+        next_decisive_tests: { type: 'array', items: { type: 'string' } },
+        blockers: { type: 'array', items: { type: 'string' } }
+    }
+};
+//# sourceMappingURL=research-falsification-runner.js.map

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

@@ -1,12 +1,12 @@
 import path from 'node:path';
 import { nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
-import { runCodexTask } from '../codex-control/codex-task-runner.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';
+import { RESEARCH_ADVERSARIAL_REVIEW_ARTIFACT, RESEARCH_CONVERGENCE_GATE_ARTIFACT } from './research-adversarial-review.js';
 export const RESEARCH_FINAL_REVIEW_ARTIFACT = 'research-final-review.json';
 export const RESEARCH_STATIC_FINAL_REVIEW_ARTIFACT = 'research-final-review.static.json';
 export const RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT = 'research-final-review.codex.json';
@@ -80,69 +80,54 @@ export async function runResearchCodexFinalReviewer(input) {
         await writeJsonAtomic(path.join(input.dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), skipped);
         return skipped;
     }
-    if (input.mock === true) {
-        const approved = {
-            schema: 'sks.research-codex-final-review.v1',
-            reviewed_at: nowIso(),
-            verdict: 'approve',
-            unsupported_claim_ids: [],
-            missing_evidence: [],
-            blueprint_findings: ['mock final reviewer approves the complete package fixture'],
-            falsification_findings: ['mock counterevidence and falsification cases are present'],
-            template_like_prose: false,
-            source_density_ok: true,
-            implementation_concreteness_ok: true,
-            evidence_bound_synthesis_ok: true,
-            required_revisions: [],
-            confidence: 'high',
-            mock: true
-        };
-        await writeJsonAtomic(path.join(input.dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), approved);
-        return approved;
-    }
-    const result = await runCodexTask({
-        route: '$Research',
-        tier: 'worker',
-        missionId: String(input.plan?.mission_id || 'research-final-review'),
-        workItemId: 'research_final_review',
-        cwd: input.root,
-        prompt: buildResearchFinalReviewPrompt(input.plan, input.staticReview),
-        outputSchema: researchCodexFinalReviewSchema,
-        outputSchemaId: 'sks.research-codex-final-review.v1',
-        sandboxPolicy: 'read-only',
-        requestedScopeContract: {
-            id: 'research-final-review',
-            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'],
-        localLlmPolicy: { mode: 'disabled', requiresGptFinal: true },
-        allowLocalLlm: false,
-        mutationLedgerRoot: path.join(input.dir, 'research', 'final-review-codex-control'),
-        reliabilityPolicy: {
-            timeoutClass: 'standard',
-            idleTimeoutMs: input.timeoutMs || 120000
-        }
-    });
-    const worker = await readJson(result.workerResultPath, null);
-    const review = normalizeCodexReview(worker, result);
+    const convergence = await readJson(path.join(input.dir, RESEARCH_CONVERGENCE_GATE_ARTIFACT), null);
+    const ledger = await readJson(path.join(input.dir, RESEARCH_ADVERSARIAL_REVIEW_ARTIFACT), null);
+    const finalCycle = Array.isArray(ledger?.review_cycles) ? ledger.review_cycles.at(-1) : null;
+    const reviewers = Array.isArray(finalCycle?.reviewers) ? finalCycle.reviewers : [];
+    const objections = reviewers.flatMap((reviewer) => [
+        ...(Array.isArray(reviewer?.critical_objections) ? reviewer.critical_objections : []),
+        ...(Array.isArray(reviewer?.major_objections) ? reviewer.major_objections : [])
+    ]);
+    const requiredRevisions = [...new Set([
+            ...reviewers.flatMap((reviewer) => Array.isArray(reviewer?.required_revisions) ? reviewer.required_revisions : []),
+            ...objections.map((objection) => objection?.required_revision).filter(Boolean),
+            ...(Array.isArray(convergence?.blockers) ? convergence.blockers : [])
+        ].map(String))];
+    const approved = convergence?.passed === true;
+    const review = {
+        schema: 'sks.research-codex-final-review.v1',
+        reviewed_at: nowIso(),
+        verdict: approved ? 'approve' : 'revise',
+        unsupported_claim_ids: [...new Set(objections.flatMap((objection) => Array.isArray(objection?.claim_ids) ? objection.claim_ids.map(String) : []))],
+        missing_evidence: objections.filter((objection) => !Array.isArray(objection?.source_ids) || objection.source_ids.length === 0).map((objection) => String(objection?.id || 'unknown')),
+        blueprint_findings: approved ? ['official subagent reviewers accepted the evidence-bound implementation handoff'] : [],
+        falsification_findings: reviewers.map((reviewer) => String(reviewer?.strongest_challenge || '')).filter(Boolean),
+        template_like_prose: objections.some((objection) => /template|boilerplate|repet/i.test(String(objection?.reason || ''))),
+        source_density_ok: approved,
+        implementation_concreteness_ok: input.staticReview?.checks?.implementation_blueprint?.ok === true,
+        evidence_bound_synthesis_ok: approved,
+        required_revisions: requiredRevisions,
+        confidence: approved ? 'high' : reviewers.length ? 'medium' : 'low',
+        official_subagent_review: true,
+        reviewer_count: reviewers.length,
+        review_cycles: Number(convergence?.review_cycles || 0),
+        unresolved_critical_objections: Number(convergence?.unresolved_critical_objections || 0),
+        ...(input.mock === true ? { mock: true } : {})
+    };
     await writeJsonAtomic(path.join(input.dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), review);
     return review;
 }
 export async function runResearchFinalReviewer(dir, input = {}) {
     const staticReview = await runResearchStaticFinalReview(dir, input);
     const existingCodex = await readJson(path.join(dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), null);
-    const codexReview = existingCodex || (input.mock === true ? await runResearchCodexFinalReviewer({
+    const codexReview = existingCodex || await runResearchCodexFinalReviewer({
         root: input.root || process.cwd(),
         dir,
         plan: input.plan || await readJson(path.join(dir, 'research-plan.json'), null),
         staticReview,
-        mock: true
-    }) : null);
+        mock: input.mock === true
+    });
+    const adversarialGate = await readJson(path.join(dir, RESEARCH_CONVERGENCE_GATE_ARTIFACT), null);
     const codexApproved = codexReview?.verdict === 'approve';
     const codexRequired = input.codexRequired !== false;
     const blockers = [
@@ -153,86 +138,20 @@ export async function runResearchFinalReviewer(dir, input = {}) {
         ...(codexReview && codexReview.source_density_ok === false ? ['research_codex_source_density_not_ok'] : []),
         ...(codexReview && codexReview.implementation_concreteness_ok === false ? ['research_codex_implementation_concreteness_not_ok'] : []),
         ...(codexReview && codexReview.evidence_bound_synthesis_ok === false ? ['research_codex_evidence_bound_synthesis_not_ok'] : []),
-        ...(Array.isArray(codexReview?.required_revisions) ? codexReview.required_revisions.map((revision) => `codex_revision:${revision}`) : [])
+        ...(Array.isArray(codexReview?.required_revisions) ? codexReview.required_revisions.map((revision) => `codex_revision:${revision}`) : []),
+        ...(adversarialGate?.passed === true ? [] : ['research_adversarial_convergence_not_passed'])
     ];
     const review = {
         schema: 'sks.research-final-reviewer.v2',
         reviewed_at: nowIso(),
-        approved: staticReview?.approved === true && (!codexRequired || codexApproved) && blockers.length === 0,
+        approved: staticReview?.approved === true && adversarialGate?.passed === true && (!codexRequired || codexApproved) && blockers.length === 0,
         blockers: [...new Set(blockers)],
         static_review: staticReview,
         codex_review: codexReview,
-        reviewer: 'research_final_reviewer_static_plus_codex_gate'
+        adversarial_convergence: adversarialGate,
+        reviewer: 'research_final_reviewer_static_plus_official_subagents'
     };
     await writeJsonAtomic(path.join(dir, RESEARCH_FINAL_REVIEW_ARTIFACT), review);
     return review;
 }
-function buildResearchFinalReviewPrompt(plan, staticReview) {
-    return [
-        'You are the Codex/GPT final reviewer for an SKS Research package.',
-        `Mission: ${plan?.mission_id || 'unknown'}`,
-        `Prompt: ${plan?.prompt || ''}`,
-        '',
-        'Review the mission artifacts read-only. Reject if claims lack evidence, blueprint steps are template-like, falsification is missing, or the package is only a short summary.',
-        'Reject repeated paragraphs, template-like prose, unsupported synthesis, source IDs that do not exist in source-ledger, and implementation blueprints that lack concrete files/tests.',
-        'Set template_like_prose=true for repeated or boilerplate reports. Set source_density_ok=false for sparse source ids. Set implementation_concreteness_ok=false for weak file/test/rollback plans. Set evidence_bound_synthesis_ok=false when recommendations are not tied to evidence.',
-        'Return only JSON matching sks.research-codex-final-review.v1 with verdict approve, revise, or reject.',
-        '',
-        `Static review summary:\n${JSON.stringify(staticReview, null, 2).slice(0, 12000)}`
-    ].join('\n');
-}
-function normalizeCodexReview(worker, result) {
-    if (!result?.ok) {
-        return {
-            schema: 'sks.research-codex-final-review.v1',
-            reviewed_at: nowIso(),
-            verdict: 'revise',
-            unsupported_claim_ids: [],
-            missing_evidence: [],
-            blueprint_findings: [],
-            falsification_findings: [],
-            template_like_prose: false,
-            source_density_ok: false,
-            implementation_concreteness_ok: false,
-            evidence_bound_synthesis_ok: false,
-            required_revisions: Array.isArray(result?.blockers) ? result.blockers : ['codex_final_reviewer_unavailable'],
-            confidence: 'low',
-            worker_result_path: result?.workerResultPath || null
-        };
-    }
-    return {
-        schema: 'sks.research-codex-final-review.v1',
-        reviewed_at: nowIso(),
-        verdict: ['approve', 'revise', 'reject'].includes(worker?.verdict) ? worker.verdict : 'revise',
-        unsupported_claim_ids: Array.isArray(worker?.unsupported_claim_ids) ? worker.unsupported_claim_ids.map(String) : [],
-        missing_evidence: Array.isArray(worker?.missing_evidence) ? worker.missing_evidence.map(String) : [],
-        blueprint_findings: Array.isArray(worker?.blueprint_findings) ? worker.blueprint_findings.map(String) : [],
-        falsification_findings: Array.isArray(worker?.falsification_findings) ? worker.falsification_findings.map(String) : [],
-        template_like_prose: worker?.template_like_prose === true,
-        source_density_ok: worker?.source_density_ok === true,
-        implementation_concreteness_ok: worker?.implementation_concreteness_ok === true,
-        evidence_bound_synthesis_ok: worker?.evidence_bound_synthesis_ok === true,
-        required_revisions: Array.isArray(worker?.required_revisions) ? worker.required_revisions.map(String) : [],
-        confidence: ['low', 'medium', 'high'].includes(worker?.confidence) ? worker.confidence : 'medium',
-        worker_result_path: result.workerResultPath
-    };
-}
-export const researchCodexFinalReviewSchema = {
-    type: 'object',
-    required: ['schema', 'verdict', 'unsupported_claim_ids', 'missing_evidence', 'blueprint_findings', 'falsification_findings', 'template_like_prose', 'source_density_ok', 'implementation_concreteness_ok', 'evidence_bound_synthesis_ok', 'required_revisions', 'confidence'],
-    properties: {
-        schema: { const: 'sks.research-codex-final-review.v1' },
-        verdict: { enum: ['approve', 'revise', 'reject'] },
-        unsupported_claim_ids: { type: 'array' },
-        missing_evidence: { type: 'array' },
-        blueprint_findings: { type: 'array' },
-        falsification_findings: { type: 'array' },
-        template_like_prose: { type: 'boolean' },
-        source_density_ok: { type: 'boolean' },
-        implementation_concreteness_ok: { type: 'boolean' },
-        evidence_bound_synthesis_ok: { type: 'boolean' },
-        required_revisions: { type: 'array' },
-        confidence: { enum: ['low', 'medium', 'high'] }
-    }
-};
 //# sourceMappingURL=research-final-reviewer.js.map

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

@@ -1,17 +1,18 @@
 import { REQUIRED_RESEARCH_REPORT_HEADINGS } from './research-report-quality.js';
 export function buildRealisticResearchReport(input) {
     const plan = input.plan || {};
-    const claims = normalizeClaims(input.claims);
+    const claims = normalizeClaims(prioritizeKeyClaims(input.claims, input.keyClaimIds));
     const sourceIds = normalizeIds(input.sourceIds).length ? normalizeIds(input.sourceIds) : fallbackIds('source', 14);
     const counterIds = normalizeIds(input.counterevidenceIds).length ? normalizeIds(input.counterevidenceIds) : fallbackIds('counter', 2);
     const sections = Array.isArray(input.blueprint?.sections) ? input.blueprint.sections : [];
     const experimentSteps = Array.isArray(input.experimentPlan?.steps) ? input.experimentPlan.steps : [];
     const falsificationCases = Array.isArray(input.falsificationLedger?.cases) ? input.falsificationLedger.cases : [];
     const claimBullets = claims.slice(0, 8).map((claim, index) => {
-        const sourceA = sourceIds[index % sourceIds.length];
-        const sourceB = sourceIds[(index + 3) % sourceIds.length];
-        const counter = counterIds[index % counterIds.length];
-        return `- ${claim.id}: ${claim.claim} The claim is supported by ${sourceA} and ${sourceB}, challenged by ${counter}, and kept falsifiable through "${claim.test_or_probe || 'the next listed validation probe'}".`;
+        const linkedSources = normalizeIds(claim.source_ids);
+        const linkedCounterevidence = normalizeIds(claim.counterevidence_ids);
+        const citedSources = (linkedSources.length ? linkedSources : [sourceIds[index % sourceIds.length], sourceIds[(index + 3) % sourceIds.length]]).filter(Boolean).slice(0, 3);
+        const citedCounterevidence = (linkedCounterevidence.length ? linkedCounterevidence : [counterIds[index % counterIds.length]]).filter(Boolean).slice(0, 2);
+        return `- ${claim.id}: ${claim.claim} Claim-local support: ${citedSources.join(', ')}. Claim-local counterevidence: ${citedCounterevidence.join(', ')}. Falsifiable probe: "${claim.test_or_probe || 'the next listed validation probe'}".`;
     });
     const blueprintTargets = [...new Set(sections.flatMap((section) => Array.isArray(section?.target_paths) ? section.target_paths : []))].slice(0, 12);
     return [
@@ -95,7 +96,7 @@ export function buildRealisticResearchReport(input) {
     ].join('\n\n');
 }
 export function buildRealisticResearchPaper(input) {
-    const claims = normalizeClaims(input.claims);
+    const claims = normalizeClaims(prioritizeKeyClaims(input.claims, input.keyClaimIds));
     const sourceIds = normalizeIds(input.sourceIds).length ? normalizeIds(input.sourceIds) : fallbackIds('source', 14);
     const counterIds = normalizeIds(input.counterevidenceIds).length ? normalizeIds(input.counterevidenceIds) : fallbackIds('counter', 2);
     return [
@@ -128,6 +129,13 @@ export function buildRealisticResearchPaper(input) {
         ''
     ].join('\n');
 }
+function prioritizeKeyClaims(claims, keyClaimIds) {
+    const rows = Array.isArray(claims) ? claims : [];
+    const byId = new Map(rows.map((claim) => [String(claim?.id || ''), claim]));
+    const prioritized = normalizeIds(keyClaimIds).map((id) => byId.get(id)).filter(Boolean);
+    const prioritizedIds = new Set(prioritized.map((claim) => String(claim?.id || '')));
+    return [...prioritized, ...rows.filter((claim) => !prioritizedIds.has(String(claim?.id || '')))];
+}
 export function requiredResearchReportHeadings() {
     return [...REQUIRED_RESEARCH_REPORT_HEADINGS];
 }

package/dist/core/research/research-review-artifact-digest.js

@@ -0,0 +1,66 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, sha256 } from '../fsx.js';
+export const RESEARCH_REVIEW_DIGEST_SCHEMA = 'sks.research-review-artifact-digest.v1';
+export async function buildResearchReviewArtifactDigest(dir, plan) {
+    const artifacts = researchReviewArtifactNames(plan);
+    const blockers = [];
+    const rows = await Promise.all(artifacts.map(async (artifact) => {
+        const file = path.join(dir, artifact);
+        const content = await fsp.readFile(file).catch(() => null);
+        if (!content) {
+            blockers.push(`research_review_artifact_missing:${artifact}`);
+            return { artifact, sha256: null, bytes: 0 };
+        }
+        if (content.length === 0)
+            blockers.push(`research_review_artifact_empty:${artifact}`);
+        return {
+            artifact,
+            sha256: sha256(content),
+            bytes: content.length
+        };
+    }));
+    return {
+        schema: RESEARCH_REVIEW_DIGEST_SCHEMA,
+        generated_at: nowIso(),
+        artifacts: rows,
+        bundle_sha256: sha256(JSON.stringify(rows.map(({ artifact, sha256: digest, bytes }) => ({ artifact, sha256: digest, bytes })))),
+        blockers: [...new Set(blockers)]
+    };
+}
+export function validateResearchReviewArtifactDigest(recorded, current) {
+    const blockers = [];
+    if (recorded?.schema !== RESEARCH_REVIEW_DIGEST_SCHEMA)
+        blockers.push('research_review_artifact_digest_schema_invalid');
+    if (!String(recorded?.bundle_sha256 || '').trim())
+        blockers.push('research_review_artifact_bundle_sha256_missing');
+    if (String(recorded?.bundle_sha256 || '') !== current.bundle_sha256)
+        blockers.push('research_review_artifact_bundle_sha256_mismatch');
+    const recordedRows = new Map((Array.isArray(recorded?.artifacts) ? recorded.artifacts : [])
+        .map((row) => [String(row?.artifact || ''), row]));
+    for (const currentRow of current.artifacts) {
+        const recordedRow = recordedRows.get(currentRow.artifact);
+        if (!recordedRow) {
+            blockers.push(`research_review_artifact_digest_entry_missing:${currentRow.artifact}`);
+            continue;
+        }
+        if (String(recordedRow?.sha256 || '') !== String(currentRow.sha256 || '')) {
+            blockers.push(`research_review_artifact_sha256_mismatch:${currentRow.artifact}`);
+        }
+        if (Number(recordedRow?.bytes || 0) !== currentRow.bytes) {
+            blockers.push(`research_review_artifact_size_mismatch:${currentRow.artifact}`);
+        }
+    }
+    blockers.push(...current.blockers);
+    return [...new Set(blockers)];
+}
+export function researchReviewArtifactNames(plan) {
+    const configuredPaper = plan?.artifacts?.research_paper || plan?.paper_artifact || 'research-paper.md';
+    return [
+        'research-report.md',
+        path.basename(String(configuredPaper)),
+        'source-ledger.json',
+        'claim-evidence-matrix.json'
+    ];
+}
+//# sourceMappingURL=research-review-artifact-digest.js.map

package/dist/core/research/research-source-evidence.js

@@ -0,0 +1,144 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { sha256 } from '../fsx.js';
+export function trustworthyVerifiedResearchSource(source) {
+    return String(source?.acquisition_verdict || '') === 'verified_content'
+        && /^verified_content:/i.test(String(source?.credibility || ''))
+        && Boolean(String(source?.content_artifact || '').trim())
+        && /^[a-f0-9]{64}$/i.test(String(source?.content_sha256 || '').trim())
+        && Number(source?.content_length || 0) > 0
+        && source?.super_search_provenance?.validated === true;
+}
+export function explicitResearchFixtureSource(source) {
+    return /^(?:deterministic_fixture|mock|selftest(?:-|$))/i.test(String(source?.kind || ''));
+}
+export async function validateResearchSourceProvenance(dir, source) {
+    const sourceId = String(source?.id || source?.source_id || '').trim() || 'unknown';
+    const blockers = [];
+    if (String(source?.acquisition_verdict || '') !== 'verified_content')
+        blockers.push(`research_source_not_verified:${sourceId}`);
+    if (!/^verified_content:/i.test(String(source?.credibility || '')))
+        blockers.push(`research_source_credibility_unverified:${sourceId}`);
+    if (!String(source?.content_artifact || '').trim())
+        blockers.push(`research_source_content_artifact_missing:${sourceId}`);
+    if (!/^[a-f0-9]{64}$/i.test(String(source?.content_sha256 || '').trim()))
+        blockers.push(`research_source_content_sha_invalid:${sourceId}`);
+    if (!(Number(source?.content_length || 0) > 0))
+        blockers.push(`research_source_content_length_invalid:${sourceId}`);
+    const provenance = source?.super_search_provenance;
+    if (provenance?.schema !== 'sks.research-super-search-source-provenance.v1') {
+        blockers.push(`research_source_super_search_provenance_missing:${sourceId}`);
+        return { ok: false, blockers: unique(blockers) };
+    }
+    if (String(provenance?.source_id || '') !== sourceId)
+        blockers.push(`research_source_provenance_source_id_mismatch:${sourceId}`);
+    const proofPath = resolveMissionArtifact(dir, provenance?.proof_artifact);
+    const sourceLedgerPath = resolveMissionArtifact(dir, provenance?.source_ledger_artifact);
+    if (!proofPath)
+        blockers.push(`research_source_proof_path_invalid:${sourceId}`);
+    if (!sourceLedgerPath)
+        blockers.push(`research_source_ledger_path_invalid:${sourceId}`);
+    if (!proofPath || !sourceLedgerPath)
+        return { ok: false, blockers: unique(blockers) };
+    const [proofBytes, sourceLedgerBytes] = await Promise.all([
+        fsp.readFile(proofPath).catch(() => null),
+        fsp.readFile(sourceLedgerPath).catch(() => null)
+    ]);
+    if (!proofBytes)
+        blockers.push(`research_source_proof_missing:${sourceId}`);
+    if (!sourceLedgerBytes)
+        blockers.push(`research_source_ledger_missing:${sourceId}`);
+    if (!proofBytes || !sourceLedgerBytes)
+        return { ok: false, blockers: unique(blockers) };
+    const proofDigest = sha256(proofBytes);
+    const sourceLedgerDigest = sha256(sourceLedgerBytes);
+    if (!/^[a-f0-9]{64}$/i.test(String(provenance?.proof_sha256 || '')) || provenance.proof_sha256 !== proofDigest) {
+        blockers.push(`research_source_proof_digest_mismatch:${sourceId}`);
+    }
+    if (!/^[a-f0-9]{64}$/i.test(String(provenance?.source_ledger_sha256 || '')) || provenance.source_ledger_sha256 !== sourceLedgerDigest) {
+        blockers.push(`research_source_ledger_digest_mismatch:${sourceId}`);
+    }
+    const proof = parseJsonBuffer(proofBytes);
+    const sourceLedger = parseJsonBuffer(sourceLedgerBytes);
+    if (proof?.schema !== 'sks.super-search-proof.v1')
+        blockers.push(`research_source_proof_schema_invalid:${sourceId}`);
+    if (proof?.ok !== true || normalizedStrings(proof?.blockers).length > 0)
+        blockers.push(`research_source_proof_blocked:${sourceId}`);
+    if (sourceLedger?.schema !== 'sks.super-search-source-ledger.v1')
+        blockers.push(`research_source_ledger_schema_invalid:${sourceId}`);
+    const linkedSource = (Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : [])
+        .find((candidate) => String(candidate?.source_id || candidate?.id || '').trim() === sourceId);
+    if (!linkedSource) {
+        blockers.push(`research_source_not_in_super_search_ledger:${sourceId}`);
+        return { ok: false, blockers: unique(blockers) };
+    }
+    if (String(linkedSource?.acquisition_verdict || '') !== 'verified_content')
+        blockers.push(`research_source_linked_verdict_unverified:${sourceId}`);
+    if (String(linkedSource?.content_artifact || '') !== String(source?.content_artifact || ''))
+        blockers.push(`research_source_content_artifact_mismatch:${sourceId}`);
+    if (String(linkedSource?.content_sha256 || '') !== String(source?.content_sha256 || ''))
+        blockers.push(`research_source_content_sha_mismatch:${sourceId}`);
+    if (Number(linkedSource?.content_length || 0) !== Number(source?.content_length || 0))
+        blockers.push(`research_source_content_length_mismatch:${sourceId}`);
+    const contentPath = resolveChildArtifact(path.dirname(sourceLedgerPath), linkedSource?.content_artifact);
+    if (!contentPath) {
+        blockers.push(`research_source_hydrated_content_path_invalid:${sourceId}`);
+        return { ok: false, blockers: unique(blockers) };
+    }
+    const contentBytes = await fsp.readFile(contentPath).catch(() => null);
+    if (!contentBytes) {
+        blockers.push(`research_source_hydrated_content_missing:${sourceId}`);
+        return { ok: false, blockers: unique(blockers) };
+    }
+    if (sha256(contentBytes) !== String(linkedSource?.content_sha256 || ''))
+        blockers.push(`research_source_hydrated_content_sha_mismatch:${sourceId}`);
+    if (contentBytes.toString('utf8').length !== Number(linkedSource?.content_length || 0))
+        blockers.push(`research_source_hydrated_content_length_mismatch:${sourceId}`);
+    return { ok: blockers.length === 0, blockers: unique(blockers) };
+}
+export async function eligibleResearchSourceIdSet(dir, sourceLedger, executionClass) {
+    const rows = [
+        ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+    ];
+    if (executionClass === 'mock_fixture') {
+        return new Set(rows
+            .filter((source) => explicitResearchFixtureSource(source))
+            .map(sourceId)
+            .filter(Boolean));
+    }
+    const eligible = await Promise.all(rows.map(async (source) => {
+        const validation = await validateResearchSourceProvenance(dir, source);
+        return validation.ok ? sourceId(source) : '';
+    }));
+    return new Set(eligible.filter(Boolean));
+}
+function resolveMissionArtifact(dir, artifact) {
+    return resolveChildArtifact(path.resolve(dir), artifact);
+}
+function resolveChildArtifact(parent, artifact) {
+    const raw = String(artifact || '').trim();
+    if (!raw || path.isAbsolute(raw))
+        return null;
+    const root = path.resolve(parent);
+    const candidate = path.resolve(root, raw);
+    return candidate === root || candidate.startsWith(`${root}${path.sep}`) ? candidate : null;
+}
+function parseJsonBuffer(bytes) {
+    try {
+        return JSON.parse(bytes.toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function sourceId(source) {
+    return String(source?.id || source?.source_id || '').trim();
+}
+function normalizedStrings(value) {
+    return (Array.isArray(value) ? value : value == null ? [] : [value]).map(String).map((item) => item.trim()).filter(Boolean);
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+//# sourceMappingURL=research-source-evidence.js.map