sneakoscope 6.0.3 → 6.1.2

package/dist/core/research/research-claim-builder.js

@@ -1,4 +1,5 @@
 import { normalizeClaimEvidenceMatrix } from './claim-evidence-matrix.js';
+import { sha256 } from '../fsx.js';
 export async function buildClaimEvidenceMatrixFromSourceShards(input) {
     const sources = [
         ...(Array.isArray(input.sourceLedger?.sources) ? input.sourceLedger.sources : []),
@@ -17,50 +18,77 @@ export async function buildClaimEvidenceMatrixFromSourceShards(input) {
             importance: candidates.size < 2 ? 'critical' : 'high',
             source_ids: normalizeStringList(entry?.source_ids || entry?.evidence),
             counterevidence_ids: normalizeStringList(entry?.counterevidence_ids || entry?.falsifiers),
-            test_or_probe: String(entry?.next_experiment || entry?.test_or_probe || '').trim()
+            counterevidence_links: normalizeCounterevidenceLinks(entry?.counterevidence_links),
+            test_or_probe: String(entry?.next_experiment || entry?.test_or_probe || '').trim(),
+            trusted_grouping: true
         });
     }
     for (const source of sources) {
         const claimIds = normalizeStringList(source?.claim_ids);
-        if (claimIds.length) {
+        const usable = usableEvidenceSource(source);
+        if (claimIds.length && usable) {
             for (const claimId of claimIds) {
+                const sourceSpecific = claimId.startsWith('source-claim-');
                 const existing = candidates.get(claimId) || {
                     id: claimId,
                     claim: claimTextFromSource(source, claimId),
                     claim_type: 'inference',
-                    importance: candidates.size < 2 ? 'critical' : candidates.size < 8 ? 'high' : 'medium',
+                    importance: sourceSpecific ? 'medium' : candidates.size < 2 ? 'critical' : candidates.size < 8 ? 'high' : 'medium',
                     source_ids: [],
                     counterevidence_ids: [],
-                    test_or_probe: ''
+                    counterevidence_links: [],
+                    test_or_probe: '',
+                    trusted_grouping: sourceSpecific ? false : deterministicFixtureSource(source)
                 };
-                if (source?.stance === 'undermines')
+                if (source?.stance === 'undermines') {
                     existing.counterevidence_ids = [...new Set([...(existing.counterevidence_ids || []), source.id])];
-                else
+                    const targetClaimIds = normalizeStringList([
+                        ...normalizeStringList(source?.counterevidence_target_claim_ids),
+                        source?.counterevidence_target_claim_id
+                    ]);
+                    if (targetClaimIds.includes(claimId) && String(source?.contradiction_rationale || '').trim()) {
+                        existing.counterevidence_links = normalizeCounterevidenceLinks([
+                            ...(existing.counterevidence_links || []),
+                            { source_id: source.id, target_claim_id: claimId, contradiction_rationale: source.contradiction_rationale }
+                        ]);
+                    }
+                }
+                else if (source?.stance === 'supports') {
                     existing.source_ids = [...new Set([...(existing.source_ids || []), source.id])];
+                }
                 if (!existing.test_or_probe)
                     existing.test_or_probe = `Probe ${claimId} against supporting and undermining source layers.`;
                 candidates.set(claimId, existing);
             }
         }
         else if (String(source?.notes || '').trim()) {
-            const id = `hypothesis-${candidates.size + 1}`;
+            const id = `unlinked-source-${sha256(`${String(source?.id || '')}\0${String(source?.notes || '')}`).slice(0, 12)}`;
             candidates.set(id, {
                 id,
                 claim: String(source.notes).slice(0, 240),
                 claim_type: 'hypothesis',
                 importance: 'medium',
-                source_ids: source?.stance === 'undermines' ? [] : [source.id].filter(Boolean),
-                counterevidence_ids: source?.stance === 'undermines' ? [source.id].filter(Boolean) : [],
-                test_or_probe: `Turn ${source.id || id} notes into a decisive source-backed probe.`
+                source_ids: [],
+                counterevidence_ids: [],
+                counterevidence_links: [],
+                test_or_probe: `Establish a semantic claim and direct evidence link for ${source.id || id} before using it.`,
+                trusted_grouping: false
             });
         }
     }
-    const falsificationCounterIds = new Set((Array.isArray(input.falsificationLedger?.cases) ? input.falsificationLedger.cases : [])
-        .flatMap((row) => [...normalizeStringList(row?.counterevidence_source_ids), ...normalizeStringList(row?.source_ids)]));
     const claims = [...candidates.values()].slice(0, Math.max(8, candidates.size)).map((candidate, index) => {
         const sourceIds = normalizeStringList(candidate.source_ids).filter((id) => sourceById(sources, id));
-        const counterIds = normalizeStringList(candidate.counterevidence_ids).filter((id) => sourceById(sources, id) || falsificationCounterIds.has(id));
+        const counterevidenceLinks = normalizeCounterevidenceLinks(candidate.counterevidence_links)
+            .filter((link) => link.target_claim_id === candidate.id && sourceById(sources, link.source_id));
+        const linkedCounterIds = new Set(counterevidenceLinks.map((link) => link.source_id));
+        const counterIds = normalizeStringList(candidate.counterevidence_ids)
+            .filter((id) => sourceById(sources, id) && linkedCounterIds.has(id));
         const layers = sourceLayersForSourceIds(sources, [...sourceIds, ...counterIds]);
+        const independentConfirmations = new Set([...sourceIds, ...counterIds]).size;
+        const highConfidence = candidate.trusted_grouping === true
+            && layers.length >= 3
+            && independentConfirmations >= 3
+            && counterIds.length > 0;
         return {
             id: candidate.id,
             claim: candidate.claim,
@@ -69,12 +97,13 @@ export async function buildClaimEvidenceMatrixFromSourceShards(input) {
             source_ids: sourceIds,
             local_evidence_ids: sources.filter((source) => source.layer === 'local_project_evidence' && normalizeStringList(source.claim_ids).includes(candidate.id)).map((source) => source.id),
             counterevidence_ids: counterIds,
+            counterevidence_links: counterevidenceLinks.filter((link) => counterIds.includes(link.source_id)),
             triangulation: {
                 source_layers: layers,
-                independent_confirmation_count: layers.length,
+                independent_confirmation_count: independentConfirmations,
                 conflicts: counterIds.length ? [`counterevidence:${counterIds.join(',')}`] : []
             },
-            confidence: layers.length >= 3 && counterIds.length ? 'high' : layers.length >= 2 ? 'medium' : 'low',
+            confidence: highConfidence ? 'high' : layers.length >= 2 && independentConfirmations >= 2 ? 'medium' : 'low',
             falsifiable: true,
             test_or_probe: candidate.test_or_probe || `Run a source-layer replication probe for ${candidate.id}.`
         };
@@ -85,16 +114,31 @@ export async function buildClaimEvidenceMatrixFromSourceShards(input) {
         return important && (claim.triangulation.source_layers.length < 2 || (claim.importance === 'critical' && claim.counterevidence_ids.length === 0));
     })
         .map((claim) => claim.id);
+    const evidenceLinkedClaims = claims.filter((claim) => claim.source_ids.length > 0 || claim.counterevidence_ids.length > 0);
     return normalizeClaimEvidenceMatrix({
         schema: 'sks.claim-evidence-matrix.v1',
         mission_id: input.plan?.mission_id || '',
         claims,
-        key_claim_ids: claims.slice(0, 8).map((claim) => claim.id),
+        key_claim_ids: evidenceLinkedClaims.slice(0, 8).map((claim) => claim.id),
         unsupported_claims: unsupported,
-        triangulated_claim_count: claims.filter((claim) => claim.triangulation.source_layers.length >= 2).length,
+        triangulated_claim_count: claims.filter((claim) => claim.triangulation.source_layers.length >= 2 && claim.triangulation.independent_confirmation_count >= 2).length,
         blockers: unsupported.map((id) => `unsupported_important_claim:${id}`)
     });
 }
+function usableEvidenceSource(source) {
+    if (!source || !String(source.id || '').trim())
+        return false;
+    if (source.stance !== 'supports' && source.stance !== 'undermines')
+        return false;
+    if (deterministicFixtureSource(source))
+        return true;
+    return String(source?.acquisition_verdict || '') === 'verified_content'
+        && /^verified_content:/i.test(String(source.credibility || ''))
+        && source?.super_search_provenance?.validated === true;
+}
+function deterministicFixtureSource(source) {
+    return /^(?:deterministic_fixture|selftest|mock)$/i.test(String(source?.kind || ''));
+}
 function claimTextFromSource(source, claimId) {
     const notes = String(source?.notes || '').trim();
     if (notes)
@@ -108,6 +152,14 @@ function sourceLayersForSourceIds(sources, ids) {
     const idSet = new Set(ids);
     return [...new Set(sources.filter((source) => idSet.has(String(source?.id || ''))).map((source) => String(source?.layer || '')).filter(Boolean))];
 }
+function normalizeCounterevidenceLinks(value) {
+    const rows = Array.isArray(value) ? value : [];
+    return rows.map((row) => ({
+        source_id: String(row?.source_id || '').trim(),
+        target_claim_id: String(row?.target_claim_id || '').trim(),
+        contradiction_rationale: String(row?.contradiction_rationale || '').trim()
+    })).filter((row) => row.source_id && row.target_claim_id && row.contradiction_rationale);
+}
 function normalizeStringList(value) {
     return [...new Set((Array.isArray(value) ? value : value == null ? [] : [value]).map((item) => String(item || '').trim()).filter(Boolean))];
 }

package/dist/core/research/research-claim-synthesizer.js

@@ -0,0 +1,343 @@
+import path from 'node:path';
+import { readJson } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-task-runner.js';
+import { THINKING_SUBAGENT_MODEL, SUBAGENT_EFFORT } from '../subagents/model-policy.js';
+import { normalizeClaimEvidenceMatrix, validateClaimEvidenceMatrix } from './claim-evidence-matrix.js';
+export async function synthesizeResearchClaimEvidenceMatrix(input) {
+    const result = await runCodexTask({
+        route: '$Research',
+        tier: 'orchestrator',
+        missionId: String(input.plan?.mission_id || 'research-claim-synthesis'),
+        workItemId: 'research_claim_semantic_synthesis',
+        cwd: input.root,
+        prompt: buildResearchClaimSynthesisPrompt(input),
+        inputFiles: [path.join(input.dir, 'source-ledger.json')],
+        outputSchema: researchClaimEvidenceMatrixOutputSchema,
+        outputSchemaId: 'sks.claim-evidence-matrix.v1',
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: {
+            id: 'research-claim-semantic-synthesis',
+            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', 'claim-synthesis-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 recalculated = recalculateResearchClaimEvidenceMatrix(worker, input.plan, input.sourceLedger);
+    const validation = validateClaimEvidenceMatrix(recalculated, input.sourceLedger, null);
+    const blockers = unique([
+        ...(Array.isArray(result.blockers) ? result.blockers.map(String) : []),
+        ...(Array.isArray(worker?.blockers) ? worker.blockers.map(String) : []),
+        ...recalculated.blockers,
+        ...validation.blockers
+    ]);
+    return {
+        matrix: normalizeClaimEvidenceMatrix({ ...recalculated, blockers }),
+        blockers,
+        worker_result_path: typeof result.workerResultPath === 'string' ? result.workerResultPath : null
+    };
+}
+export function recalculateResearchClaimEvidenceMatrix(value, plan, sourceLedger) {
+    const normalized = normalizeClaimEvidenceMatrix(value);
+    const sources = allSources(sourceLedger);
+    const byId = new Map(sources.map((source) => [String(source?.id || ''), source]));
+    const claims = normalized.claims.map((claim) => {
+        const evidenceBlockers = [];
+        const counterevidenceLinks = claim.counterevidence_links.filter((link) => {
+            if (link.target_claim_id !== claim.id) {
+                evidenceBlockers.push(`claim_counterevidence_target_mismatch:${claim.id}:${link.source_id}`);
+                return false;
+            }
+            if (link.contradiction_rationale.length < 32 || !sourceSemanticallyOverlapsClaim({ notes: link.contradiction_rationale }, claim.claim)) {
+                evidenceBlockers.push(`claim_counterevidence_rationale_not_claim_relative:${claim.id}:${link.source_id}`);
+                return false;
+            }
+            return true;
+        });
+        const counterevidenceLinksBySource = new Map(counterevidenceLinks.map((link) => [link.source_id, link]));
+        const sourceIds = unique(claim.source_ids).filter((sourceId) => {
+            const source = byId.get(sourceId);
+            if (!source) {
+                evidenceBlockers.push(`claim_source_unknown:${claim.id}:${sourceId}`);
+                return false;
+            }
+            if (!trustworthyVerifiedEvidence(source)) {
+                evidenceBlockers.push(`claim_source_not_verified:${claim.id}:${sourceId}`);
+                return false;
+            }
+            if (!sourceSemanticallyOverlapsClaim(source, claim.claim)) {
+                evidenceBlockers.push(`claim_source_semantic_overlap_missing:${claim.id}:${sourceId}`);
+                return false;
+            }
+            return true;
+        });
+        const counterevidenceIds = unique(claim.counterevidence_ids).filter((sourceId) => {
+            const source = byId.get(sourceId);
+            if (!source) {
+                evidenceBlockers.push(`claim_counterevidence_unknown:${claim.id}:${sourceId}`);
+                return false;
+            }
+            if (!trustworthyVerifiedEvidence(source)) {
+                evidenceBlockers.push(`claim_counterevidence_not_verified:${claim.id}:${sourceId}`);
+                return false;
+            }
+            if (!counterevidenceLinksBySource.has(sourceId)) {
+                evidenceBlockers.push(`claim_counterevidence_link_missing:${claim.id}:${sourceId}`);
+                return false;
+            }
+            if (sourceIds.includes(sourceId)) {
+                evidenceBlockers.push(`claim_counterevidence_also_used_as_support:${claim.id}:${sourceId}`);
+                return false;
+            }
+            if (!sourceSemanticallyOverlapsClaim(source, claim.claim)) {
+                evidenceBlockers.push(`claim_counterevidence_semantic_overlap_missing:${claim.id}:${sourceId}`);
+                return false;
+            }
+            return true;
+        });
+        const supportRows = sourceIds.map((id) => byId.get(id)).filter(Boolean);
+        const counterRows = counterevidenceIds.map((id) => byId.get(id)).filter(Boolean);
+        const supportLayers = unique(supportRows.map((row) => String(row?.layer || '')).filter(Boolean));
+        const layers = unique([...supportRows, ...counterRows].map((row) => String(row?.layer || '')).filter(Boolean));
+        const independenceKeys = unique(supportRows.map(sourceIndependenceKey).filter(Boolean));
+        const authoritativeSupportCount = supportRows.filter(authoritativeSupportingEvidence).length;
+        const independentConfirmationCount = independenceKeys.length;
+        const highConfidence = sourceIds.length >= 3
+            && independentConfirmationCount >= 3
+            && supportLayers.length >= 3
+            && authoritativeSupportCount >= 2
+            && counterevidenceIds.length > 0
+            && evidenceBlockers.length === 0;
+        const mediumConfidence = sourceIds.length >= 2
+            && independentConfirmationCount >= 2
+            && supportLayers.length >= 2
+            && authoritativeSupportCount >= 1
+            && evidenceBlockers.length === 0;
+        return {
+            ...claim,
+            source_ids: sourceIds,
+            counterevidence_ids: counterevidenceIds,
+            counterevidence_links: counterevidenceLinks.filter((link) => counterevidenceIds.includes(link.source_id)),
+            local_evidence_ids: sourceIds.filter((id) => byId.get(id)?.layer === 'local_project_evidence'),
+            triangulation: {
+                source_layers: layers,
+                independent_confirmation_count: independentConfirmationCount,
+                conflicts: counterevidenceIds.length ? [`counterevidence:${counterevidenceIds.join(',')}`] : []
+            },
+            confidence: highConfidence ? 'high' : mediumConfidence ? 'medium' : 'low',
+            evidence_blockers: unique(evidenceBlockers),
+            support_layer_count: supportLayers.length,
+            authoritative_support_count: authoritativeSupportCount
+        };
+    });
+    const unsupported = unique([
+        ...normalized.unsupported_claims,
+        ...claims.filter((claim) => {
+            const important = claim.importance === 'high' || claim.importance === 'critical';
+            return important && (claim.source_ids.length < 2
+                || claim.triangulation.independent_confirmation_count < 2
+                || claim.support_layer_count < 2
+                || claim.authoritative_support_count < 1
+                || claim.evidence_blockers.length > 0
+                || (claim.importance === 'critical' && claim.counterevidence_ids.length === 0));
+        }).map((claim) => claim.id)
+    ]);
+    const evidenceBlockers = claims.flatMap((claim) => claim.evidence_blockers);
+    const outputClaims = claims.map(({ evidence_blockers: _evidenceBlockers, support_layer_count: _supportLayerCount, authoritative_support_count: _authoritativeSupportCount, ...claim }) => claim);
+    return normalizeClaimEvidenceMatrix({
+        schema: 'sks.claim-evidence-matrix.v1',
+        mission_id: String(value?.mission_id || plan?.mission_id || ''),
+        claims: outputClaims,
+        key_claim_ids: normalized.key_claim_ids,
+        unsupported_claims: unsupported,
+        triangulated_claim_count: outputClaims.filter((claim) => claim.triangulation.source_layers.length >= 2 && claim.triangulation.independent_confirmation_count >= 2).length,
+        blockers: unique([
+            ...normalized.blockers,
+            ...evidenceBlockers,
+            ...unsupported.map((id) => `unsupported_important_claim:${id}`)
+        ])
+    });
+}
+function buildResearchClaimSynthesisPrompt(input) {
+    const contract = input.plan?.quality_contract || {};
+    return [
+        'Build a semantic claim-evidence matrix for this Research mission.',
+        'This is a judgment-heavy task: use GPT-5.6 Sol with max reasoning.',
+        'Return exactly one JSON object matching sks.claim-evidence-matrix.v1.',
+        'Never reuse or merge discovery claim IDs merely because their strings match.',
+        'Group sources only when their hydrated notes/content actually support the same written claim.',
+        'Every supporting and counterevidence source id must exist in the supplied source ledger.',
+        'A source title alone is not evidence. Use locator, author/date, credibility, notes/snippet, and content artifact/hash when present.',
+        'Context, weak, partial, public-discourse-only, or discovery-only rows cannot support a high/critical claim.',
+        'Critical claims require direct counterevidence or must be downgraded/blocked.',
+        'Every counterevidence id must have a counterevidence_links row whose target_claim_id exactly equals the current claim id and whose contradiction_rationale explains the claim-relative conflict.',
+        'Do not infer counterevidence from generic negative keywords; select it only when the hydrated source meaning directly challenges the written claim.',
+        'Mark uncertainty and return explicit blockers when the evidence cannot satisfy the requested minimums.',
+        `Mission: ${input.plan?.mission_id || 'unknown'}`,
+        `Question: ${input.plan?.prompt || ''}`,
+        `Target key claims: ${Number(contract.min_key_claims || 8)}`,
+        `Target triangulated claims: ${Number(contract.min_trianguled_claims || 6)}`,
+        '',
+        'Evidence pack:',
+        JSON.stringify(compactSourceLedger(input.sourceLedger), null, 2).slice(0, 30000)
+    ].join('\n');
+}
+function compactSourceLedger(sourceLedger) {
+    return {
+        sources: allSources(sourceLedger).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,
+            reliability: source.reliability,
+            credibility: source.credibility,
+            stance: source.stance,
+            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
+        })),
+        blockers: Array.isArray(sourceLedger?.blockers) ? sourceLedger.blockers : []
+    };
+}
+function allSources(sourceLedger) {
+    return [
+        ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+    ];
+}
+function trustworthyVerifiedEvidence(source) {
+    const verified = String(source?.acquisition_verdict || '') === 'verified_content'
+        && /^verified_content:/i.test(String(source?.credibility || ''));
+    const hydrated = Boolean(String(source?.content_artifact || '').trim())
+        && /^[a-f0-9]{64}$/i.test(String(source?.content_sha256 || '').trim())
+        && Number(source?.content_length || 0) > 0;
+    return verified && hydrated && source?.super_search_provenance?.validated === true;
+}
+function authoritativeSupportingEvidence(source) {
+    if (!source || source?.layer === 'public_discourse')
+        return false;
+    const tier = String(source?.authority_tier || '').toUpperCase();
+    const reliability = String(source?.reliability || '').toLowerCase();
+    return source?.primary_source === true
+        || ['A0', 'A1', 'B'].includes(tier)
+        || reliability === 'high'
+        || reliability === 'medium-high';
+}
+function sourceIndependenceKey(source) {
+    const explicit = String(source?.independence_cluster_id || source?.domain || '').trim().toLowerCase();
+    if (explicit)
+        return explicit;
+    try {
+        return new URL(String(source?.locator || '')).hostname.toLowerCase();
+    }
+    catch {
+        return String(source?.publisher_or_author || '').trim().toLowerCase();
+    }
+}
+function sourceSemanticallyOverlapsClaim(source, claim) {
+    const claimTokens = semanticTokens(claim);
+    if (claimTokens.length === 0)
+        return false;
+    const sourceTokens = new Set(semanticTokens([
+        source?.title,
+        source?.notes,
+        source?.publisher_or_author,
+        source?.locator
+    ].filter(Boolean).join(' ')));
+    const overlap = claimTokens.filter((token) => sourceTokens.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 unique(String(value || '').toLowerCase().normalize('NFKC').match(/[\p{L}\p{N}]{4,}/gu) || [])
+        .filter((token) => !stop.has(token));
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+export const researchClaimEvidenceMatrixOutputSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['schema', 'mission_id', 'claims', 'key_claim_ids', 'unsupported_claims', 'triangulated_claim_count', 'blockers'],
+    properties: {
+        schema: { const: 'sks.claim-evidence-matrix.v1' },
+        mission_id: { type: 'string' },
+        claims: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['id', 'claim', 'claim_type', 'importance', 'source_ids', 'local_evidence_ids', 'counterevidence_ids', 'counterevidence_links', 'triangulation', 'confidence', 'falsifiable', 'test_or_probe'],
+                properties: {
+                    id: { type: 'string' },
+                    claim: { type: 'string' },
+                    claim_type: { enum: ['fact', 'inference', 'hypothesis', 'recommendation', 'implementation_guidance'] },
+                    importance: { enum: ['low', 'medium', 'high', 'critical'] },
+                    source_ids: { type: 'array', items: { type: 'string' } },
+                    local_evidence_ids: { type: 'array', items: { type: 'string' } },
+                    counterevidence_ids: { type: 'array', items: { type: 'string' } },
+                    counterevidence_links: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            required: ['source_id', 'target_claim_id', 'contradiction_rationale'],
+                            properties: {
+                                source_id: { type: 'string' },
+                                target_claim_id: { type: 'string' },
+                                contradiction_rationale: { type: 'string' }
+                            }
+                        }
+                    },
+                    triangulation: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['source_layers', 'independent_confirmation_count', 'conflicts'],
+                        properties: {
+                            source_layers: { type: 'array', items: { type: 'string' } },
+                            independent_confirmation_count: { type: 'number' },
+                            conflicts: { type: 'array', items: { type: 'string' } }
+                        }
+                    },
+                    confidence: { enum: ['low', 'medium', 'high'] },
+                    falsifiable: { type: 'boolean' },
+                    test_or_probe: { type: 'string' }
+                }
+            }
+        },
+        key_claim_ids: { type: 'array', items: { type: 'string' } },
+        unsupported_claims: { type: 'array', items: { type: 'string' } },
+        triangulated_claim_count: { type: 'number' },
+        blockers: { type: 'array', items: { type: 'string' } }
+    }
+};
+//# sourceMappingURL=research-claim-synthesizer.js.map

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

