sneakoscope 6.0.3 → 6.1.2

package/dist/core/research/research-source-layer-catalog.js

@@ -0,0 +1,68 @@
+export const RESEARCH_SOURCE_LAYERS = Object.freeze([
+    {
+        id: 'academic_literature',
+        label: 'Academic literature',
+        purpose: 'Find papers, preprints, reviews, citations, and archival scholarly evidence before synthesis.',
+        evidence_role: 'formal_evidence',
+        examples: ['arXiv', 'Semantic Scholar', 'OpenAlex', 'Crossref', 'PubMed'],
+        query_templates: ['"<topic>" arxiv', '"<topic>" Semantic Scholar', '"<topic>" OpenAlex Crossref PubMed']
+    },
+    {
+        id: 'official_government_data',
+        label: 'Official government data',
+        purpose: 'Ground claims in public datasets, policy papers, national statistics, and leading-institution sources.',
+        evidence_role: 'authoritative_baseline',
+        examples: ['World Bank', 'OECD', 'Eurostat', 'data.gov', 'NIST'],
+        query_templates: ['"<topic>" site:worldbank.org OR site:oecd.org', '"<topic>" site:data.gov', '"<topic>" site:nist.gov']
+    },
+    {
+        id: 'standards_primary_docs',
+        label: 'Standards and primary documents',
+        purpose: 'Check specifications, standards, RFCs, policy originals, and official project documents before relying on summaries.',
+        evidence_role: 'primary_source',
+        examples: ['IETF RFCs', 'W3C', 'ISO abstracts', 'official standards bodies'],
+        query_templates: ['"<topic>" RFC standard specification', '"<topic>" W3C IETF NIST standard', '"<topic>" official specification']
+    },
+    {
+        id: 'news_current_events',
+        label: 'News and current events',
+        purpose: 'Capture recent events, public impact, and regional framing from reputable news and current-event indices.',
+        evidence_role: 'recency_signal',
+        examples: ['GDELT', 'BBC', 'Reuters', 'AP', 'regional reputable outlets'],
+        query_templates: ['"<topic>" latest Reuters AP', '"<topic>" GDELT news', '"<topic>" BBC analysis']
+    },
+    {
+        id: 'public_discourse',
+        label: 'Public discourse',
+        purpose: 'Sample public practitioner and community discourse without treating popularity as truth.',
+        evidence_role: 'sentiment_and_edge_cases',
+        examples: ['X/Twitter', 'Reddit', 'Hacker News', 'public forums'],
+        query_templates: ['"<topic>" site:x.com OR site:twitter.com', '"<topic>" site:reddit.com', '"<topic>" "Hacker News"']
+    },
+    {
+        id: 'developer_practitioner',
+        label: 'Developer and practitioner knowledge',
+        purpose: 'Find implementation pitfalls, developer questions, bug reports, and operational lessons.',
+        evidence_role: 'practice_feedback',
+        examples: ['Stack Overflow', 'Stack Exchange', 'GitHub issues', 'release notes', 'engineering blogs'],
+        query_templates: ['"<topic>" site:stackoverflow.com', '"<topic>" site:stackexchange.com', '"<topic>" site:github.com issues']
+    },
+    {
+        id: 'counterevidence_factcheck',
+        label: 'Counterevidence and fact checking',
+        purpose: 'Actively search for failures, critiques, null results, retractions, fact checks, and source conflicts.',
+        evidence_role: 'falsification',
+        examples: ['Fact checks', 'Retraction Watch', 'critical reviews', 'benchmark failures', 'negative results'],
+        query_templates: ['"<topic>" critique failure limitation', '"<topic>" fact check retraction', '"<topic>" counterevidence null result']
+    },
+    {
+        id: 'local_project_evidence',
+        label: 'Local project evidence',
+        purpose: 'Inspect repository-local files, scripts, docs, schemas, and tests as implementation evidence for handoff.',
+        evidence_role: 'local_evidence',
+        examples: ['git ls-files', 'package scripts', 'source modules', 'docs', 'schemas'],
+        query_templates: ['git ls-files', 'rg "<topic>" src docs schemas package.json']
+    }
+]);
+export const RESEARCH_SOURCE_LAYER_IDS = Object.freeze(RESEARCH_SOURCE_LAYERS.map((layer) => layer.id));
+//# sourceMappingURL=research-source-layer-catalog.js.map

