sneakoscope 2.0.13 → 2.0.15

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

@@ -0,0 +1,114 @@
+import { normalizeClaimEvidenceMatrix } from './claim-evidence-matrix.js';
+export async function buildClaimEvidenceMatrixFromSourceShards(input) {
+    const sources = [
+        ...(Array.isArray(input.sourceLedger?.sources) ? input.sourceLedger.sources : []),
+        ...(Array.isArray(input.sourceLedger?.counterevidence_sources) ? input.sourceLedger.counterevidence_sources : [])
+    ];
+    const noveltyEntries = Array.isArray(input.noveltyLedger?.entries) ? input.noveltyLedger.entries : [];
+    const candidates = new Map();
+    for (const entry of noveltyEntries) {
+        const id = String(entry?.id || '').trim();
+        if (!id)
+            continue;
+        candidates.set(id, {
+            id,
+            claim: String(entry?.claim || entry?.title || id),
+            claim_type: entry?.type === 'implementation_guidance' ? 'implementation_guidance' : 'hypothesis',
+            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()
+        });
+    }
+    for (const source of sources) {
+        const claimIds = normalizeStringList(source?.claim_ids);
+        if (claimIds.length) {
+            for (const claimId of claimIds) {
+                const existing = candidates.get(claimId) || {
+                    id: claimId,
+                    claim: claimTextFromSource(source, claimId),
+                    claim_type: 'inference',
+                    importance: candidates.size < 2 ? 'critical' : candidates.size < 8 ? 'high' : 'medium',
+                    source_ids: [],
+                    counterevidence_ids: [],
+                    test_or_probe: ''
+                };
+                if (source?.stance === 'undermines')
+                    existing.counterevidence_ids = [...new Set([...(existing.counterevidence_ids || []), source.id])];
+                else
+                    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}`;
+            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.`
+            });
+        }
+    }
+    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 layers = sourceLayersForSourceIds(sources, [...sourceIds, ...counterIds]);
+        return {
+            id: candidate.id,
+            claim: candidate.claim,
+            claim_type: candidate.claim_type,
+            importance: candidate.importance || (index < 2 ? 'critical' : 'high'),
+            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,
+            triangulation: {
+                source_layers: layers,
+                independent_confirmation_count: layers.length,
+                conflicts: counterIds.length ? [`counterevidence:${counterIds.join(',')}`] : []
+            },
+            confidence: layers.length >= 3 && counterIds.length ? 'high' : layers.length >= 2 ? 'medium' : 'low',
+            falsifiable: true,
+            test_or_probe: candidate.test_or_probe || `Run a source-layer replication probe for ${candidate.id}.`
+        };
+    });
+    const unsupported = claims
+        .filter((claim) => {
+        const important = claim.importance === 'high' || claim.importance === 'critical';
+        return important && (claim.triangulation.source_layers.length < 2 || (claim.importance === 'critical' && claim.counterevidence_ids.length === 0));
+    })
+        .map((claim) => claim.id);
+    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),
+        unsupported_claims: unsupported,
+        triangulated_claim_count: claims.filter((claim) => claim.triangulation.source_layers.length >= 2).length,
+        blockers: unsupported.map((id) => `unsupported_important_claim:${id}`)
+    });
+}
+function claimTextFromSource(source, claimId) {
+    const notes = String(source?.notes || '').trim();
+    if (notes)
+        return `${claimId}: ${notes.slice(0, 220)}`;
+    return `${claimId}: Evidence row ${source?.id || 'unknown'} contributes to this research claim.`;
+}
+function sourceById(sources, id) {
+    return sources.find((source) => String(source?.id || '') === id) || null;
+}
+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 normalizeStringList(value) {
+    return [...new Set((Array.isArray(value) ? value : value == null ? [] : [value]).map((item) => String(item || '').trim()).filter(Boolean))];
+}
+//# sourceMappingURL=research-claim-builder.js.map

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

@@ -1,25 +1,129 @@
 import path from 'node:path';
 import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
 import { runResearchStage } from './research-stage-runner.js';
