sneakoscope 2.0.11 → 2.0.13

package/dist/core/codex-control/codex-sdk-adapter.js

@@ -1,5 +1,8 @@
+import path from 'node:path';
+import { appendJsonl } from '../fsx.js';
 import { buildCodexSdkConfig } from './codex-sdk-config-policy.js';
 import { buildCodexSdkEnv } from './codex-sdk-env-policy.js';
+import { translateCodexSdkEvent } from './codex-event-translator.js';
 export async function runRealCodexSdkTask(input, policy) {
     const mod = await import('@openai/codex-sdk');
     const Codex = mod.Codex || mod.default?.Codex || mod.default;
@@ -22,9 +25,15 @@ export async function runRealCodexSdkTask(input, policy) {
     const thread = resumeId ? codex.resumeThread(resumeId, threadOptions) : codex.startThread(threadOptions);
     const events = [];
     let finalResponse = '';
+    let liveEventsWritten = false;
+    const liveEventPath = input.mutationLedgerRoot ? path.join(input.mutationLedgerRoot, 'codex-sdk-events.jsonl') : null;
     const streamed = await thread.runStreamed(buildSdkInput(input), { outputSchema: input.outputSchema });
     for await (const event of streamed.events) {
         events.push(event);
+        if (liveEventPath) {
+            await appendJsonl(liveEventPath, translateCodexSdkEvent(event));
+            liveEventsWritten = true;
+        }
         if (event?.type === 'item.completed' && event?.item?.type === 'agent_message')
             finalResponse = String(event.item.text || '');
     }
@@ -37,6 +46,7 @@ export async function runRealCodexSdkTask(input, policy) {
         finalResponse,
         structuredOutput,
         blockers: [],
+        liveEventsWritten,
         raw: { item_count: events.filter((event) => String(event?.type || '').startsWith('item.')).length }
     };
 }

package/dist/core/codex-control/codex-task-runner.js

@@ -67,8 +67,10 @@ export async function runCodexTask(input) {
     }
     const events = Array.isArray(adapterResult?.events) ? adapterResult.events : [];
     const translatedEvents = translateCodexSdkEvents(events);
-    for (const event of translatedEvents)
-        await appendJsonl(path.join(root, 'codex-sdk-events.jsonl'), event);
+    if (adapterResult?.liveEventsWritten !== true) {
+        for (const event of translatedEvents)
+            await appendJsonl(path.join(root, 'codex-sdk-events.jsonl'), event);
+    }
     if (adapterResult?.reliabilityShield)
         await writeJsonAtomic(path.join(root, 'codex-reliability-shield.json'), adapterResult.reliabilityShield);
     const structuredOutput = adapterResult?.structuredOutput;

package/dist/core/commands/naruto-command.js

@@ -94,7 +94,7 @@ async function narutoRun(parsed) {
     const localWorker = await resolveNarutoLocalWorkerMode(parsed);
     const schedulerBackend = localWorker.auto_select_eligible ? 'ollama' : parsed.backend;
     const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
-    const workGraph = buildNarutoWorkGraph({
+    const baseWorkGraph = buildNarutoWorkGraph({
         prompt: parsed.prompt,
         requestedClones: roster.agent_count,
         totalWorkItems: parsed.workItems,
@@ -104,9 +104,21 @@ async function narutoRun(parsed) {
         maxActiveWorkers: parsed.concurrency || safe.cap,
         worktreePolicy
     });
+    const baseRoleDistribution = buildNarutoRoleDistribution(baseWorkGraph.work_items, { readonly: parsed.readonly });
+    const allocationWorkers = buildNarutoAllocationWorkers(baseWorkGraph, baseRoleDistribution, roster);
+    const allocationAssignments = allocateNarutoTasksToWorkers(baseWorkGraph.work_items, allocationWorkers);
+    const workGraph = buildNarutoWorkGraph({
+        prompt: parsed.prompt,
+        requestedClones: roster.agent_count,
+        totalWorkItems: parsed.workItems,
+        readonly: parsed.readonly,
+        writeCapable,
+        leaseBasePath: patchEnvelopeBasePath,
+        maxActiveWorkers: parsed.concurrency || safe.cap,
+        worktreePolicy,
+        allocationAssignments
+    });
     const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
-    const allocationWorkers = buildNarutoAllocationWorkers(workGraph, roleDistribution, roster);
-    const allocationAssignments = allocateNarutoTasksToWorkers(workGraph.work_items, allocationWorkers);
     const allocationPolicy = {
         schema: 'sks.naruto-allocation-policy.v1',
         generated_at: nowIso(),
@@ -135,7 +147,7 @@ async function narutoRun(parsed) {
         blockers: allocationWorkers.length ? [] : ['naruto_allocation_workers_missing']
     };
     const rebalanceDecisions = rebalanceNarutoReadyWork({
-        tasks: workGraph.work_items.map((item) => ({ ...item, owner: null, status: 'pending' })),
+        tasks: workGraph.work_items.map((item) => ({ ...item, status: 'pending' })),
         workers: allocationWorkers.map((worker) => ({ ...worker, alive: true, state: 'idle' })),
         completedTaskIds: [],
         reclaimedTaskIds: []
@@ -159,52 +171,38 @@ async function narutoRun(parsed) {
     const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
     const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
     const activePool = await runNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
-    const realRuntimeSmokeGraph = buildNarutoWorkGraph({
-        prompt: parsed.prompt,
-        requestedClones: Math.min(2, roster.agent_count),
-        totalWorkItems: Math.min(2, workGraph.total_work_items),
-        readonly: true,
-        writeCapable: false,
-        leaseBasePath: patchEnvelopeBasePath,
-        maxActiveWorkers: Math.min(2, activeSlots),
-        worktreePolicy: {
-            mode: 'patch-envelope-only',
-            required: false,
-            main_repo_root: worktreePolicy.main_repo_root,
-            worktree_root: null,
-            fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
-        }
-    });
-    const realRuntimeWorktreePolicy = {
-        mode: 'patch-envelope-only',
-        required: false,
-        main_repo_root: worktreePolicy.main_repo_root,
-        worktree_root: null,
-        fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
-    };
-    const realActivePool = await runNarutoRealActivePool({
-        graph: realRuntimeSmokeGraph,
-        governor: { ...governor, safe_active_workers: Math.min(2, activeSlots), safe_zellij_visible_panes: Math.min(1, zellijVisiblePanes) },
-        spawnWorker: async (item, placement) => spawnActualNarutoWorker({
+    const runPreRunSmoke = parsed.smoke === true || process.env.SKS_NARUTO_PRE_RUN_SMOKE === '1';
+    const realActivePoolSmoke = runPreRunSmoke
+        ? await runNarutoControlPlaneSmoke({
             root,
             missionId: mission.id,
-            item,
-            placement,
-            backend: 'fake',
-            worktreePolicy: realRuntimeWorktreePolicy,
-            zellijSessionName: `sks-${mission.id}`,
-            visiblePaneCap: zellijVisiblePanes
-        }),
-        collectWorker: async (handle) => collectActualNarutoWorker(handle),
-        enqueueVerification: async () => undefined,
-        updateDashboard: async () => undefined
-    });
-    const realActivePoolSmoke = {
-        ...realActivePool,
-        runtime_source_of_truth: 'pre_run_smoke_only',
-        production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
-        smoke_graph_total_work_items: realRuntimeSmokeGraph.total_work_items
-    };
+            prompt: parsed.prompt,
+            rosterCount: roster.agent_count,
+            totalWorkItems: workGraph.total_work_items,
+            patchEnvelopeBasePath,
+            worktreePolicy,
+            governor,
+            activeSlots,
+            zellijVisiblePanes
+        })
+        : {
+            schema: 'sks.naruto-active-pool.v1',
+            ok: true,
+            status: 'skipped',
+            runtime_source_of_truth: 'agent-orchestrator-scheduler',
+            production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
+            fallback_reason: 'pre_run_smoke_never_owns_production_runtime',
+            reason: 'pre_run_smoke_disabled_for_production',
+            active_cap: 0,
+            max_observed_active_workers: 0,
+            average_active_workers: 0,
+            active_pool_utilization: 0,
+            refill_latency_ms_p95: 0,
+            visible_workers: 0,
+            headless_workers: 0,
+            worker_lifecycle: [],
+            smoke_graph_total_work_items: 0
+        };
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
     const gptFinalPack = buildNarutoGptFinalPack({
         missionId: mission.id,
@@ -284,7 +282,8 @@ async function narutoRun(parsed) {
         concurrency: activeSlots,
         targetActiveSlots: activeSlots,
         visualLaneCount: zellijVisiblePanes,
-        desiredWorkItemCount: parsed.workItems,
+        desiredWorkItemCount: workGraph.total_work_items,
+        minimumWorkItems: workGraph.total_work_items,
         maxAgentCount: MAX_NARUTO_AGENT_COUNT,
         narutoMode: true,
         clones: roster.agent_count,
@@ -307,6 +306,9 @@ async function narutoRun(parsed) {
         noFast: false,
         writeMode: writeCapable ? parsed.writeMode || 'parallel' : 'off',
         gitWorktreePolicy: worktreePolicy,
+        narutoWorkGraph: workGraph,
+        narutoAllocationPolicy: allocationPolicy,
+        narutoRebalancePolicy: rebalancePolicy,
         json: parsed.json
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
@@ -323,7 +325,7 @@ async function narutoRun(parsed) {
         concurrency: result.target_active_slots ?? activeSlots,
         target_active_slots: result.target_active_slots ?? activeSlots,
         runtime_source_of_truth: 'agent-orchestrator-scheduler',
-        pre_run_real_active_pool_source: 'smoke_only',
+        pre_run_real_active_pool_source: runPreRunSmoke ? 'smoke_only' : 'skipped',
         concurrency_capped: clones > (result.target_active_slots ?? activeSlots),
         system: { cores: safe.cores, free_gb: safe.free_gb, safe_concurrency: safe.cap, heavy_backend: safe.heavy },
         work_graph: {
@@ -409,6 +411,56 @@ function compactNarutoRunResult(result) {
         }
     };
 }
+async function runNarutoControlPlaneSmoke(input) {
+    const smokeGraph = buildNarutoWorkGraph({
+        prompt: input.prompt,
+        requestedClones: Math.min(2, input.rosterCount),
+        totalWorkItems: Math.min(2, input.totalWorkItems),
+        readonly: true,
+        writeCapable: false,
+        leaseBasePath: input.patchEnvelopeBasePath,
+        maxActiveWorkers: Math.min(2, input.activeSlots),
+        worktreePolicy: {
+            mode: 'patch-envelope-only',
+            required: false,
+            main_repo_root: input.worktreePolicy.main_repo_root,
+            worktree_root: null,
+            fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
+        }
+    });
+    const smokeWorktreePolicy = {
+        mode: 'patch-envelope-only',
+        required: false,
+        main_repo_root: input.worktreePolicy.main_repo_root,
+        worktree_root: null,
+        fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
+    };
+    const realActivePool = await runNarutoRealActivePool({
+        graph: smokeGraph,
+        governor: { ...input.governor, safe_active_workers: Math.min(2, input.activeSlots), safe_zellij_visible_panes: Math.min(1, input.zellijVisiblePanes) },
+        spawnWorker: async (item, placement) => spawnActualNarutoWorker({
+            root: input.root,
+            missionId: input.missionId,
+            item,
+            placement,
+            backend: 'fake',
+            worktreePolicy: smokeWorktreePolicy,
+            zellijSessionName: `sks-${input.missionId}`,
+            visiblePaneCap: input.zellijVisiblePanes
+        }),
+        collectWorker: async (handle) => collectActualNarutoWorker(handle),
+        enqueueVerification: async () => undefined,
+        updateDashboard: async () => undefined
+    });
+    return {
+        ...realActivePool,
+        status: 'smoke_completed',
+        runtime_source_of_truth: 'pre_run_smoke_only',
+        production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
+        fallback_reason: 'pre_run_smoke_never_owns_production_runtime',
+        smoke_graph_total_work_items: smokeGraph.total_work_items
+    };
+}
 function buildNarutoAllocationWorkers(workGraph, roleDistribution, roster) {
     const workItems = Array.isArray(workGraph?.work_items) ? workGraph.work_items : [];
     const roleByWorkItem = new Map((roleDistribution?.work_item_roles || []).map((row) => [String(row.work_item_id), String(row.role || '')]));
@@ -582,9 +634,10 @@ function parseNarutoArgs(args = []) {
     const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
     const attach = hasFlag(args, '--attach');
+    const smoke = hasFlag(args, '--smoke');
     const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach };
+    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke };
 }
 async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);

package/dist/core/commands/research-command.js

@@ -14,6 +14,15 @@ import { scanDbSafety } from '../db-safety.js';
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { flag, positionalArgs, readFlagValue, readMaxCycles, readBoundedIntegerFlag, resolveMissionId, safeReadTextFile } from './command-utils.js';
+import { writeResearchWorkGraph } from '../research/research-work-graph.js';
+import { runResearchCycle } from '../research/research-cycle-runner.js';
+import { readResearchQualityContract } from '../research/research-quality-contract.js';
+import { readClaimEvidenceMatrix } from '../research/claim-evidence-matrix.js';
+import { readSourceQualityReport } from '../research/source-quality-report.js';
+import { readImplementationBlueprint, validateImplementationBlueprint } from '../research/implementation-blueprint.js';
+import { readExperimentPlan, validateExperimentPlan } from '../research/experiment-plan.js';
+import { readReplicationPack, validateReplicationPack } from '../research/replication-pack.js';
+import { readResearchFinalReview } from '../research/research-final-reviewer.js';
 const RESEARCH_DEFAULT_MAX_CYCLES = 12;
 const RESEARCH_DEFAULT_CYCLE_TIMEOUT_MINUTES = 120;
 const RESEARCH_MIN_CYCLE_TIMEOUT_MINUTES = 15;
@@ -128,9 +137,12 @@ async function researchRun(args) {
     const dryRunPatches = flag(args, '--dry-run-patches') || flag(args, '--dryrun-patches');
     const maxWriteAgents = readBoundedIntegerFlag(args, '--max-write-agents', Math.min(requestedAgents, 5), 1, 20);
     const mock = flag(args, '--mock');
+    const researchWorkGraph = await writeResearchWorkGraph(dir, plan);
+    const graphWorkItemCount = Math.max(1, Number(researchWorkGraph.total_work_items || researchWorkGraph.work_items?.length || 0));
+    await runResearchCycle(dir, researchWorkGraph, { cycle: 0, status: mock ? 'mock_native_orchestrator_planned' : 'native_orchestrator_planned' });
     await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_RUNNING_NO_QUESTIONS', questions_allowed: false, implementation_allowed: false, research_real_run_required: !mock, research_cycle_timeout_minutes: cycleTimeoutMinutes });
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.run.started', maxCycles, mock, cycleTimeoutMinutes, real_run_required: !mock });
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !(applyPatches && writeMode !== 'off'), profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command' });
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount: Math.max(desiredWorkItemCount, graphWorkItemCount), minimumWorkItems: Math.max(minimumWorkItems, Math.min(graphWorkItemCount, targetActiveSlots)), maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: true, profile, writeMode: writeMode, applyPatches: false, dryRunPatches, maxWriteAgents, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command', narutoWorkGraph: researchWorkGraph });
     await writeJsonAtomic(path.join(dir, 'research-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (mock) {
@@ -141,7 +153,7 @@ async function researchRun(args) {
         const proof = await maybeFinalizeRoute(root, { missionId: id, route: '$Research', gateFile: 'research-gate.json', gate: gate.gate || gate, artifacts: ['agents/agent-proof-evidence.json', 'research-native-agent-run.json', 'research-gate.json', 'research-report.md', researchPaperArtifactForPlan(plan), 'source-ledger.json', 'agent-ledger.json', 'debate-ledger.json', 'completion-proof.json'], mock, command: { cmd: `sks research run ${id} --mock`, status: 0 } });
         await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: gate.passed ? 'RESEARCH_DONE' : 'RESEARCH_PAUSED', questions_allowed: true, implementation_allowed: false });
         if (flag(args, '--json'))
-            return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, proof: proof.validation, native_agent_run: nativeAgentRun, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
+            return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, quality_metrics: gate.metrics || null, proof: proof.validation, native_agent_run: nativeAgentRun, research_work_graph: researchWorkGraph, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
         console.log(`Mock research done: ${id}`);
         console.log(`Gate: ${gate.passed ? 'passed' : 'blocked'}`);
         return;
@@ -178,6 +190,7 @@ async function researchRun(args) {
         const cycleDir = path.join(dir, 'research', `cycle-${cycle}`);
         const outputFile = path.join(cycleDir, 'final.md');
         await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle.start', cycle, timeoutMinutes: cycleTimeoutMinutes, profile, enforced_reasoning_effort: 'xhigh' });
+        await runResearchCycle(dir, researchWorkGraph, { cycle, status: 'codex_research_cycle_started' });
         const prompt = buildResearchPrompt({ id, mission, plan, cycle, previous: last });
         const result = await runCodexExec({ root, prompt, outputFile, json: true, profile, extraArgs: researchCodexArgs, logDir: cycleDir, timeoutMs: cycleTimeoutMs });
         await writeJsonAtomic(path.join(cycleDir, 'process.json'), { code: result.code, stdout_tail: result.stdout, stderr_tail: result.stderr, stdout_bytes: result.stdoutBytes, stderr_bytes: result.stderrBytes, truncated: result.truncated, timed_out: result.timedOut });
@@ -212,7 +225,7 @@ async function researchRun(args) {
             await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.done', cycle });
             await enforceRetention(root).catch(() => { });
             if (flag(args, '--json'))
-                return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, proof: proof.validation, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
+                return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, quality_metrics: gate.metrics || null, proof: proof.validation, research_work_graph: researchWorkGraph, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
             console.log(`Research done: ${id}`);
             return;
         }
@@ -246,6 +259,16 @@ async function researchStatus(args) {
     const agentRows = Array.isArray(agentLedger?.agents) ? agentLedger.agents : [];
     const sourceLayerRows = Array.isArray(sourceLedger?.source_layers) ? sourceLedger.source_layers : [];
     const sourceLayersCovered = sourceLayerRows.filter((layer) => layer.status === 'covered' && ((Array.isArray(layer.source_ids) && layer.source_ids.length) || (Array.isArray(layer.counterevidence_ids) && layer.counterevidence_ids.length))).length;
+    const qualityContract = await readResearchQualityContract(dir);
+    const claimMatrix = await readClaimEvidenceMatrix(dir);
+    const sourceQualityReport = await readSourceQualityReport(dir);
+    const implementationBlueprint = await readImplementationBlueprint(dir);
+    const experimentPlan = await readExperimentPlan(dir);
+    const replicationPack = await readReplicationPack(dir);
+    const finalReview = await readResearchFinalReview(dir);
+    const blueprintValidation = validateImplementationBlueprint(implementationBlueprint, qualityContract);
+    const experimentValidation = validateExperimentPlan(experimentPlan, qualityContract);
+    const replicationValidation = validateReplicationPack(replicationPack);
     console.log(JSON.stringify({
         mission,
         state,
@@ -275,7 +298,23 @@ async function researchStatus(args) {
         research_paper_artifact: paperArtifact.name,
         paper_present: Boolean(paperText.trim()),
         paper_sections: countResearchPaperSections(paperText),
-        falsification_cases: falsificationLedger?.cases?.length ?? null
+        falsification_cases: falsificationLedger?.cases?.length ?? null,
+        research_quality: {
+            contract: qualityContract,
+            report_word_count: gate?.metrics?.report_word_count ?? null,
+            claim_evidence_matrix_present: claimMatrix.present,
+            key_claims: claimMatrix.key_claim_ids.length,
+            triangulated_claims: claimMatrix.triangulated_claim_count,
+            claim_matrix_blockers: claimMatrix.blockers,
+            source_quality_report_ok: sourceQualityReport?.ok === true,
+            implementation_blueprint_sections: Array.isArray(implementationBlueprint?.sections) ? implementationBlueprint.sections.length : null,
+            implementation_blueprint_ok: blueprintValidation.ok,
+            experiment_steps: Array.isArray(experimentPlan?.steps) ? experimentPlan.steps.length : null,
+            experiment_plan_ok: experimentValidation.ok,
+            replication_pack_ok: replicationValidation.ok,
+            final_review_approved: finalReview?.approved === true,
+            final_review_blockers: finalReview?.blockers || []
+        }
     }, null, 2));
 }
 async function researchCodeMutationSnapshot(root, missionId = null) {

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.11';
+export const PACKAGE_VERSION = '2.0.13';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/git/git-worktree-merge-queue.js

@@ -54,14 +54,34 @@ export async function applyGitWorktreeMergeQueue(input) {
             input: diff.diff,
             timeoutMs: 30000
         });
-        if (apply.ok)
+        if (apply.ok) {
             appliedCount += 1;
+            strategyResults.push({
+                ok: true,
+                worker_id: diff.worker_id,
+                strategy: 'diff-apply-3way',
+                commit_hash: null,
+                conflict_files: [],
+                changed_files: diff.changed_files,
+                blockers: []
+            });
+        }
         else {
-            conflicts.push(summarizeGitWorktreeConflict({
+            const conflict = summarizeGitWorktreeConflict({
                 workerId: diff.worker_id,
                 changedFiles: diff.changed_files,
                 stderr: apply.stderr || apply.stdout
-            }));
+            });
+            strategyResults.push({
+                ok: false,
+                worker_id: diff.worker_id,
+                strategy: 'diff-apply-3way',
+                commit_hash: null,
+                conflict_files: conflict.conflict_files || diff.changed_files,
+                changed_files: diff.changed_files,
+                blockers: conflict.blockers || ['git_worktree_diff_apply_failed']
+            });
+            conflicts.push(conflict);
         }
     }
     const blockers = conflicts.length ? ['git_worktree_merge_queue_conflicts'] : [];
@@ -80,44 +100,44 @@ export async function applyGitWorktreeMergeQueue(input) {
     };
 }
 async function applyCheckpointCommit(integrationWorktreePath, checkpoint) {
-    const merge = await runGitCommand(integrationWorktreePath, ['merge', '--no-ff', '--no-edit', checkpoint.commit_hash || ''], {
+    const cherryPick = await runGitCommand(integrationWorktreePath, ['cherry-pick', '--allow-empty', '-X', 'theirs', checkpoint.commit_hash || ''], {
         timeoutMs: 120000
     });
-    if (merge.ok) {
+    if (cherryPick.ok) {
         return {
             ok: true,
             worker_id: checkpoint.worker_id,
-            strategy: 'merge',
+            strategy: 'checkpoint-cherry-pick',
             commit_hash: checkpoint.commit_hash,
             conflict_files: [],
             blockers: []
         };
     }
-    await runGitCommand(integrationWorktreePath, ['merge', '--abort'], { timeoutMs: 30000 }).catch(() => null);
-    const cherryPick = await runGitCommand(integrationWorktreePath, ['cherry-pick', checkpoint.commit_hash || ''], {
+    await runGitCommand(integrationWorktreePath, ['cherry-pick', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    const merge = await runGitCommand(integrationWorktreePath, ['merge', '--no-ff', '--no-edit', '-X', 'theirs', checkpoint.commit_hash || ''], {
         timeoutMs: 120000
     });
-    if (cherryPick.ok) {
+    if (merge.ok) {
         return {
             ok: true,
             worker_id: checkpoint.worker_id,
-            strategy: 'cherry-pick',
+            strategy: 'checkpoint-merge',
             commit_hash: checkpoint.commit_hash,
             conflict_files: [],
             blockers: []
         };
     }
     const conflictFiles = await runGitCommand(integrationWorktreePath, ['diff', '--name-only', '--diff-filter=U'], { timeoutMs: 30000 }).catch(() => null);
-    await runGitCommand(integrationWorktreePath, ['cherry-pick', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    await runGitCommand(integrationWorktreePath, ['merge', '--abort'], { timeoutMs: 30000 }).catch(() => null);
     return {
         ok: false,
         worker_id: checkpoint.worker_id,
-        strategy: 'merge_then_cherry-pick',
+        strategy: 'checkpoint-cherry-pick-then-merge',
         commit_hash: checkpoint.commit_hash,
         conflict_files: String(conflictFiles?.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean),
         blockers: [
-            `git_worktree_checkpoint_merge_failed:${merge.stderr_tail || merge.stdout_tail}`,
-            `git_worktree_checkpoint_cherry_pick_failed:${cherryPick.stderr_tail || cherryPick.stdout_tail}`
+            `git_worktree_checkpoint_cherry_pick_failed:${cherryPick.stderr_tail || cherryPick.stdout_tail}`,
+            `git_worktree_checkpoint_merge_failed:${merge.stderr_tail || merge.stdout_tail}`
         ]
     };
 }

package/dist/core/naruto/naruto-rebalance-policy.js

@@ -3,11 +3,14 @@ export function rebalanceNarutoReadyWork(input) {
     const completed = new Set((input.completedTaskIds || []).map(String));
     const reclaimed = new Set((input.reclaimedTaskIds || []).map(String));
     const idle = input.workers.filter((worker) => worker.alive && ['idle', 'done', 'unknown'].includes(worker.state));
+    const activeWorkerIds = new Set(input.workers.filter((worker) => worker.alive).map((worker) => worker.id));
+    const activeWritePaths = new Set([...(input.activeWritePaths || []), ...(input.currentAssignments || []).flatMap((row) => row.write_paths || [])].map(normalizePath));
     if (!idle.length)
         return [];
     const ready = input.tasks
-        .filter((task) => (task.status || 'pending') === 'pending' && !task.owner)
+        .filter((task) => (task.status || 'pending') === 'pending')
         .filter((task) => task.dependencies.every((dep) => completed.has(dep)))
+        .filter((task) => task.write_paths.every((file) => !activeWritePaths.has(normalizePath(file))))
         .sort((left, right) => {
         const reclaimedOrder = Number(!reclaimed.has(left.id)) - Number(!reclaimed.has(right.id));
         return reclaimedOrder || left.id.localeCompare(right.id);
@@ -15,12 +18,18 @@ export function rebalanceNarutoReadyWork(input) {
     const decisions = [];
     const assignments = [...(input.currentAssignments || [])];
     for (const task of ready) {
-        const decision = chooseNarutoTaskOwner(task, idle, assignments);
+        const requestedOwner = task.owner ? String(task.owner) : '';
+        const ownerActive = requestedOwner && activeWorkerIds.has(requestedOwner);
+        const ownerIdle = ownerActive ? idle.some((worker) => worker.id === requestedOwner) : false;
+        if (requestedOwner && ownerActive && !ownerIdle)
+            continue;
+        const candidateWorkers = ownerIdle ? idle.filter((worker) => worker.id === requestedOwner) : idle;
+        const decision = chooseNarutoTaskOwner({ ...task, owner: null }, candidateWorkers, assignments);
         decisions.push({
             type: 'assign',
             task_id: task.id,
             worker_id: decision.owner,
-            reason: `${reclaimed.has(task.id) ? 'reclaimed ready work' : 'idle worker pickup'}; ${decision.reason}`
+            reason: `${reclaimed.has(task.id) ? 'reclaimed ready work' : requestedOwner && !ownerActive ? `owner inactive:${requestedOwner}` : 'idle worker pickup'}; ${decision.reason}`
         });
         assignments.push({
             task_id: task.id,
@@ -33,4 +42,7 @@ export function rebalanceNarutoReadyWork(input) {
     }
     return decisions;
 }
+function normalizePath(file) {
+    return String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+}
 //# sourceMappingURL=naruto-rebalance-policy.js.map

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

@@ -42,6 +42,12 @@ export function buildNarutoWorkGraph(input = {}) {
         fallback_reason: writeCapable ? 'git_capability_not_evaluated' : 'readonly_or_write_disabled'
     };
     const workItems = [];
+    const assignmentById = new Map();
+    for (const row of input.allocationAssignments || []) {
+        const id = String(row.task_id || row.id || '');
+        if (id)
+            assignmentById.set(id, row);
+    }
     for (let index = 0; index < totalWorkItems; index += 1) {
         const id = `NW-${String(index + 1).padStart(6, '0')}`;
         const kind = kindCycle[index % kindCycle.length] || 'verification';
@@ -53,6 +59,8 @@ export function buildNarutoWorkGraph(input = {}) {
             ...writePaths.map((file) => ({ path: file, kind: 'write' })),
             ...readPaths.map((file) => ({ path: file, kind: 'read' }))
         ];
+        const assignment = assignmentById.get(id);
+        const allocationHints = assignment?.allocation_hints || assignment?.hints || null;
         workItems.push({
             id,
             kind,
@@ -73,6 +81,11 @@ export function buildNarutoWorkGraph(input = {}) {
                 requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
                 requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
             },
+            owner: assignment?.owner ?? null,
+            allocation_reason: assignment?.allocation_reason ?? null,
+            allocation_score: assignment?.allocation_score ?? null,
+            allocation_hints: allocationHints,
+            lane: assignment?.owner ?? null,
             ...(writePaths.length > 0 ? {
                 worktree: {
                     mode: worktreePolicy.mode,