sneakoscope 6.1.0 → 6.2.0

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-plan-markdown.js

@@ -0,0 +1,123 @@
+export function renderResearchPlanMarkdown(plan, helpers) {
+    const lines = [];
+    lines.push('# SKS Research Plan');
+    lines.push('');
+    lines.push(`Prompt: ${plan.prompt}`);
+    lines.push(`Depth: ${plan.depth}`);
+    lines.push(`Methodology: ${plan.methodology}`);
+    lines.push(`Research paper: ${helpers.researchPaperArtifactForPlan(plan)}`);
+    if (plan.codex_app_execution_profile) {
+        lines.push(`Execution profile: ${plan.codex_app_execution_profile.mode}; agent role strategy ${plan.codex_app_execution_profile.agent_role_strategy}`);
+    }
+    if (plan.execution_policy) {
+        lines.push(`Execution: ${plan.execution_policy.normal_run}; default cycle timeout ${plan.execution_policy.default_cycle_timeout_minutes} minutes`);
+        if (plan.execution_policy.default_max_cycles)
+            lines.push(`Adversarial review loop: run three independent official research_reviewer threads, revise on any objection, then run a fresh three-thread cycle; default safety cap ${plan.execution_policy.default_max_cycles} cycles`);
+        lines.push(`Mock policy: ${plan.execution_policy.mock_policy}`);
+    }
+    if (plan.mutation_policy)
+        lines.push(`Mutation policy: ${plan.mutation_policy.rule}`);
+    lines.push('');
+    if (plan.quality_contract) {
+        const contract = plan.quality_contract;
+        lines.push('## Quality Contract');
+        lines.push(`- minimum sources: ${contract.min_sources_total}`);
+        lines.push(`- minimum source layers covered: ${contract.min_source_layers_covered}`);
+        lines.push(`- minimum counterevidence sources: ${contract.min_counterevidence_sources}`);
+        lines.push(`- minimum key claims: ${contract.min_key_claims}`);
+        lines.push(`- minimum triangulated claims: ${contract.min_trianguled_claims}`);
+        lines.push(`- minimum blueprint sections: ${contract.min_implementation_blueprint_sections}`);
+        lines.push(`- minimum falsification cases: ${contract.min_falsification_cases}`);
+        lines.push(`- minimum experiment steps: ${contract.min_experiment_steps}`);
+        lines.push(`- minimum report words: ${contract.min_report_words}`);
+        lines.push('');
+    }
+    if (plan.native_agent_plan) {
+        lines.push('## Official Subagent Review Plan');
+        lines.push(`Backend: ${plan.native_agent_plan.backend}`);
+        lines.push(`Sessions: ${plan.native_agent_plan.session_count}`);
+        lines.push(`AutoResearch batches: ${plan.native_agent_plan.autoresearch_cycle_policy?.uses_agent_batches ? 'enabled' : 'disabled'}`);
+        for (const persona of plan.native_agent_plan.personas || []) {
+            lines.push(`- ${persona.id}: ${persona.role}; outputs ${(persona.outputs || []).join(', ')}`);
+        }
+        for (const batch of plan.native_agent_plan.batches || []) {
+            lines.push(`- batch ${batch.id}: ${(batch.agents || []).join(', ')} -> ${(batch.outputs || []).join(', ')}`);
+        }
+        lines.push('');
+    }
+    lines.push('## Rules');
+    for (const rule of plan.rules)
+        lines.push(`- ${rule}`);
+    lines.push('');
+    if (plan.research_council?.agents?.length) {
+        lines.push('## Genius Agent Council');
+        lines.push(`Policy: ${plan.research_council.policy}`);
+        for (const agent of plan.research_council.agents)
+            lines.push(`- ${helpers.researchAgentAgentName(agent)}: ${agent.persona || agent.role} - ${agent.mandate} (${agent.persona_boundary || 'persona-inspired lens only'})`);
+        lines.push('');
+    }
+    if (plan.web_research_policy) {
+        lines.push('## Web Research Policy');
+        lines.push(`Mode: ${plan.web_research_policy.mode}`);
+        lines.push(`Requirement: ${plan.web_research_policy.requirement}`);
+        if (plan.web_research_policy.source_tool_routing)
+            lines.push(`Source tool routing: ${plan.web_research_policy.source_tool_routing.mode}`);
+        for (const querySet of plan.web_research_policy.query_sets || [])
+            lines.push(`- query set: ${querySet}`);
+        if (plan.web_research_policy.skill_creator?.artifact)
+            lines.push(`- source skill artifact: ${plan.web_research_policy.skill_creator.artifact}`);
+        for (const layer of plan.web_research_policy.source_layers || []) {
+            lines.push(`- layer ${layer.id}: ${layer.purpose}`);
+        }
+        lines.push('');
+    }
+    lines.push('## Outcome Rubric');
+    for (const item of plan.outcome_rubric || [])
+        lines.push(`- ${item.id}: ${item.description}`);
+    lines.push('');
+    lines.push('## Phases');
+    for (const phase of plan.phases)
+        lines.push(`- ${phase.id}: ${phase.goal}`);
+    lines.push('');
+    lines.push('## Required Artifacts');
+    for (const artifact of plan.required_artifacts)
+        lines.push(`- ${artifact}`);
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+export function renderResearchSourceSkillMarkdown(plan, defaultLayers) {
+    const layers = plan?.web_research_policy?.source_layers?.length ? plan.web_research_policy.source_layers : defaultLayers;
+    const lines = [];
+    lines.push('# Research Source Layer Skill');
+    lines.push('');
+    lines.push('Status: route-local candidate skill. Use it inside this research mission before agent synthesis. Do not install or edit generated .agents/skills from this artifact.');
+    lines.push('Real-run policy: collect live sources for as long as needed within the mission timeout; mock or fixture evidence is valid only for explicit --mock selftests.');
+    lines.push('');
+    lines.push('## Trigger');
+    lines.push('- Any `$Research` run that must collect broad public evidence before synthesis, adversarial review, falsification, or paper writing.');
+    lines.push('');
+    lines.push('## Source Layers');
+    for (const layer of layers) {
+        lines.push(`- ${layer.id}: ${layer.purpose}`);
+        lines.push(`  Examples: ${(layer.examples || []).join(', ')}`);
+        lines.push(`  Query templates: ${(layer.query_templates || []).join(' | ')}`);
+    }
+    lines.push('');
+    lines.push('## Output Contract');
+    lines.push('- Fill source-ledger.json with `source_layers`, `sources[].layer`, `counterevidence_sources[].layer`, `citation_coverage`, `triangulation.cross_layer_checks`, and `blockers`.');
+    lines.push('- Each source entry should record title, locator/URL, publisher or author when known, published_at when known, accessed_at, layer, reliability, credibility, stance, supports or undermines, and notes.');
+    lines.push('- Public discourse sources such as X/Twitter or Reddit are signals and edge cases, not truth. They must be triangulated with formal, official, practitioner, or counterevidence layers.');
+    lines.push('- If a layer cannot be searched with the available runtime or credentials, record the blocker and keep research-gate.json unpassed.');
+    lines.push('- Do not modify repository source code or generated harness files during Research; write only route-local mission artifacts.');
+    lines.push('');
+    lines.push('## Official Reviewer Use');
+    lines.push('- Only source-ledger ids with correlated verified-content Super Search proof may support a real-run reviewer finding or Eureka idea.');
+    lines.push('- Run exactly three independent official `research_reviewer` threads on GPT-5.6 Sol Max: Einstein, von Neumann, and Skeptic composite lenses.');
+    lines.push('- The skeptic lens must challenge the strongest claim using counterevidence or source-quality downgrades.');
+    lines.push('- Any objection triggers a mission-local `research_synthesizer` revision followed by a fresh three-thread review cycle; do not launch a custom scheduler or debate pool.');
+    lines.push('- `agent-ledger.json` and `debate-ledger.json` are compatibility projections from official reviewer outcomes. Canonical convergence requires three trustworthy parent outcomes and zero unresolved objections.');
+    lines.push('- Synthesis keeps only claims that survive cross-layer triangulation and falsification.');
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+//# sourceMappingURL=research-plan-markdown.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