package/dist/core/research/research-source-ledger-merge.js

@@ -1,23 +1,33 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
 import { writeSourceQualityReport } from './source-quality-report.js';
+import { validateResearchSourceProvenance } from './research-source-evidence.js';
 import { RESEARCH_SOURCE_LAYERS, validateResearchSourceShardOutput } from './research-source-shards.js';
 export async function mergeResearchSourceShards(input) {
     const shardDir = path.join(input.dir, 'research', `cycle-${input.cycle}`, 'source-shards');
     const shardFiles = await listJsonFiles(shardDir);
     const shardOutputs = [];
+    const superSearchRuns = [];
     const blockers = [];
     for (const file of shardFiles) {
         const shard = await readJson(file, null);
         const validation = validateResearchSourceShardOutput(shard);
         if (!validation.ok)
             blockers.push(...validation.blockers.map((blocker) => `${path.basename(file)}:${blocker}`));
-        shardOutputs.push(shard);
+        const materialized = await materializeShardSuperSearchProvenance(input.dir, shard);
+        blockers.push(...materialized.blockers.map((blocker) => `${path.basename(file)}:${blocker}`));
+        shardOutputs.push(materialized.shard);
+        if (materialized.run)
+            superSearchRuns.push(materialized.run);
     }
     const requiredLayers = sourceLayersForPlan(input.plan);
     const rows = dedupeSources(shardOutputs.flatMap((shard) => Array.isArray(shard?.sources) ? shard.sources : []));
-    const counterRows = rows.filter((row) => row.layer === 'counterevidence_factcheck' || row.stance === 'undermines');
+    const counterCandidates = rows.filter((row) => row.stance === 'undermines');
+    const unstructuredCounterRows = counterCandidates.filter((row) => !structuredCounterevidence(row));
+    blockers.push(...unstructuredCounterRows.map((row) => `counterevidence_link_unstructured:${row.id || 'unknown'}`));
+    const counterRows = counterCandidates.filter((row) => structuredCounterevidence(row));
+    const counterRowIds = new Set(counterRows.map((row) => String(row.id || '')));
     const primaryRows = rows.filter((row) => !counterRows.some((counter) => counter.id === row.id));
     const coveredLayers = [...new Set(rows.map((row) => String(row.layer || '')).filter(Boolean))];
     const missingLayers = requiredLayers.map((layer) => layer.id).filter((id) => !coveredLayers.includes(id));
@@ -38,9 +48,10 @@ export async function mergeResearchSourceShards(input) {
             status: 'created'
         },
         web_search_passes: shardOutputs.length ? 1 : 0,
+        super_search_runs: superSearchRuns,
         source_layers: requiredLayers.map((layer) => {
-            const sourceIds = rows.filter((row) => row.layer === layer.id && row.stance !== 'undermines').map((row) => row.id);
-            const counterIds = rows.filter((row) => row.layer === layer.id && row.stance === 'undermines').map((row) => row.id);
+            const sourceIds = rows.filter((row) => row.layer === layer.id && !counterRowIds.has(String(row.id || ''))).map((row) => row.id);
+            const counterIds = rows.filter((row) => row.layer === layer.id && counterRowIds.has(String(row.id || ''))).map((row) => row.id);
             return {
                 id: layer.id,
                 label: layer.label,
@@ -90,6 +101,183 @@ export async function mergeResearchSourceShards(input) {
         blockers: [...new Set(blockers)]
     };
 }
+export function linkSourceLedgerToClaimMatrix(sourceLedger, claimMatrix) {
+    const claims = Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : [];
+    const keyClaimIds = Array.isArray(claimMatrix?.key_claim_ids) ? claimMatrix.key_claim_ids.map(String) : [];
+    const originalSources = Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : [];
+    const originalCounterSources = Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [];
+    const originalCounterIds = new Set(originalCounterSources.map((source) => String(source?.id || '')).filter(Boolean));
+    const sourceRowsById = new Map([...originalSources, ...originalCounterSources]
+        .map((source) => [String(source?.id || ''), source]));
+    const sourceToClaims = new Map();
+    const linkBlockers = [];
+    for (const claim of claims) {
+        const claimId = String(claim?.id || '').trim();
+        if (!claimId)
+            continue;
+        for (const sourceId of normalizeStringList(claim?.source_ids)) {
+            const source = sourceRowsById.get(sourceId);
+            if (!source || !supportLinkAllowed(source, originalCounterIds.has(sourceId))) {
+                linkBlockers.push(`claim_support_source_untrusted:${claimId}:${sourceId}`);
+                continue;
+            }
+            const row = sourceToClaims.get(sourceId) || { supports: [], undermines: [], contradiction_rationales: [] };
+            row.supports.push(claimId);
+            sourceToClaims.set(sourceId, row);
+        }
+        for (const sourceId of normalizeStringList(claim?.counterevidence_ids)) {
+            const source = sourceRowsById.get(sourceId);
+            const structuredLink = (Array.isArray(claim?.counterevidence_links) ? claim.counterevidence_links : [])
+                .find((link) => String(link?.source_id || '') === sourceId && String(link?.target_claim_id || '') === claimId && String(link?.contradiction_rationale || '').trim());
+            if (!source || !structuredLink || !counterevidenceLinkAllowed(source)) {
+                linkBlockers.push(`claim_counterevidence_source_untrusted:${claimId}:${sourceId}`);
+                continue;
+            }
+            const row = sourceToClaims.get(sourceId) || { supports: [], undermines: [], contradiction_rationales: [] };
+            row.undermines.push(claimId);
+            row.contradiction_rationales.push(String(structuredLink.contradiction_rationale).trim());
+            sourceToClaims.set(sourceId, row);
+        }
+    }
+    const link = (source) => {
+        const mapped = sourceToClaims.get(String(source?.id || '')) || { supports: [], undermines: [], contradiction_rationales: [] };
+        const semanticCounterTargets = [...new Set(mapped.undermines)];
+        return {
+            ...source,
+            stance: semanticCounterTargets.length ? 'undermines' : source?.stance || 'context',
+            discovery_claim_ids: normalizeStringList(source?.discovery_claim_ids || source?.claim_ids),
+            supports: [...new Set(mapped.supports)],
+            undermines: semanticCounterTargets,
+            claim_ids: [...new Set([...mapped.supports, ...mapped.undermines])],
+            ...(semanticCounterTargets.length ? {
+                counterevidence_target_claim_id: semanticCounterTargets[0],
+                counterevidence_target_claim_ids: semanticCounterTargets,
+                contradiction_rationale: [
+                    ...mapped.contradiction_rationales,
+                    `Validated semantic claim synthesis links this source against ${semanticCounterTargets.join(', ')}.`
+                ].filter(Boolean).join(' ')
+            } : {}),
+            semantic_claim_linked: mapped.supports.length > 0 || mapped.undermines.length > 0
+        };
+    };
+    const rows = [
+        ...originalSources,
+        ...originalCounterSources
+    ].map(link);
+    const semanticCounterIds = new Set(rows.filter((row) => normalizeStringList(row?.undermines).length > 0).map((row) => String(row?.id || '')));
+    const counterevidenceSources = rows.filter((row) => semanticCounterIds.has(String(row?.id || '')));
+    const sources = rows.filter((row) => !semanticCounterIds.has(String(row?.id || '')));
+    const sourceLayers = (Array.isArray(sourceLedger?.source_layers) ? sourceLedger.source_layers : []).map((layer) => {
+        const layerRows = rows.filter((row) => row.layer === layer.id);
+        return {
+            ...layer,
+            source_ids: layerRows.filter((row) => !semanticCounterIds.has(String(row?.id || ''))).map((row) => row.id),
+            counterevidence_ids: layerRows.filter((row) => semanticCounterIds.has(String(row?.id || ''))).map((row) => row.id)
+        };
+    });
+    return {
+        ...sourceLedger,
+        sources,
+        counterevidence_sources: counterevidenceSources,
+        source_layers: sourceLayers,
+        claim_link_blockers: [...new Set(linkBlockers)],
+        triangulation: {
+            ...(sourceLedger?.triangulation || {}),
+            cross_layer_checks: buildCrossLayerChecks(rows),
+            conflicts: counterevidenceSources.flatMap((row) => normalizeStringList(row.claim_ids).map((claimId) => ({
+                id: `conflict-${row.id}-${claimId}`,
+                source_id: row.id,
+                claim_ids: [claimId],
+                notes: row.notes || ''
+            }))),
+            synthesis_notes: ['Semantic claim links were rebuilt from the validated claim-evidence matrix.']
+        },
+        citation_coverage: buildCitationCoverage(rows, keyClaimIds)
+    };
+}
+async function materializeShardSuperSearchProvenance(dir, shard) {
+    const sources = Array.isArray(shard?.sources) ? shard.sources : [];
+    const verifiedSources = sources.filter((source) => String(source?.acquisition_verdict || '') === 'verified_content');
+    const link = shard?.super_search;
+    if (link?.schema !== 'sks.research-super-search-link.v1') {
+        return {
+            shard,
+            run: null,
+            blockers: verifiedSources.map((source) => `super_search_provenance_missing:${String(source?.id || 'unknown')}`)
+        };
+    }
+    const [proofArtifact, sourceLedgerArtifact] = await Promise.all([
+        readMissionArtifact(dir, link.proof_artifact),
+        readMissionArtifact(dir, link.source_ledger_artifact)
+    ]);
+    const shared = {
+        schema: 'sks.research-super-search-source-provenance.v1',
+        layer_id: String(shard?.layer_id || ''),
+        proof_artifact: String(link?.proof_artifact || ''),
+        proof_sha256: proofArtifact?.sha256 || null,
+        source_ledger_artifact: String(link?.source_ledger_artifact || ''),
+        source_ledger_sha256: sourceLedgerArtifact?.sha256 || null
+    };
+    const validationBlockers = [];
+    const enrichedSources = await Promise.all(sources.map(async (source) => {
+        const provenance = {
+            ...shared,
+            source_id: String(source?.id || source?.source_id || ''),
+            validated: false,
+            blockers: []
+        };
+        const enriched = { ...source, super_search_provenance: provenance };
+        const validation = await validateResearchSourceProvenance(dir, enriched);
+        provenance.validated = validation.ok;
+        provenance.blockers = validation.blockers;
+        if (String(source?.acquisition_verdict || '') === 'verified_content' && !validation.ok)
+            validationBlockers.push(...validation.blockers);
+        return enriched;
+    }));
+    const verifiedSourceIds = enrichedSources
+        .filter((source) => source?.super_search_provenance?.validated === true)
+        .map((source) => String(source?.id || source?.source_id || ''))
+        .filter(Boolean);
+    const run = {
+        schema: 'sks.research-super-search-run-provenance.v1',
+        layer_id: shared.layer_id,
+        proof_artifact: shared.proof_artifact,
+        proof_sha256: shared.proof_sha256,
+        source_ledger_artifact: shared.source_ledger_artifact,
+        source_ledger_sha256: shared.source_ledger_sha256,
+        proof_ok: proofArtifact?.json?.schema === 'sks.super-search-proof.v1'
+            && proofArtifact.json.ok === true
+            && normalizeStringList(proofArtifact.json.blockers).length === 0,
+        verified_source_ids: verifiedSourceIds,
+        validated: verifiedSources.length > 0 && verifiedSourceIds.length === verifiedSources.length && validationBlockers.length === 0,
+        blockers: [...new Set(validationBlockers)]
+    };
+    return {
+        shard: { ...shard, sources: enrichedSources },
+        run,
+        blockers: run.blockers
+    };
+}
+async function readMissionArtifact(dir, artifact) {
+    const raw = String(artifact || '').trim();
+    if (!raw || path.isAbsolute(raw))
+        return null;
+    const root = path.resolve(dir);
+    const resolved = path.resolve(root, raw);
+    if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`))
+        return null;
+    const bytes = await fsp.readFile(resolved).catch(() => null);
+    if (!bytes)
+        return null;
+    let json = null;
+    try {
+        json = JSON.parse(bytes.toString('utf8'));
+    }
+    catch {
+        json = null;
+    }
+    return { sha256: sha256(bytes), json };
+}
 async function listJsonFiles(dir) {
     try {
         const entries = await fsp.readdir(dir, { withFileTypes: true });
@@ -122,6 +310,12 @@ function dedupeSources(rows) {
         if (existing) {
             existing.claim_ids = [...new Set([...(existing.claim_ids || []), ...(normalized.claim_ids || [])])];
             existing.notes = [existing.notes, normalized.notes].filter(Boolean).join('\n');
+            existing.counterevidence_target_claim_id ||= normalized.counterevidence_target_claim_id;
+            existing.counterevidence_target_claim_ids = [...new Set([...(existing.counterevidence_target_claim_ids || []), ...(normalized.counterevidence_target_claim_ids || [])])];
+            existing.contradiction_rationale ||= normalized.contradiction_rationale;
+            if (normalized.super_search_provenance?.validated === true && existing.super_search_provenance?.validated !== true) {
+                existing.super_search_provenance = normalized.super_search_provenance;
+            }
             byKey.set(existing.id, existing);
             byKey.set(key, existing);
         }
@@ -148,12 +342,53 @@ function normalizeSourceRow(row) {
         supports: normalizeStringList(row?.supports),
         undermines: normalizeStringList(row?.undermines),
         claim_ids: normalizeStringList(row?.claim_ids),
-        notes: String(row?.notes || '').trim()
+        counterevidence_target_claim_id: row?.counterevidence_target_claim_id ? String(row.counterevidence_target_claim_id).trim() : null,
+        counterevidence_target_claim_ids: normalizeStringList(row?.counterevidence_target_claim_ids),
+        contradiction_rationale: row?.contradiction_rationale ? String(row.contradiction_rationale).trim() : null,
+        notes: String(row?.notes || '').trim(),
+        semantic_claim_linked: row?.semantic_claim_linked === true,
+        content_artifact: row?.content_artifact ? String(row.content_artifact) : null,
+        content_sha256: row?.content_sha256 ? String(row.content_sha256) : null,
+        content_length: Number.isFinite(Number(row?.content_length)) ? Number(row.content_length) : null,
+        acquisition_verdict: row?.acquisition_verdict ? String(row.acquisition_verdict) : null,
+        domain: row?.domain ? String(row.domain) : null,
+        authority_tier: row?.authority_tier ? String(row.authority_tier) : null,
+        primary_source: row?.primary_source === true,
+        independence_cluster_id: row?.independence_cluster_id ? String(row.independence_cluster_id) : null,
+        super_search_provenance: row?.super_search_provenance && typeof row.super_search_provenance === 'object'
+            ? { ...row.super_search_provenance }
+            : null
     };
 }
+function fixtureEvidence(source) {
+    return /^(?:deterministic_fixture|mock|selftest(?:-|$))/i.test(String(source?.kind || ''));
+}
+function verifiedEvidence(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;
+}
+function supportLinkAllowed(source, isCounterSource) {
+    return !isCounterSource && source?.stance !== 'undermines' && (verifiedEvidence(source) || fixtureEvidence(source));
+}
+function counterevidenceLinkAllowed(source) {
+    return verifiedEvidence(source) || fixtureEvidence(source);
+}
+function structuredCounterevidence(source) {
+    const targetClaimIds = normalizeStringList([
+        ...normalizeStringList(source?.counterevidence_target_claim_ids),
+        source?.counterevidence_target_claim_id
+    ]);
+    return targetClaimIds.length > 0 && String(source?.contradiction_rationale || '').trim().length >= 16;
+}
 function buildCrossLayerChecks(rows) {
     const byClaim = new Map();
     for (const row of rows) {
+        if (row.semantic_claim_linked !== true && !/^(?:deterministic_fixture|selftest|mock)$/i.test(String(row.kind || '')))
+            continue;
         for (const claimId of normalizeStringList(row.claim_ids)) {
             const current = byClaim.get(claimId) || [];
             current.push(row);
@@ -165,19 +400,22 @@ function buildCrossLayerChecks(rows) {
         claim: claimId,
         source_ids: claimRows.map((row) => row.id),
         layers: [...new Set(claimRows.map((row) => row.layer))],
-        result: 'cross_layer_evidence_recorded'
+        result: 'semantic_cross_layer_evidence_recorded'
     }));
 }
-function buildCitationCoverage(rows) {
+function buildCitationCoverage(rows, keyClaimIds = []) {
     const cited = [...new Set(rows.flatMap((row) => normalizeStringList(row.claim_ids)))];
     const sourceClaimMap = Object.fromEntries(rows.map((row) => [row.id, normalizeStringList(row.claim_ids)]));
+    const keys = [...new Set(keyClaimIds.filter(Boolean))];
     return {
-        all_key_claims_cited: cited.length >= 8,
-        key_claim_ids: cited.slice(0, 8),
+        all_key_claims_cited: keys.length > 0 && keys.every((claimId) => cited.includes(claimId)),
+        key_claim_ids: keys,
         cited_claim_ids: cited,
-        uncited_claim_ids: [],
+        uncited_claim_ids: keys.filter((claimId) => !cited.includes(claimId)),
         source_claim_map: sourceClaimMap,
-        notes: ['Citation coverage was built from source shard claim_ids.']
+        notes: keys.length
+            ? ['Citation coverage was rebuilt from the validated claim-evidence matrix.']
+            : ['Source discovery rows are not treated as cited key claims until semantic claim synthesis completes.']
     };
 }
 function normalizeStringList(value) {

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

@@ -1,70 +1,6 @@
 import { nowIso } from '../fsx.js';
-export const RESEARCH_SOURCE_LAYERS = Object.freeze([
-    {
-        id: 'academic_literature',
-        label: 'Academic literature',
-        purpose: 'Find papers, preprints, reviews, citations, and archival scholarly evidence before synthesis.',
-        evidence_role: 'formal_evidence',
-        examples: ['arXiv', 'Semantic Scholar', 'OpenAlex', 'Crossref', 'PubMed'],
-        query_templates: ['"<topic>" arxiv', '"<topic>" Semantic Scholar', '"<topic>" OpenAlex Crossref PubMed']
-    },
-    {
-        id: 'official_government_data',
-        label: 'Official government data',
-        purpose: 'Ground claims in public datasets, policy papers, national statistics, and leading-institution sources.',
-        evidence_role: 'authoritative_baseline',
-        examples: ['World Bank', 'OECD', 'Eurostat', 'data.gov', 'NIST'],
-        query_templates: ['"<topic>" site:worldbank.org OR site:oecd.org', '"<topic>" site:data.gov', '"<topic>" site:nist.gov']
-    },
-    {
-        id: 'standards_primary_docs',
-        label: 'Standards and primary documents',
-        purpose: 'Check specifications, standards, RFCs, policy originals, and official project documents before relying on summaries.',
-        evidence_role: 'primary_source',
-        examples: ['IETF RFCs', 'W3C', 'ISO abstracts', 'official standards bodies'],
-        query_templates: ['"<topic>" RFC standard specification', '"<topic>" W3C IETF NIST standard', '"<topic>" official specification']
-    },
-    {
-        id: 'news_current_events',
-        label: 'News and current events',
-        purpose: 'Capture recent events, public impact, and regional framing from reputable news and current-event indices.',
-        evidence_role: 'recency_signal',
-        examples: ['GDELT', 'BBC', 'Reuters', 'AP', 'regional reputable outlets'],
-        query_templates: ['"<topic>" latest Reuters AP', '"<topic>" GDELT news', '"<topic>" BBC analysis']
-    },
-    {
-        id: 'public_discourse',
-        label: 'Public discourse',
-        purpose: 'Sample public practitioner and community discourse without treating popularity as truth.',
-        evidence_role: 'sentiment_and_edge_cases',
-        examples: ['X/Twitter', 'Reddit', 'Hacker News', 'public forums'],
-        query_templates: ['"<topic>" site:x.com OR site:twitter.com', '"<topic>" site:reddit.com', '"<topic>" "Hacker News"']
-    },
-    {
-        id: 'developer_practitioner',
-        label: 'Developer and practitioner knowledge',
-        purpose: 'Find implementation pitfalls, developer questions, bug reports, and operational lessons.',
-        evidence_role: 'practice_feedback',
-        examples: ['Stack Overflow', 'Stack Exchange', 'GitHub issues', 'release notes', 'engineering blogs'],
-        query_templates: ['"<topic>" site:stackoverflow.com', '"<topic>" site:stackexchange.com', '"<topic>" site:github.com issues']
-    },
-    {
-        id: 'counterevidence_factcheck',
-        label: 'Counterevidence and fact checking',
-        purpose: 'Actively search for failures, critiques, null results, retractions, fact checks, and source conflicts.',
-        evidence_role: 'falsification',
-        examples: ['Fact checks', 'Retraction Watch', 'critical reviews', 'benchmark failures', 'negative results'],
-        query_templates: ['"<topic>" critique failure limitation', '"<topic>" fact check retraction', '"<topic>" counterevidence null result']
-    },
-    {
-        id: 'local_project_evidence',
-        label: 'Local project evidence',
-        purpose: 'Inspect repository-local files, scripts, docs, schemas, and tests as implementation evidence for handoff.',
-        evidence_role: 'local_evidence',
-        examples: ['git ls-files', 'package scripts', 'source modules', 'docs', 'schemas'],
-        query_templates: ['git ls-files', 'rg "<topic>" src docs schemas package.json']
-    }
-]);
+import { RESEARCH_SOURCE_LAYERS } from './research-source-layer-catalog.js';
+export { RESEARCH_SOURCE_LAYERS } from './research-source-layer-catalog.js';
 export function researchSourceLayerById(id) {
     return RESEARCH_SOURCE_LAYERS.find((layer) => layer.id === id) || RESEARCH_SOURCE_LAYERS[0];
 }
@@ -93,7 +29,7 @@ export function defaultResearchSourceShardOutput(plan, layer, cycle = 1) {
     const secondaryClaimIds = layer.id === 'counterevidence_factcheck'
         ? ['stage-claim-1', 'stage-claim-2', 'stage-claim-8']
         : layer.id === 'local_project_evidence' ? [secondClaim, 'stage-claim-7', 'stage-claim-8'] : [secondClaim];
-    const stance = layer.id === 'counterevidence_factcheck' ? 'undermines' : layer.id === 'local_project_evidence' ? 'context' : 'supports';
+    const stance = layer.id === 'counterevidence_factcheck' ? 'undermines' : 'supports';
     return {
         schema: 'sks.research-source-shard-output.v1',
         mission_id: missionId,
@@ -107,7 +43,7 @@ export function defaultResearchSourceShardOutput(plan, layer, cycle = 1) {
             {
                 id: `shard-${layer.id}-primary`,
                 layer: layer.id,
-                kind: layer.id === 'local_project_evidence' ? 'local_project' : 'deterministic_fixture',
+                kind: 'deterministic_fixture',
                 title: `${layer.label} primary evidence for ${topic}`,
                 locator: layer.id === 'local_project_evidence' ? 'git ls-files' : `deterministic://${layer.id}/primary`,
                 publisher_or_author: layer.id === 'local_project_evidence' ? 'local repository' : 'SKS deterministic research shard',
@@ -117,12 +53,17 @@ export function defaultResearchSourceShardOutput(plan, layer, cycle = 1) {
                 credibility: layer.id === 'public_discourse' ? 'contextual' : 'layer-appropriate',
                 stance,
                 claim_ids: primaryClaimIds,
+                ...(layer.id === 'counterevidence_factcheck' ? {
+                    counterevidence_target_claim_id: primaryClaimIds[0],
+                    counterevidence_target_claim_ids: [primaryClaimIds[0], 'stage-claim-7'],
+                    contradiction_rationale: `Deterministic fixture challenges ${primaryClaimIds[0]} for counterevidence contract testing.`
+                } : {}),
                 notes: `${layer.label} shard records reproducible evidence metadata for ${topic}.`
             },
             {
                 id: `shard-${layer.id}-secondary`,
                 layer: layer.id,
-                kind: layer.id === 'local_project_evidence' ? 'local_project' : 'deterministic_fixture',
+                kind: 'deterministic_fixture',
                 title: `${layer.label} secondary evidence for ${topic}`,
                 locator: layer.id === 'local_project_evidence' ? 'package.json docs src schemas' : `deterministic://${layer.id}/secondary`,
                 publisher_or_author: layer.id === 'local_project_evidence' ? 'local repository' : 'SKS deterministic research shard',
@@ -130,8 +71,13 @@ export function defaultResearchSourceShardOutput(plan, layer, cycle = 1) {
                 accessed_at: nowIso(),
                 reliability: 'medium',
                 credibility: 'corroborating',
-                stance: layer.id === 'counterevidence_factcheck' ? 'undermines' : 'mixed',
+                stance: layer.id === 'counterevidence_factcheck' ? 'undermines' : 'supports',
                 claim_ids: secondaryClaimIds,
+                ...(layer.id === 'counterevidence_factcheck' ? {
+                    counterevidence_target_claim_id: secondaryClaimIds[1] || secondaryClaimIds[0],
+                    counterevidence_target_claim_ids: [secondaryClaimIds[1] || secondaryClaimIds[0], 'stage-claim-8'],
+                    contradiction_rationale: `Deterministic fixture challenges ${secondaryClaimIds[1] || secondaryClaimIds[0]} for counterevidence contract testing.`
+                } : {}),
                 notes: `${layer.label} shard adds a second row so merger and triangulation are observable.`
             }
         ],
@@ -157,6 +103,16 @@ export function validateResearchSourceShardOutput(output) {
         }
         if (!Array.isArray(source?.claim_ids) || source.claim_ids.length === 0)
             blockers.push(`source_shard_claim_ids_missing:${source?.id || 'unknown'}`);
+        if (source?.stance === 'undermines') {
+            const targetClaimIds = [
+                ...(Array.isArray(source?.counterevidence_target_claim_ids) ? source.counterevidence_target_claim_ids : []),
+                source?.counterevidence_target_claim_id
+            ].map((value) => String(value || '').trim()).filter(Boolean);
+            if (!targetClaimIds.length)
+                blockers.push(`source_shard_counterevidence_target_missing:${source?.id || 'unknown'}`);
+            if (!String(source?.contradiction_rationale || '').trim())
+                blockers.push(`source_shard_counterevidence_rationale_missing:${source?.id || 'unknown'}`);
+        }
     }
     return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
 }