sneakoscope 6.1.0 → 6.2.0

package/dist/core/research/research-super-search.js

@@ -0,0 +1,188 @@
+import path from 'node:path';
+import { readJson, sha256 } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-task-runner.js';
+import { runSuperSearch } from '../super-search/index.js';
+import { TERRA_SUBAGENT_EFFORT, TERRA_SUBAGENT_MODEL } from '../subagents/model-policy.js';
+import {} from './research-source-shards.js';
+export const RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY = Object.freeze({
+    model: TERRA_SUBAGENT_MODEL,
+    model_reasoning_effort: TERRA_SUBAGENT_EFFORT
+});
+export async function runResearchSuperSearchShard(input) {
+    const missionId = String(input.plan?.mission_id || '');
+    const acquisitionDir = path.join(input.dir, 'research', `cycle-${input.cycle}`, 'source-acquisition', input.layer.id);
+    const sourceSearch = input.sourceSearch || createCodexSourceSearch(input);
+    const result = await runSuperSearch({
+        root: input.root,
+        missionDir: acquisitionDir,
+        missionId,
+        route: '$Research',
+        query: buildResearchLayerQuery(input.plan, input.layer),
+        mode: 'deep',
+        codexWebSearch: sourceSearch,
+        maxQueryVariants: 2,
+        maxHydratedSources: 4,
+        hardTimeoutMs: input.timeoutMs,
+        ...(input.deadlineMs === undefined ? {} : { deadlineEpochMs: input.deadlineMs }),
+        env: { ...process.env, SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' }
+    });
+    const sources = result.sources.map((source) => researchSourceRow(source, input.layer));
+    const verifiedEvidenceCandidates = sources.filter((source) => source.acquisition_verdict === 'verified_content').length;
+    const blockers = [
+        ...result.proof.blockers.map((blocker) => `super_search:${blocker}`),
+        ...(sources.length ? [] : ['super_search:source_rows_missing']),
+        ...(input.layer.id === 'counterevidence_factcheck' && verifiedEvidenceCandidates === 0
+            ? ['super_search:verified_counterevidence_candidate_missing']
+            : [])
+    ];
+    return {
+        schema: 'sks.research-source-shard-output.v1',
+        mission_id: missionId,
+        cycle: input.cycle,
+        layer_id: input.layer.id,
+        queries: result.query_variants.map((query) => ({
+            query,
+            rationale: `Super Search ${result.mode} acquisition for ${input.layer.label}.`
+        })),
+        sources,
+        blockers: [...new Set(blockers)],
+        super_search: {
+            schema: 'sks.research-super-search-link.v1',
+            result_artifact: path.relative(input.dir, path.join(result.artifact_dir, 'super-search-result.json')),
+            proof_artifact: path.relative(input.dir, path.join(result.artifact_dir, 'super-search-proof.json')),
+            source_ledger_artifact: path.relative(input.dir, path.join(result.artifact_dir, 'source-ledger.json')),
+            claim_ledger_artifact: path.relative(input.dir, path.join(result.artifact_dir, 'claim-ledger.json')),
+            proof_ok: result.proof.ok,
+            verified_sources: result.proof.verified_source_count,
+            provider_independent: result.proof.provider_independent,
+            verified_provider_families: result.proof.verified_provider_families,
+            verified_independence_clusters: result.proof.verified_independence_clusters,
+            query_execution: result.query_execution
+        }
+    };
+}
+export function buildResearchLayerQuery(plan, layer) {
+    const topic = String(plan?.prompt || 'research mission').trim();
+    const templates = layer.query_templates.slice(0, 3).map((query) => query.replace(/<topic>/g, topic));
+    return [
+        topic,
+        `Evidence layer: ${layer.label}.`,
+        layer.purpose,
+        `Prioritize primary or authoritative sources; preserve contrary evidence; never invent URLs. Suggested searches: ${templates.join(' | ')}`
+    ].join(' ');
+}
+function createCodexSourceSearch(input) {
+    return async (query) => {
+        const queryId = sha256(query).slice(0, 12);
+        const result = await runCodexTask({
+            route: '$Research',
+            tier: 'worker',
+            missionId: String(input.plan?.mission_id || 'research-source-acquisition'),
+            workItemId: `super_search_${input.layer.id}_${queryId}`,
+            cwd: input.root,
+            prompt: buildSourceSearchPrompt(input.plan, input.layer, query),
+            outputSchema: researchSourceSearchOutputSchema,
+            outputSchemaId: 'sks.research-source-search-output.v1',
+            sandboxPolicy: 'read-only',
+            requestedScopeContract: {
+                id: `research-super-search-${input.layer.id}`,
+                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: ['codex-sdk', 'python-codex-sdk'],
+            allowLocalLlm: false,
+            localLlmPolicy: { mode: 'disabled', requiresGptFinal: true },
+            mutationLedgerRoot: path.join(input.dir, 'research', `cycle-${input.cycle}`, 'super-search-codex-control', input.layer.id, queryId),
+            reliabilityPolicy: {
+                timeoutClass: 'standard',
+                idleTimeoutMs: input.timeoutMs,
+                hardTimeoutMs: input.timeoutMs,
+                ...(input.deadlineMs === undefined ? {} : { deadlineEpochMs: input.deadlineMs })
+            },
+            model: RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY.model,
+            reasoningEffort: RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY.model_reasoning_effort,
+            modelReasoningEffort: RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY.model_reasoning_effort,
+            serviceTier: 'fast'
+        });
+        const worker = await readJson(result.workerResultPath, null);
+        if (!result.ok || !worker)
+            return { results: [], blockers: result.blockers || ['research_source_search_failed'] };
+        return {
+            results: Array.isArray(worker.results) ? worker.results : [],
+            blockers: Array.isArray(worker.blockers) ? worker.blockers : []
+        };
+    };
+}
+function buildSourceSearchPrompt(plan, layer, query) {
+    return [
+        'Use current web/source search tools for one read-only Super Search acquisition query.',
+        `Mission: ${plan?.mission_id || 'unknown'}`,
+        `Research topic: ${plan?.prompt || ''}`,
+        `Layer: ${layer.id} (${layer.label})`,
+        `Query: ${query}`,
+        '',
+        'Return only JSON matching sks.research-source-search-output.v1.',
+        'Every result must contain an exact reachable http(s) URL, title, and source-grounded snippet.',
+        'Do not invent citations, URLs, dates, authors, or source text. If search is unavailable, return an empty results array and an explicit blocker.'
+    ].join('\n');
+}
+export function researchSourceRow(source, layer) {
+    const verified = source.acquisition_verdict === 'verified_content';
+    const evidenceText = [source.title, source.snippet].filter(Boolean).join(' ');
+    const sourceClaimId = `source-claim-${sha256([
+        source.canonical_url || source.original_url || source.source_id,
+        source.content_sha256 || '',
+        evidenceText.trim().toLowerCase()
+    ].join('\0')).slice(0, 16)}`;
+    return {
+        id: source.source_id,
+        layer: layer.id,
+        kind: source.source_type,
+        title: source.title,
+        locator: source.canonical_url || source.original_url || source.content_artifact || source.source_id,
+        publisher_or_author: source.author || source.domain || source.provider_id,
+        ...(source.published_at ? { published_at: source.published_at } : {}),
+        accessed_at: source.retrieved_at,
+        reliability: source.authority_tier === 'A0' || source.authority_tier === 'A1' ? 'high' : source.authority_tier === 'B' ? 'medium-high' : 'medium',
+        credibility: verified ? `verified_content:${source.trust_score.toFixed(2)}` : `${source.acquisition_verdict}:${source.trust_score.toFixed(2)}`,
+        stance: 'context',
+        claim_ids: [sourceClaimId],
+        content_artifact: source.content_artifact,
+        content_sha256: source.content_sha256,
+        content_length: source.content_length,
+        acquisition_verdict: source.acquisition_verdict,
+        domain: source.domain,
+        authority_tier: source.authority_tier,
+        primary_source: source.primary_source,
+        independence_cluster_id: source.independence_cluster_id,
+        notes: [
+            source.snippet.trim().slice(0, 900),
+            `Super Search provider=${source.provider_id}; authority=${source.authority_tier}; acquisition=${source.acquisition_verdict}; source_claim_id=${sourceClaimId}.`
+        ].filter(Boolean).join(' ')
+    };
+}
+export const researchSourceSearchOutputSchema = {
+    type: 'object',
+    required: ['schema', 'results', 'blockers'],
+    properties: {
+        schema: { const: 'sks.research-source-search-output.v1' },
+        results: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['title', 'url', 'snippet'],
+                properties: {
+                    title: { type: 'string' },
+                    url: { type: 'string' },
+                    snippet: { type: 'string' }
+                }
+            }
+        },
+        blockers: { type: 'array', items: { type: 'string' } }
+    }
+};
+//# sourceMappingURL=research-super-search.js.map

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