@@ -22,6 +22,7 @@ export async function runResearchCycle(inputOrDir, legacyGraph = null, legacyOpt
     const running = new Map();
     const blockers = [];
     const maxParallel = Math.max(1, Math.min(16, Number(input.maxParallelStages || 4)));
+    const cycleDeadlineMs = Date.now() + Math.max(1, Number(input.timeoutMs || 1));
     let maxObservedParallel = 0;
     while (pending.size || running.size) {
         const ready = readyStages([...pending.values()], completed);
@@ -30,7 +31,15 @@ export async function runResearchCycle(inputOrDir, legacyGraph = null, legacyOpt
             if (!stage)
                 break;
             pending.delete(String(stage.id));
-            const promise = runResearchStage({ ...input, stage }).catch((err) => failureStage(input, stage, err));
+            const remainingMs = Math.max(0, cycleDeadlineMs - Date.now());
+            if (remainingMs <= 0) {
+                const failed = failureStage(input, stage, new Error('research_cycle_timeout_exceeded'));
+                completed.set(String(stage.id), failed);
+                blockers.push(`${String(stage.id)}:research_cycle_timeout_exceeded`);
+                continue;
+            }
+            const promise = runResearchStage({ ...input, stage, timeoutMs: remainingMs, cycleDeadlineMs })
+                .catch((err) => failureStage(input, stage, err));
             running.set(String(stage.id), promise);
             maxObservedParallel = Math.max(maxObservedParallel, running.size);
         }
@@ -44,7 +53,24 @@ export async function runResearchCycle(inputOrDir, legacyGraph = null, legacyOpt
             pending.clear();
             break;
         }
-        const done = await Promise.race([...running.entries()].map(async ([id, promise]) => ({ id, result: await promise })));
+        const done = await raceResearchStagesUntilDeadline(running, cycleDeadlineMs);
+        if (!done) {
+            for (const [id, promise] of running.entries()) {
+                promise.catch(() => undefined);
+                const stage = stages.find((candidate) => String(candidate.id) === id);
+                const failed = failureStage(input, stage, new Error('research_cycle_timeout_exceeded'));
+                completed.set(id, failed);
+                blockers.push(`${id}:research_cycle_timeout_exceeded`);
+            }
+            for (const [id, stage] of pending.entries()) {
+                const failed = failureStage(input, stage, new Error('research_cycle_timeout_exceeded'));
+                completed.set(id, failed);
+                blockers.push(`${id}:research_cycle_timeout_exceeded`);
+            }
+            running.clear();
+            pending.clear();
+            break;
+        }
         running.delete(done.id);
         completed.set(done.id, done.result);
         if (done.result.status !== 'passed' && pendingStageRequired(stages.find((stage) => String(stage.id) === done.id))) {
@@ -70,13 +96,37 @@ export async function runResearchCycle(inputOrDir, legacyGraph = null, legacyOpt
             stage_count: stageResults.length,
             critical_path_length: criticalPathLength(stages)
         },
-        legacy_final_md_loop: false
+        legacy_final_md_loop: false,
+        timeout: {
+            budget_ms: Math.max(1, Number(input.timeoutMs || 1)),
+            deadline_epoch_ms: cycleDeadlineMs,
+            exhausted: Date.now() >= cycleDeadlineMs
+        }
     };
     await writeJsonAtomic(path.join(input.dir, 'research', `cycle-${input.cycle}`, 'research-cycle-runner.json'), record);
     await writeJsonAtomic(path.join(input.dir, 'research-cycle-runner.json'), record);
     await appendJsonlBounded(path.join(input.dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle_runner.completed', cycle: record.cycle, stage_count: record.stage_count, status: record.status, max_observed_parallel: maxObservedParallel });
     return record;
 }
+export async function raceResearchStagesUntilDeadline(running, deadlineEpochMs) {
+    const remainingMs = Math.max(0, Math.floor(deadlineEpochMs - Date.now()));
+    if (remainingMs <= 0)
+        return null;
+    let timer = null;
+    try {
+        return await Promise.race([
+            ...[...running.entries()].map(async ([id, promise]) => ({ id, result: await promise })),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(null), remainingMs);
+                timer.unref?.();
+            })
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 export function readyStages(pending, completed) {
     return pending.filter((stage) => (Array.isArray(stage.dependencies) ? stage.dependencies : []).every((id) => completed.has(String(id))));
 }