sneakoscope 2.0.11 → 2.0.13

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

@@ -0,0 +1,67 @@
+export const REQUIRED_RESEARCH_REPORT_HEADINGS = [
+    'Question',
+    'Methodology',
+    'Source Map',
+    'Key Claims',
+    'Evidence Matrix Summary',
+    'Counterevidence',
+    'Falsification',
+    'Implementation Blueprint',
+    'Experiment / Validation Plan',
+    'Limitations',
+    'References'
+];
+export function analyzeResearchReportQuality(text) {
+    const body = String(text || '');
+    const headings = body.split(/\r?\n/)
+        .map((line) => line.match(/^#{1,6}\s+(.+?)\s*#*\s*$/)?.[1]?.trim())
+        .filter((value) => Boolean(value));
+    const lowerHeadings = headings.map((heading) => normalizeHeading(heading));
+    const headingsPresent = REQUIRED_RESEARCH_REPORT_HEADINGS.filter((heading) => lowerHeadings.some((value) => value.includes(normalizeHeading(heading))));
+    const missingHeadings = REQUIRED_RESEARCH_REPORT_HEADINGS.filter((heading) => !headingsPresent.includes(heading));
+    const implementationText = sectionText(body, 'Implementation Blueprint');
+    const referencesText = sectionText(body, 'References');
+    const referencesSourceIds = [...new Set([
+            ...body.matchAll(/\b(?:source|src|mock-source|counter|mock-counter)-[A-Za-z0-9_.:-]+\b/g)
+        ].map((match) => match[0]))];
+    const blockers = [
+        ...missingHeadings.map((heading) => `research_report_heading_missing:${normalizeHeading(heading).replace(/\s+/g, '_')}`),
+        ...(referencesSourceIds.length ? [] : ['research_report_references_missing_source_ids'])
+    ];
+    return {
+        schema: 'sks.research-report-quality.v1',
+        word_count: countWords(body),
+        headings_present: headingsPresent,
+        missing_headings: missingHeadings,
+        implementation_section_words: countWords(implementationText),
+        references_source_ids: referencesText ? referencesSourceIds : [],
+        blockers,
+        ok: blockers.length === 0
+    };
+}
+export function countWords(text) {
+    return String(text || '').trim().split(/\s+/).filter(Boolean).length;
+}
+function normalizeHeading(value) {
+    return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
+function sectionText(text, heading) {
+    const lines = String(text || '').split(/\r?\n/);
+    const target = normalizeHeading(heading);
+    let capture = false;
+    const out = [];
+    for (const line of lines) {
+        const match = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+        if (match) {
+            const normalized = normalizeHeading(match[2] || '');
+            if (capture)
+                break;
+            capture = normalized.includes(target);
+            continue;
+        }
+        if (capture)
+            out.push(line);
+    }
+    return out.join('\n');
+}
+//# sourceMappingURL=research-report-quality.js.map

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

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export async function runResearchStage(dir, stage, opts = {}) {
+    const record = {
+        schema: 'sks.research-stage-run.v1',
+        stage_id: stage?.id || opts.stageId || 'unknown',
+        status: opts.status || 'recorded',
+        readonly: true,
+        started_at: opts.startedAt || nowIso(),
+        completed_at: nowIso(),
+        notes: opts.notes || []
+    };
+    await writeJsonAtomic(path.join(dir, 'research', 'stages', `${record.stage_id}.json`), record);
+    return record;
+}
+//# sourceMappingURL=research-stage-runner.js.map

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

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export const RESEARCH_WORK_GRAPH_ARTIFACT = 'research-work-graph.json';
+const STAGES = [
+    { id: 'research_source_quality', title: 'Source quality and layered retrieval audit', kind: 'research', outputs: ['source-ledger.json', 'source-quality-report.json'] },
+    { id: 'research_claim_matrix', title: 'Claim-evidence matrix and citation coverage', kind: 'research', outputs: ['claim-evidence-matrix.json'] },
+    { id: 'research_falsification', title: 'Counterevidence and falsification strengthening', kind: 'research', outputs: ['falsification-ledger.json'] },
+    { id: 'research_synthesis_report', title: 'Research report and manuscript synthesis', kind: 'research', outputs: ['research-report.md'] },
+    { id: 'research_blueprint', title: 'Implementation blueprint and handoff', kind: 'documentation', outputs: ['implementation-blueprint.json', 'implementation-blueprint.md', 'team-handoff-goal.md'] },
+    { id: 'research_experiment', title: 'Experiment plan and replication pack', kind: 'verification', outputs: ['experiment-plan.json', 'replication-pack.json'] },
+    { id: 'research_final_review', title: 'Final reviewer quality audit', kind: 'verification', outputs: ['research-final-review.json'] },
+    { id: 'research_gate_close', title: 'Research gate evaluation and completion output', kind: 'final_review_input_pack', outputs: ['research-gate.evaluated.json', 'research-gate.json'] }
+];
+function workItem(stage, index, plan = null) {
+    const missionPrefix = plan?.mission_id ? `.sneakoscope/missions/${plan.mission_id}/` : '';
+    return {
+        id: stage.id,
+        kind: stage.kind,
+        title: stage.title,
+        target_paths: stage.outputs.map((artifact) => `${missionPrefix}${artifact}`),
+        readonly_paths: [
+            `${missionPrefix}research-plan.json`,
+            `${missionPrefix}research-quality-contract.json`,
+            `${missionPrefix}source-ledger.json`,
+            `${missionPrefix}claim-evidence-matrix.json`
+        ],
+        write_paths: [],
+        required_role: index < 4 ? 'research' : 'verifier',
+        write_allowed: false,
+        verification_required: true,
+        dependencies: index === 0 ? [] : [STAGES[index - 1]?.id].filter(Boolean),
+        can_run_in_parallel_with: STAGES.filter((candidate) => candidate.id !== stage.id).map((candidate) => candidate.id),
+        conflicts_with: [],
+        estimated_cost: { tokens: 4000, latency_ms: 60000, cpu_weight: 1, memory_mb: 256, gpu_weight: 0 },
+        lease_requirements: stage.outputs.map((artifact) => ({ path: `${missionPrefix}${artifact}`, kind: 'read' })),
+        acceptance: { requires_patch_envelope: false, requires_verification: true, requires_gpt_final: false },
+        owner: null,
+        allocation_reason: 'Stage-aware read-only research pipeline work graph',
+        allocation_score: 1,
+        allocation_hints: { domains: [stage.kind], write_paths: [], read_only_paths: stage.outputs },
+        lane: null,
+        worktree: { mode: 'patch-envelope-only', required: false, allocation_required: false }
+    };
+}
+export function buildResearchWorkGraph(plan = null) {
+    const requestedClones = Math.max(8, Number(plan?.native_agent_plan?.session_count || 0));
+    const workItems = STAGES.map((stage, index) => workItem(stage, index, plan));
+    return {
+        schema: 'sks.naruto-work-graph.v1',
+        route: '$Naruto',
+        requested_clones: requestedClones,
+        total_work_items: workItems.length,
+        readonly: true,
+        write_capable: false,
+        work_items: workItems,
+        active_waves: [
+            { wave_id: 'research-quality-wave', work_item_ids: workItems.slice(0, 4).map((item) => item.id), write_paths: [], conflict_count: 0 },
+            { wave_id: 'research-closeout-wave', work_item_ids: workItems.slice(4).map((item) => item.id), write_paths: [], conflict_count: 0 }
+        ],
+        mixed_work_kinds: [...new Set(workItems.map((item) => item.kind))],
+        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
+    };
+}
+export async function writeResearchWorkGraph(dir, plan = null) {
+    const graph = buildResearchWorkGraph(plan);
+    await writeJsonAtomic(path.join(dir, RESEARCH_WORK_GRAPH_ARTIFACT), {
+        ...graph,
+        generated_at: nowIso()
+    });
+    return graph;
+}
+//# sourceMappingURL=research-work-graph.js.map

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

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+export const SOURCE_QUALITY_REPORT_ARTIFACT = 'source-quality-report.json';
+const REQUIRED_SOURCE_FIELDS = Object.freeze([
+    'id',
+    'layer',
+    'kind',
+    'title',
+    'locator',
+    'publisher_or_author',
+    'accessed_at',
+    'reliability',
+    'credibility',
+    'stance',
+    'claim_ids'
+]);
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function sourceRows(sourceLedger = null) {
+    return [
+        ...asArray(sourceLedger?.sources),
+        ...asArray(sourceLedger?.counterevidence_sources)
+    ];
+}
+function missingFields(row) {
+    return REQUIRED_SOURCE_FIELDS.filter((field) => {
+        const value = row?.[field];
+        if (Array.isArray(value))
+            return value.length === 0;
+        return value === undefined || value === null || String(value).trim() === '';
+    });
+}
+export function buildSourceQualityReport(sourceLedger = null, claimMatrix = null) {
+    const rows = sourceRows(sourceLedger);
+    const rowReports = rows.map((row) => {
+        const missing = missingFields(row);
+        return {
+            id: String(row?.id || ''),
+            layer: row?.layer || row?.layer_id || row?.source_layer || null,
+            stance: row?.stance || null,
+            claim_ids: asArray(row?.claim_ids).map(String),
+            reliability: row?.reliability || null,
+            credibility: row?.credibility || null,
+            missing_fields: missing,
+            ok: missing.length === 0
+        };
+    });
+    const sourceLayerRows = asArray(sourceLedger?.source_layers);
+    const coveredLayerIds = sourceLayerRows
+        .filter((layer) => layer?.status === 'covered')
+        .map((layer) => String(layer.id || layer.layer || ''))
+        .filter(Boolean);
+    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 blockers = [
+        ...rowReports.flatMap((row) => row.ok ? [] : [`source_metadata_incomplete:${row.id || 'unknown'}`]),
+        ...(keyClaimIds.length && uncitedKeyClaimIds.length ? ['key_claim_citation_coverage_incomplete'] : []),
+        ...(sourceLedger?.citation_coverage?.all_key_claims_cited === false ? ['source_ledger_reports_uncited_key_claims'] : [])
+    ];
+    return {
+        schema: 'sks.research-source-quality-report.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        blockers,
+        required_source_fields: [...REQUIRED_SOURCE_FIELDS],
+        summary: {
+            source_entries: asArray(sourceLedger?.sources).length,
+            counterevidence_entries: asArray(sourceLedger?.counterevidence_sources).length,
+            total_entries: rows.length,
+            rows_with_complete_metadata: rowReports.filter((row) => row.ok).length,
+            source_layers_covered: coveredLayerIds.length,
+            key_claims: keyClaimIds.length,
+            cited_key_claims: keyClaimIds.length - uncitedKeyClaimIds.length,
+            uncited_key_claims: uncitedKeyClaimIds.length
+        },
+        citation_coverage: {
+            all_key_claims_cited: uncitedKeyClaimIds.length === 0 && sourceLedger?.citation_coverage?.all_key_claims_cited === true,
+            cited_claim_ids: [...citedClaimIds].sort(),
+            uncited_key_claim_ids: uncitedKeyClaimIds
+        },
+        sources: rowReports
+    };
+}
+export async function readSourceQualityReport(dir) {
+    return readJson(path.join(dir, SOURCE_QUALITY_REPORT_ARTIFACT), null);
+}
+export async function writeSourceQualityReport(dir, sourceLedger = null, claimMatrix = null) {
+    const report = buildSourceQualityReport(sourceLedger, claimMatrix);
+    await writeJsonAtomic(path.join(dir, SOURCE_QUALITY_REPORT_ARTIFACT), report);
+    return report;
+}
+//# sourceMappingURL=source-quality-report.js.map