@@ -4,6 +4,8 @@ export function buildResearchSynthesisPrompt(input) {
         'Do not write a short summary.',
         'Do not pad with repeated paragraphs.',
         'Every key claim must cite source-ledger ids.',
+        'In the Key Claims section, write every key claim id and its actual claim text in one local paragraph or table row, with at least one source id linked to that same claim in claim-evidence-matrix.json.',
+        'A global References list does not satisfy claim coverage. Claim-local citations must appear beside the claim they support.',
         'Every recommendation must point to implementation-blueprint sections.',
         'Every limitation must point to falsification-ledger cases or source blockers.',
         'Return JSON only matching sks.research-synthesis-output.v1.',
@@ -27,15 +29,32 @@ function compactEvidencePack(input) {
         source_ids: sourceRows.map((source) => ({
             id: source.id,
             layer: source.layer,
+            kind: source.kind,
             title: source.title,
+            locator: source.locator,
+            publisher_or_author: source.publisher_or_author,
+            published_at: source.published_at || null,
+            accessed_at: source.accessed_at || null,
+            reliability: source.reliability,
+            credibility: source.credibility,
             stance: source.stance,
-            claim_ids: source.claim_ids || []
+            claim_ids: source.claim_ids || [],
+            notes: source.notes || '',
+            content_artifact: source.content_artifact || null,
+            content_sha256: source.content_sha256 || null,
+            content_length: source.content_length || null,
+            acquisition_verdict: source.acquisition_verdict || null,
+            domain: source.domain || null,
+            authority_tier: source.authority_tier || null,
+            primary_source: source.primary_source === true,
+            independence_cluster_id: source.independence_cluster_id || null
         })),
         key_claims: (Array.isArray(input.claimMatrix?.claims) ? input.claimMatrix.claims : []).map((claim) => ({
             id: claim.id,
             claim: claim.claim,
             source_ids: claim.source_ids || [],
             counterevidence_ids: claim.counterevidence_ids || [],
+            counterevidence_links: claim.counterevidence_links || [],
             test_or_probe: claim.test_or_probe || ''
         })),
         falsification_cases: Array.isArray(input.falsificationLedger?.cases) ? input.falsificationLedger.cases : [],

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

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { readJson, writeJsonAtomic, writeTextAtomic, nowIso } from '../fsx.js';
 import { runCodexTask } from '../codex-control/codex-task-runner.js';
 import { researchPaperArtifactForPlan } from '../research.js';
+import { THINKING_SUBAGENT_MODEL, SUBAGENT_EFFORT } from '../subagents/model-policy.js';
 import { analyzeResearchReportQuality, countWords } from './research-report-quality.js';
 import { analyzeResearchRepetition } from './research-repetition-detector.js';
 import { buildRealisticResearchPaper, buildRealisticResearchReport } from './research-realistic-report.js';
@@ -52,7 +53,7 @@ export async function runResearchCodexSynthesisWriter(input) {
     }
     const result = await runCodexTask({
         route: '$Research',
-        tier: 'worker',
+        tier: 'orchestrator',
         missionId: String(input.plan?.mission_id || 'research-synthesis'),
         workItemId: 'research_synthesis',
         cwd: input.root,
@@ -73,7 +74,16 @@ export async function runResearchCodexSynthesisWriter(input) {
         allowLocalLlm: false,
         localLlmPolicy: { mode: 'disabled', requiresGptFinal: true },
         mutationLedgerRoot: path.join(input.dir, 'research', 'synthesis-codex-control'),
-        reliabilityPolicy: { timeoutClass: 'standard', idleTimeoutMs: input.timeoutMs || 120000 }
+        reliabilityPolicy: {
+            timeoutClass: 'standard',
+            idleTimeoutMs: input.timeoutMs || 120000,
+            hardTimeoutMs: input.timeoutMs || 120000,
+            ...(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 output = normalizeResearchSynthesisOutput(worker);
@@ -127,7 +137,8 @@ export function validateResearchSynthesisOutput(output, contract = null, claimMa
     const report = output.report_markdown;
     const paper = output.paper_markdown;
     const sourceIdsCited = sourceIds.filter((id) => report.includes(id));
-    const keyClaimsCovered = keyClaims.filter((id) => report.includes(id) || claimSourceIds(claimMatrix, id).some((sourceId) => report.includes(sourceId)));
+    const claimCoverage = keyClaims.map((id) => claimLocalReportCoverage(report, claimMatrix, id));
+    const keyClaimsCovered = claimCoverage.filter((row) => row.ok).map((row) => row.claim_id);
     const paperSections = ['Abstract', 'Introduction', 'Methodology', 'Findings', 'Discussion', 'Limitations', 'Conclusion', 'References'];
     const blockers = [
         ...(output.schema === 'sks.research-synthesis-output.v1' ? [] : ['research_synthesis_schema_invalid']),
@@ -138,6 +149,9 @@ export function validateResearchSynthesisOutput(output, contract = null, claimMa
         ...reportQuality.blockers,
         ...repetition.blockers,
         ...(sourceIdsCited.length >= Math.min(8, sourceIds.length) ? [] : ['research_synthesis_unique_sources_below_contract']),
+        ...claimCoverage.filter((row) => !row.id_present).map((row) => `research_synthesis_key_claim_id_missing:${row.claim_id}`),
+        ...claimCoverage.filter((row) => !row.semantics_present).map((row) => `research_synthesis_key_claim_semantics_missing:${row.claim_id}`),
+        ...claimCoverage.filter((row) => !row.local_citation_present).map((row) => `research_synthesis_key_claim_local_citation_missing:${row.claim_id}`),
         ...(keyClaimsCovered.length >= Number(contract?.min_key_claims || 8) ? [] : ['research_synthesis_key_claims_below_contract']),
         ...(repetition.repeated_paragraph_ratio <= 0.18 ? [] : ['research_synthesis_repeated_paragraph_ratio_high']),
         ...(repetition.template_phrase_hits.length ? ['research_synthesis_template_phrase_hits'] : []),
@@ -146,6 +160,72 @@ export function validateResearchSynthesisOutput(output, contract = null, claimMa
     ];
     return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
 }
+function claimLocalReportCoverage(report, claimMatrix, claimId) {
+    const claim = (Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : []).find((row) => String(row?.id || '') === claimId);
+    const claimText = String(claim?.claim || '').trim();
+    const linkedSourceIds = normalizeStringList(claim?.source_ids);
+    const blocks = markdownSection(report, 'Key Claims').split(/\n\s*\n/).map((block) => block.trim()).filter(Boolean);
+    let idPresent = false;
+    let semanticsPresent = false;
+    let localCitationPresent = false;
+    for (const block of blocks) {
+        const hasId = block.includes(claimId);
+        const hasSemantics = semanticallyContainsClaim(block, claimText);
+        const hasLocalCitation = linkedSourceIds.some((sourceId) => block.includes(sourceId));
+        idPresent ||= hasId;
+        semanticsPresent ||= hasSemantics;
+        localCitationPresent ||= hasId && hasSemantics && hasLocalCitation;
+    }
+    return {
+        claim_id: claimId,
+        id_present: idPresent,
+        semantics_present: semanticsPresent,
+        local_citation_present: localCitationPresent,
+        ok: idPresent && semanticsPresent && localCitationPresent
+    };
+}
+function markdownSection(markdown, heading) {
+    const target = normalizeHeading(heading);
+    const lines = String(markdown || '').split(/\r?\n/);
+    const out = [];
+    let capture = false;
+    let level = 0;
+    for (const line of lines) {
+        const match = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+        if (match) {
+            const nextLevel = match[1]?.length || 0;
+            const normalized = normalizeHeading(match[2] || '');
+            if (capture && nextLevel <= level)
+                break;
+            if (!capture && normalized.includes(target)) {
+                capture = true;
+                level = nextLevel;
+            }
+            continue;
+        }
+        if (capture)
+            out.push(line);
+    }
+    return out.join('\n');
+}
+function semanticallyContainsClaim(block, claimText) {
+    const claimTokens = semanticTokens(claimText);
+    if (!claimTokens.length)
+        return false;
+    const blockTokens = new Set(semanticTokens(block));
+    const overlap = claimTokens.filter((token) => blockTokens.has(token)).length;
+    const minimumOverlap = claimTokens.length <= 2 ? claimTokens.length : claimTokens.length <= 5 ? 2 : 3;
+    const minimumCoverage = claimTokens.length <= 3 ? 1 : 0.3;
+    return overlap >= minimumOverlap && overlap / claimTokens.length >= minimumCoverage;
+}
+function semanticTokens(value) {
+    const stop = new Set(['about', 'after', 'before', 'been', 'being', 'could', 'evidence', 'finding', 'from', 'have', 'into', 'research', 'result', 'should', 'source', 'study', 'that', 'their', 'there', 'these', 'this', 'through', 'using', 'with']);
+    return normalizeStringList(String(value || '').toLowerCase().normalize('NFKC').match(/[\p{L}\p{N}]{4,}/gu) || [])
+        .filter((token) => !stop.has(token));
+}
+function normalizeHeading(value) {
+    return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
 async function readSynthesisInputs(dir) {
     return {
         sourceLedger: await readJson(path.join(dir, 'source-ledger.json'), null),
@@ -161,8 +241,9 @@ function mockResearchSynthesisOutput(plan, artifacts) {
     const claims = Array.isArray(artifacts.claimMatrix?.claims) ? artifacts.claimMatrix.claims : [];
     const sourceIds = sourceIdsFromLedger(artifacts.sourceLedger);
     const counterIds = counterevidenceIdsFromLedger(artifacts.sourceLedger);
-    const report = buildRealisticResearchReport({ plan, claims, sourceIds, counterevidenceIds: counterIds, blueprint: artifacts.implementationBlueprint, falsificationLedger: artifacts.falsificationLedger, experimentPlan: artifacts.experimentPlan, replicationPack: artifacts.replicationPack });
-    const paper = buildRealisticResearchPaper({ plan, claims, sourceIds, counterevidenceIds: counterIds });
+    const keyClaimIds = Array.isArray(artifacts.claimMatrix?.key_claim_ids) ? artifacts.claimMatrix.key_claim_ids.map(String) : [];
+    const report = buildRealisticResearchReport({ plan, claims, keyClaimIds, sourceIds, counterevidenceIds: counterIds, blueprint: artifacts.implementationBlueprint, falsificationLedger: artifacts.falsificationLedger, experimentPlan: artifacts.experimentPlan, replicationPack: artifacts.replicationPack });
+    const paper = buildRealisticResearchPaper({ plan, claims, keyClaimIds, sourceIds, counterevidenceIds: counterIds });
     return normalizeResearchSynthesisOutput({
         schema: 'sks.research-synthesis-output.v1',
         mission_id: String(plan?.mission_id || ''),

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

@@ -1,17 +1,9 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
-import { RESEARCH_SOURCE_LAYERS } from './research-source-shards.js';
+import { RESEARCH_AGENT_PERSONA_CONTRACT } from '../recallpulse/policy.js';
+import { RESEARCH_SOURCE_LAYERS } from './research-source-layer-catalog.js';
 export const RESEARCH_WORK_GRAPH_ARTIFACT = 'research-work-graph.json';
-export const REQUIRED_SOURCE_SHARD_IDS = Object.freeze([
-    'source_shard_academic_literature',
-    'source_shard_official_government_data',
-    'source_shard_standards_primary_docs',
-    'source_shard_news_current_events',
-    'source_shard_public_discourse',
-    'source_shard_developer_practitioner',
-    'source_shard_counterevidence_factcheck',
-    'source_shard_local_project_evidence'
-]);
+export const REQUIRED_SOURCE_SHARD_IDS = Object.freeze(RESEARCH_SOURCE_LAYERS.map((layer) => `source_shard_${layer.id}`));
 function researchStages() {
     const sourceShards = RESEARCH_SOURCE_LAYERS.map((layer) => ({
         id: `source_shard_${layer.id}`,
@@ -71,15 +63,27 @@ function researchStages() {
             kind: 'research',
             stage_kind: 'synthesis',
             dependencies: ['claim_matrix_build', 'falsification', 'implementation_blueprint', 'experiment_plan'],
-            outputs: ['research-report.md', 'research-paper.md', 'genius-opinion-summary.md', 'agent-ledger.json', 'debate-ledger.json', 'novelty-ledger.json']
+            outputs: ['research-report.md', 'research-paper.md', 'novelty-ledger.json']
         },
         {
             id: 'final_review',
-            title: 'Static plus Codex/GPT research final reviewer',
+            title: 'Static plus official-subagent adversarial review and bounded revision',
             kind: 'verification',
             stage_kind: 'final_review',
             dependencies: ['synthesis'],
-            outputs: ['research-final-review.static.json', 'research-final-review.codex.json', 'research-final-review.json']
+            outputs: [
+                'research-final-review.static.json',
+                'research-final-review.codex.json',
+                'research-final-review.json',
+                'research-adversarial-plan.json',
+                'research-adversarial-review.json',
+                'research-revision-ledger.json',
+                'research-adversarial-convergence.json',
+                'research-honest-mode.json',
+                'genius-opinion-summary.md',
+                'agent-ledger.json',
+                'debate-ledger.json'
+            ]
         },
         {
             id: 'verification',
@@ -116,7 +120,7 @@ function workItem(stage, index, allStages, plan = null) {
         lease_requirements: stage.outputs.map((artifact) => ({ path: `${missionPrefix}${artifact}`, kind: 'read' })),
         acceptance: { requires_patch_envelope: false, requires_verification: true, requires_gpt_final: stage.stage_kind === 'final_review' },
         owner: null,
-        allocation_reason: 'Stage-aware read-only research pipeline work graph with source-layer shard parallelism',
+        allocation_reason: 'Stage-aware read-only Research graph: Super Search source acquisition, evidence synthesis, and official-subagent adversarial convergence',
         allocation_score: 1,
         allocation_hints: { domains: [stage.kind], write_paths: [], read_only_paths: stage.outputs },
         lane: null,
@@ -132,14 +136,14 @@ function workItem(stage, index, allStages, plan = null) {
 }
 export function buildResearchWorkGraph(plan = null) {
     const stages = researchStages();
-    const requestedClones = Math.max(8, Number(plan?.native_agent_plan?.session_count || 0), RESEARCH_SOURCE_LAYERS.length);
+    const requestedReviewers = RESEARCH_AGENT_PERSONA_CONTRACT.length;
     const workItems = stages.map((stage, index) => workItem(stage, index, stages, plan));
     const sourceShardIds = workItems.filter((item) => item.stage_kind === 'source_shard').map((item) => item.id);
     const closeoutIds = workItems.filter((item) => item.stage_kind !== 'source_shard').map((item) => item.id);
     return {
         schema: 'sks.naruto-work-graph.v1',
         route: '$Naruto',
-        requested_clones: requestedClones,
+        requested_clones: requestedReviewers,
         total_work_items: workItems.length,
         readonly: true,
         write_capable: false,
@@ -152,7 +156,10 @@ export function buildResearchWorkGraph(plan = null) {
         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
+        ok: true,
+        official_subagent_workflow: true,
+        official_subagent_reviewer_count: requestedReviewers,
+        legacy_process_swarm_used: false
     };
 }
 export async function writeResearchWorkGraph(dir, plan = null) {

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

@@ -26,6 +26,11 @@ function sourceRows(sourceLedger = null) {
 function missingFields(row) {
     return REQUIRED_SOURCE_FIELDS.filter((field) => {
         const value = row?.[field];
+        if (field === 'claim_ids') {
+            if (!Array.isArray(value))
+                return true;
+            return ['supports', 'undermines'].includes(String(row?.stance || '')) && value.length === 0;
+        }
         if (Array.isArray(value))
             return value.length === 0;
         return value === undefined || value === null || String(value).trim() === '';
@@ -54,8 +59,14 @@ export function buildSourceQualityReport(sourceLedger = null, claimMatrix = null
     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 untrustedClaimLinks = rows.flatMap((row) => {
+        const linked = asArray(row?.supports).length > 0 || asArray(row?.undermines).length > 0;
+        return linked && !trustedLinkedEvidence(row) ? [`source_claim_link_untrusted:${String(row?.id || 'unknown')}`] : [];
+    });
     const blockers = [
         ...rowReports.flatMap((row) => row.ok ? [] : [`source_metadata_incomplete:${row.id || 'unknown'}`]),
+        ...asArray(sourceLedger?.claim_link_blockers).map(String),
+        ...untrustedClaimLinks,
         ...(keyClaimIds.length && uncitedKeyClaimIds.length ? ['key_claim_citation_coverage_incomplete'] : []),
         ...(sourceLedger?.citation_coverage?.all_key_claims_cited === false ? ['source_ledger_reports_uncited_key_claims'] : [])
     ];
@@ -83,6 +94,16 @@ export function buildSourceQualityReport(sourceLedger = null, claimMatrix = null
         sources: rowReports
     };
 }
+function trustedLinkedEvidence(row) {
+    if (/^(?:deterministic_fixture|mock|selftest(?:-|$))/i.test(String(row?.kind || '')))
+        return true;
+    return String(row?.acquisition_verdict || '') === 'verified_content'
+        && /^verified_content:/i.test(String(row?.credibility || ''))
+        && Boolean(String(row?.content_artifact || '').trim())
+        && /^[a-f0-9]{64}$/i.test(String(row?.content_sha256 || '').trim())
+        && Number(row?.content_length || 0) > 0
+        && row?.super_search_provenance?.validated === true;
+}
 export async function readSourceQualityReport(dir) {
     return readJson(path.join(dir, SOURCE_QUALITY_REPORT_ARTIFACT), null);
 }