-export async function runResearchCycle(dir, graph = null, opts = {}) {
+export async function runResearchCycle(inputOrDir, legacyGraph = null, legacyOpts = {}) {
+    const input = typeof inputOrDir === 'string'
+        ? {
+            root: process.cwd(),
+            dir: inputOrDir,
+            plan: null,
+            graph: legacyGraph,
+            cycle: Number(legacyOpts.cycle || 0),
+            backend: legacyOpts.mock ? 'mock' : 'deterministic',
+            timeoutMs: Number(legacyOpts.timeoutMs || 120000),
+            maxParallelStages: Number(legacyOpts.maxParallelStages || legacyOpts.maxParallel || 4),
+            mock: legacyOpts.mock === true
+        }
+        : inputOrDir;
     const startedAt = nowIso();
-    const stages = Array.isArray(graph?.work_items) ? graph.work_items : [];
-    const stageResults = [];
-    for (const stage of stages) {
-        stageResults.push(await runResearchStage(dir, stage, { status: opts.status || 'planned', startedAt }));
+    const stages = normalizeStages(input.graph);
+    const pending = new Map(stages.map((stage) => [String(stage.id), stage]));
+    const completed = new Map();
+    const running = new Map();
+    const blockers = [];
+    const maxParallel = Math.max(1, Math.min(16, Number(input.maxParallelStages || 4)));
+    let maxObservedParallel = 0;
+    while (pending.size || running.size) {
+        const ready = readyStages([...pending.values()], completed);
+        while (running.size < maxParallel && ready.length) {
+            const stage = ready.shift();
+            if (!stage)
+                break;
+            pending.delete(String(stage.id));
+            const promise = runResearchStage({ ...input, stage }).catch((err) => failureStage(input, stage, err));
+            running.set(String(stage.id), promise);
+            maxObservedParallel = Math.max(maxObservedParallel, running.size);
+        }
+        if (!running.size) {
+            const blockedIds = [...pending.keys()];
+            blockers.push(...blockedIds.map((id) => `stage_dependencies_unresolved:${id}`));
+            for (const stage of pending.values()) {
+                const failed = failureStage(input, stage, new Error(`dependencies unresolved: ${(stage.dependencies || []).join(',')}`));
+                completed.set(String(stage.id), failed);
+            }
+            pending.clear();
+            break;
+        }
+        const done = await Promise.race([...running.entries()].map(async ([id, promise]) => ({ id, result: await promise })));
+        running.delete(done.id);
+        completed.set(done.id, done.result);
+        if (done.result.status !== 'passed' && pendingStageRequired(stages.find((stage) => String(stage.id) === done.id))) {
+            blockers.push(...(done.result.blockers.length ? done.result.blockers.map((blocker) => `${done.id}:${blocker}`) : [`${done.id}:stage_not_passed`]));
+        }
     }
+    const stageResults = [...completed.values()];
     const record = {
-        schema: 'sks.research-cycle-runner.v1',
-        cycle: opts.cycle || 0,
+        schema: 'sks.research-cycle-runner.v2',
+        cycle: input.cycle,
         readonly: true,
         started_at: startedAt,
         completed_at: nowIso(),
         stage_count: stageResults.length,
-        status: opts.status || 'planned',
-        stages: stageResults.map((stage) => stage.stage_id)
+        status: blockers.length ? 'blocked' : 'passed',
+        blockers: [...new Set(blockers)],
+        stages: stageResults.map((stage) => stage.stage_id),
+        stage_results: stageResults,
+        parallelism: {
+            max_parallel_stages: maxParallel,
+            max_observed_parallel: maxObservedParallel,
+            stage_count: stageResults.length,
+            critical_path_length: criticalPathLength(stages)
+        },
+        legacy_final_md_loop: false
     };
-    await writeJsonAtomic(path.join(dir, 'research-cycle-runner.json'), record);
-    await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle_runner.recorded', cycle: record.cycle, stage_count: record.stage_count });
+    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 function readyStages(pending, completed) {
+    return pending.filter((stage) => (Array.isArray(stage.dependencies) ? stage.dependencies : []).every((id) => completed.has(String(id))));
+}
+function normalizeStages(graph) {
+    const stages = Array.isArray(graph?.work_items) ? graph.work_items : [];
+    return stages.map((stage, index) => ({
+        ...stage,
+        id: String(stage?.id || `research-stage-${index + 1}`),
+        dependencies: Array.isArray(stage?.dependencies) ? stage.dependencies.map(String) : []
+    }));
+}
+function pendingStageRequired(stage) {
+    return stage?.required !== false;
+}
+function failureStage(input, stage, err) {
+    const ts = nowIso();
+    return {
+        schema: 'sks.research-stage-result.v1',
+        mission_id: String(input.plan?.mission_id || ''),
+        cycle: input.cycle,
+        stage_id: String(stage?.id || 'unknown'),
+        stage_kind: 'verification',
+        status: 'failed',
+        started_at: ts,
+        completed_at: ts,
+        input_artifacts: [],
+        output_artifacts: [],
+        backend: input.backend,
+        worker_result_path: null,
+        blockers: [err instanceof Error ? err.message : String(err)],
+        metrics: {}
+    };
+}
+function criticalPathLength(stages) {
+    const byId = new Map(stages.map((stage) => [String(stage.id), stage]));
+    const memo = new Map();
+    const visit = (id, seen = new Set()) => {
+        if (memo.has(id))
+            return memo.get(id);
+        if (seen.has(id))
+            return 1;
+        seen.add(id);
+        const stage = byId.get(id);
+        const deps = Array.isArray(stage?.dependencies) ? stage.dependencies.map(String) : [];
+        const value = 1 + (deps.length ? Math.max(...deps.map((dep) => visit(dep, new Set(seen)))) : 0);
+        memo.set(id, value);
+        return value;
+    };
+    return stages.length ? Math.max(...stages.map((stage) => visit(String(stage.id)))) : 0;
+}
 //# sourceMappingURL=research-cycle-runner.js.map

package/dist/core/research/research-final-reviewer.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-task-runner.js';
 import { analyzeResearchReportQuality } from './research-report-quality.js';
 import { validateClaimEvidenceMatrix } from './claim-evidence-matrix.js';
 import { validateImplementationBlueprint } from './implementation-blueprint.js';
@@ -7,10 +8,12 @@ import { validateExperimentPlan } from './experiment-plan.js';
 import { validateReplicationPack } from './replication-pack.js';
 import { validateFalsificationCoverage } from './falsification.js';
 export const RESEARCH_FINAL_REVIEW_ARTIFACT = 'research-final-review.json';
+export const RESEARCH_STATIC_FINAL_REVIEW_ARTIFACT = 'research-final-review.static.json';
+export const RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT = 'research-final-review.codex.json';
 export async function readResearchFinalReview(dir) {
     return readJson(path.join(dir, RESEARCH_FINAL_REVIEW_ARTIFACT), null);
 }
-export async function runResearchFinalReviewer(dir, input = {}) {
+export async function runResearchStaticFinalReview(dir, input = {}) {
     const contract = input.contract || await readJson(path.join(dir, 'research-quality-contract.json'), null);
     const sourceLedger = input.sourceLedger || await readJson(path.join(dir, 'source-ledger.json'), null);
     const claimMatrix = input.claimMatrix || await readJson(path.join(dir, 'claim-evidence-matrix.json'), null);
@@ -52,7 +55,184 @@ export async function runResearchFinalReviewer(dir, input = {}) {
         },
         reviewer: 'research_final_reviewer_static_gate'
     };
+    await writeJsonAtomic(path.join(dir, RESEARCH_STATIC_FINAL_REVIEW_ARTIFACT), review);
+    return review;
+}
+export async function runResearchCodexFinalReviewer(input) {
+    if (input.staticReview?.approved !== true) {
+        const skipped = {
+            schema: 'sks.research-codex-final-review.v1',
+            reviewed_at: nowIso(),
+            verdict: 'revise',
+            unsupported_claim_ids: [],
+            missing_evidence: [],
+            blueprint_findings: [],
+            falsification_findings: [],
+            template_like_prose: true,
+            source_density_ok: false,
+            implementation_concreteness_ok: false,
+            evidence_bound_synthesis_ok: false,
+            required_revisions: ['static_review_failed'],
+            confidence: 'low',
+            skipped: true,
+            skip_reason: 'static_review_failed'
+        };
+        await writeJsonAtomic(path.join(input.dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), skipped);
+        return skipped;
+    }
+    if (input.mock === true) {
+        const approved = {
+            schema: 'sks.research-codex-final-review.v1',
+            reviewed_at: nowIso(),
+            verdict: 'approve',
+            unsupported_claim_ids: [],
+            missing_evidence: [],
+            blueprint_findings: ['mock final reviewer approves the complete package fixture'],
+            falsification_findings: ['mock counterevidence and falsification cases are present'],
+            template_like_prose: false,
+            source_density_ok: true,
+            implementation_concreteness_ok: true,
+            evidence_bound_synthesis_ok: true,
+            required_revisions: [],
+            confidence: 'high',
+            mock: true
+        };
+        await writeJsonAtomic(path.join(input.dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), approved);
+        return approved;
+    }
+    const result = await runCodexTask({
+        route: '$Research',
+        tier: 'worker',
+        missionId: String(input.plan?.mission_id || 'research-final-review'),
+        workItemId: 'research_final_review',
+        cwd: input.root,
+        prompt: buildResearchFinalReviewPrompt(input.plan, input.staticReview),
+        outputSchema: researchCodexFinalReviewSchema,
+        outputSchemaId: 'sks.research-codex-final-review.v1',
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: {
+            id: 'research-final-review',
+            route: '$Research',
+            read_only: true,
+            allowed_paths: [`.sneakoscope/missions/${input.plan?.mission_id || ''}/`],
+            write_paths: [],
+            allowed_write_prefixes: [`.sneakoscope/missions/${input.plan?.mission_id || ''}/`],
+            source_mutation_allowed: false
+        },
+        backendPreference: input.backendPreference || ['codex-sdk', 'python-codex-sdk'],
+        localLlmPolicy: { mode: 'disabled', requiresGptFinal: true },
+        allowLocalLlm: false,
+        mutationLedgerRoot: path.join(input.dir, 'research', 'final-review-codex-control'),
+        reliabilityPolicy: {
+            timeoutClass: 'standard',
+            idleTimeoutMs: input.timeoutMs || 120000
+        }
+    });
+    const worker = await readJson(result.workerResultPath, null);
+    const review = normalizeCodexReview(worker, result);
+    await writeJsonAtomic(path.join(input.dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), review);
+    return review;
+}
+export async function runResearchFinalReviewer(dir, input = {}) {
+    const staticReview = await runResearchStaticFinalReview(dir, input);
+    const existingCodex = await readJson(path.join(dir, RESEARCH_CODEX_FINAL_REVIEW_ARTIFACT), null);
+    const codexReview = existingCodex || (input.mock === true ? await runResearchCodexFinalReviewer({
+        root: input.root || process.cwd(),
+        dir,
+        plan: input.plan || await readJson(path.join(dir, 'research-plan.json'), null),
+        staticReview,
+        mock: true
+    }) : null);
+    const codexApproved = codexReview?.verdict === 'approve';
+    const codexRequired = input.codexRequired !== false;
+    const blockers = [
+        ...(Array.isArray(staticReview?.blockers) ? staticReview.blockers : []),
+        ...(codexRequired && !codexReview ? ['research_codex_final_review_missing'] : []),
+        ...(codexReview && !codexApproved ? ['research_codex_final_review_not_approved'] : []),
+        ...(codexReview?.template_like_prose === true ? ['research_codex_template_like_prose'] : []),
+        ...(codexReview && codexReview.source_density_ok === false ? ['research_codex_source_density_not_ok'] : []),
+        ...(codexReview && codexReview.implementation_concreteness_ok === false ? ['research_codex_implementation_concreteness_not_ok'] : []),
+        ...(codexReview && codexReview.evidence_bound_synthesis_ok === false ? ['research_codex_evidence_bound_synthesis_not_ok'] : []),
+        ...(Array.isArray(codexReview?.required_revisions) ? codexReview.required_revisions.map((revision) => `codex_revision:${revision}`) : [])
+    ];
+    const review = {
+        schema: 'sks.research-final-reviewer.v2',
+        reviewed_at: nowIso(),
+        approved: staticReview?.approved === true && (!codexRequired || codexApproved) && blockers.length === 0,
+        blockers: [...new Set(blockers)],
+        static_review: staticReview,
+        codex_review: codexReview,
+        reviewer: 'research_final_reviewer_static_plus_codex_gate'
+    };
     await writeJsonAtomic(path.join(dir, RESEARCH_FINAL_REVIEW_ARTIFACT), review);
     return review;
 }
+function buildResearchFinalReviewPrompt(plan, staticReview) {
+    return [
+        'You are the Codex/GPT final reviewer for an SKS Research package.',
+        `Mission: ${plan?.mission_id || 'unknown'}`,
+        `Prompt: ${plan?.prompt || ''}`,
+        '',
+        'Review the mission artifacts read-only. Reject if claims lack evidence, blueprint steps are template-like, falsification is missing, or the package is only a short summary.',
+        'Reject repeated paragraphs, template-like prose, unsupported synthesis, source IDs that do not exist in source-ledger, and implementation blueprints that lack concrete files/tests.',
+        'Set template_like_prose=true for repeated or boilerplate reports. Set source_density_ok=false for sparse source ids. Set implementation_concreteness_ok=false for weak file/test/rollback plans. Set evidence_bound_synthesis_ok=false when recommendations are not tied to evidence.',
+        'Return only JSON matching sks.research-codex-final-review.v1 with verdict approve, revise, or reject.',
+        '',
+        `Static review summary:\n${JSON.stringify(staticReview, null, 2).slice(0, 12000)}`
+    ].join('\n');
+}
+function normalizeCodexReview(worker, result) {
+    if (!result?.ok) {
+        return {
+            schema: 'sks.research-codex-final-review.v1',
+            reviewed_at: nowIso(),
+            verdict: 'revise',
+            unsupported_claim_ids: [],
+            missing_evidence: [],
+            blueprint_findings: [],
+            falsification_findings: [],
+            template_like_prose: false,
+            source_density_ok: false,
+            implementation_concreteness_ok: false,
+            evidence_bound_synthesis_ok: false,
+            required_revisions: Array.isArray(result?.blockers) ? result.blockers : ['codex_final_reviewer_unavailable'],
+            confidence: 'low',
+            worker_result_path: result?.workerResultPath || null
+        };
+    }
+    return {
+        schema: 'sks.research-codex-final-review.v1',
+        reviewed_at: nowIso(),
+        verdict: ['approve', 'revise', 'reject'].includes(worker?.verdict) ? worker.verdict : 'revise',
+        unsupported_claim_ids: Array.isArray(worker?.unsupported_claim_ids) ? worker.unsupported_claim_ids.map(String) : [],
+        missing_evidence: Array.isArray(worker?.missing_evidence) ? worker.missing_evidence.map(String) : [],
+        blueprint_findings: Array.isArray(worker?.blueprint_findings) ? worker.blueprint_findings.map(String) : [],
+        falsification_findings: Array.isArray(worker?.falsification_findings) ? worker.falsification_findings.map(String) : [],
+        template_like_prose: worker?.template_like_prose === true,
+        source_density_ok: worker?.source_density_ok === true,
+        implementation_concreteness_ok: worker?.implementation_concreteness_ok === true,
+        evidence_bound_synthesis_ok: worker?.evidence_bound_synthesis_ok === true,
+        required_revisions: Array.isArray(worker?.required_revisions) ? worker.required_revisions.map(String) : [],
+        confidence: ['low', 'medium', 'high'].includes(worker?.confidence) ? worker.confidence : 'medium',
+        worker_result_path: result.workerResultPath
+    };
+}
+export const researchCodexFinalReviewSchema = {
+    type: 'object',
+    required: ['schema', 'verdict', 'unsupported_claim_ids', 'missing_evidence', 'blueprint_findings', 'falsification_findings', 'template_like_prose', 'source_density_ok', 'implementation_concreteness_ok', 'evidence_bound_synthesis_ok', 'required_revisions', 'confidence'],
+    properties: {
+        schema: { const: 'sks.research-codex-final-review.v1' },
+        verdict: { enum: ['approve', 'revise', 'reject'] },
+        unsupported_claim_ids: { type: 'array' },
+        missing_evidence: { type: 'array' },
+        blueprint_findings: { type: 'array' },
+        falsification_findings: { type: 'array' },
+        template_like_prose: { type: 'boolean' },
+        source_density_ok: { type: 'boolean' },
+        implementation_concreteness_ok: { type: 'boolean' },
+        evidence_bound_synthesis_ok: { type: 'boolean' },
+        required_revisions: { type: 'array' },
+        confidence: { enum: ['low', 'medium', 'high'] }
+    }
+};
 //# sourceMappingURL=research-final-reviewer.js.map

package/dist/core/research/research-handoff.js

@@ -1,15 +1,23 @@
 import path from 'node:path';
-import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { nowIso, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 export const IMPLEMENTATION_HANDOFF_PATCH_PLAN_ARTIFACT = 'implementation-handoff.patch-plan.json';
 export const TEAM_HANDOFF_GOAL_ARTIFACT = 'team-handoff-goal.md';
 export const DECISION_LOG_ARTIFACT = 'decision-log.md';
 export async function writeResearchHandoffArtifacts(dir, plan = null, blueprint = null) {
+    const claimMatrix = await readJson(path.join(dir, 'claim-evidence-matrix.json'), null);
+    const sourceLedger = await readJson(path.join(dir, 'source-ledger.json'), null);
+    const claims = Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : [];
+    const sourceRows = [
+        ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+    ];
+    const workItems = parallelWorkItems(blueprint);
     const patchPlan = {
         schema: 'sks.research-implementation-handoff-patch-plan.v1',
         generated_at: nowIso(),
         mission_id: plan?.mission_id || null,
         implementation_allowed_in_research: false,
-        intended_route: '$Team',
+        intended_route: '$Naruto',
         prompt: plan?.prompt || '',
         source_artifacts: [
             'research-report.md',
@@ -20,20 +28,55 @@ export async function writeResearchHandoffArtifacts(dir, plan = null, blueprint
             'source-quality-report.json'
         ],
         proposed_changes: [],
+        parallel_work_items: workItems,
         notes: [
             'This is a handoff artifact. Research records implementation guidance but does not mutate repository source.'
         ]
     };
     const goalLines = [
-        '# Research-To-Team Handoff Goal',
+        '# Research-To-Naruto Handoff Goal',
+        '',
+        '## Context',
         '',
         `Mission: ${plan?.mission_id || 'unknown'}`,
         `Prompt: ${plan?.prompt || ''}`,
+        'Route: Use `$Naruto` for implementation, integration, and parallel non-overlapping lanes.',
         '',
         'Use the implementation blueprint, claim-evidence matrix, source-quality report, experiment plan, replication pack, and final reviewer output before changing code.',
         '',
-        'Blueprint sections:',
-        ...(Array.isArray(blueprint?.sections) ? blueprint.sections.map((section) => `- ${section.id}: ${section.title}`) : [])
+        '## Key Claims',
+        '',
+        ...(claims.length ? claims.slice(0, 8).map((claim) => `- ${claim.id}: ${claim.claim} Sources: ${normalizeList(claim.source_ids).join(', ') || 'explicit blocker: source ids missing'}. Counterevidence: ${normalizeList(claim.counterevidence_ids).join(', ') || 'explicit blocker: counterevidence missing'}.`) : ['- explicit blocker: claim-evidence-matrix.json has no claim rows.']),
+        '',
+        '## Evidence Summary',
+        '',
+        `- Source rows: ${sourceRows.length}.`,
+        `- Key claims: ${Array.isArray(claimMatrix?.key_claim_ids) ? claimMatrix.key_claim_ids.length : 0}.`,
+        `- Counterevidence rows: ${Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources.length : 0}.`,
+        '- Read `source-quality-report.json` and `research-final-review.json` before implementation.',
+        '',
+        '## Implementation Blueprint',
+        '',
+        ...(Array.isArray(blueprint?.sections) ? blueprint.sections.map((section) => `- ${section.id}: ${section.title}. Files: ${normalizeList(section.target_paths).join(', ') || 'explicit blocker: no target paths'}. Checks: ${normalizeList(section.acceptance_checks).join(' | ') || 'explicit blocker: no acceptance checks'}.`) : ['- explicit blocker: implementation-blueprint.json missing sections.']),
+        '',
+        '## Parallel Work Items',
+        '',
+        ...workItems.map((item, index) => `${index + 1}. ${item.title}. Files: ${item.files.length ? item.files.join(', ') : 'explicit blocker: file list missing'}. Tests: ${item.tests.length ? item.tests.join(', ') : 'explicit blocker: tests missing'}. Acceptance: ${item.acceptance}.`),
+        '',
+        '## Acceptance Tests',
+        '',
+        ...normalizeList(blueprint?.test_commands).map((command) => `- ${command}`),
+        ...(normalizeList(blueprint?.test_commands).length ? [] : ['- explicit blocker: no test commands in implementation blueprint.']),
+        '',
+        '## Rollback Plan',
+        '',
+        ...normalizeList(blueprint?.rollback_steps).map((step) => `- ${step}`),
+        ...(normalizeList(blueprint?.rollback_steps).length ? [] : ['- explicit blocker: no rollback steps in implementation blueprint.']),
+        '',
+        '## Source Appendix',
+        '',
+        ...sourceRows.slice(0, 20).map((source) => `- ${source.id}: ${source.title || source.locator || 'source row'}; claims=${normalizeList(source.claim_ids).join(', ') || 'none'}.`),
+        ...(sourceRows.length ? [] : ['- explicit blocker: source-ledger.json has no source rows.'])
     ];
     const decisionLog = [
         '# Research Decision Log',
@@ -48,4 +91,25 @@ export async function writeResearchHandoffArtifacts(dir, plan = null, blueprint
     await writeTextAtomic(path.join(dir, DECISION_LOG_ARTIFACT), `${decisionLog.join('\n')}\n`);
     return { patch_plan: patchPlan, goal_artifact: TEAM_HANDOFF_GOAL_ARTIFACT, decision_log: DECISION_LOG_ARTIFACT };
 }
+function parallelWorkItems(blueprint) {
+    const sections = Array.isArray(blueprint?.sections) ? blueprint.sections : [];
+    const fallbackFiles = normalizeList(blueprint?.existing_files).slice(0, 8);
+    const tests = normalizeList(blueprint?.test_commands);
+    const rows = normalizeList(blueprint?.parallel_work_decomposition);
+    const source = rows.length >= 4 ? rows : ['Synthesis writer lane', 'Report quality lane', 'Final reviewer lane', 'Release and docs lane'];
+    return source.slice(0, Math.max(4, source.length)).map((title, index) => {
+        const section = sections[index % Math.max(1, sections.length)] || {};
+        const files = normalizeList(section.target_paths).length ? normalizeList(section.target_paths) : fallbackFiles.slice(index, index + 3);
+        return {
+            id: `handoff-work-${index + 1}`,
+            title,
+            files,
+            tests: tests.slice(0, 3),
+            acceptance: normalizeList(section.acceptance_checks).join(' | ') || 'Complete the lane and rerun the relevant research gate.'
+        };
+    });
+}
+function normalizeList(value) {
+    return [...new Set((Array.isArray(value) ? value : value == null ? [] : [value]).map((item) => String(item || '').trim()).filter(Boolean))];
+}
 //# sourceMappingURL=research-handoff.js.map