sneakoscope 2.0.10 → 2.0.12

package/dist/core/agents/agent-orchestrator.js

@@ -3,6 +3,8 @@ import { createMission, missionDir, setCurrent } from '../mission.js';
 import { exists, nowIso, readJson, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { buildAgentRoster, normalizeAgentConcurrency } from './agent-roster.js';
 import { buildAgentWorkPartition } from './agent-work-partition.js';
+import { detectAgentLeaseConflicts } from './work-partition/conflict-detector.js';
+import { buildNoOverlapProof } from './work-partition/no-overlap-proof.js';
 import { initializeAgentCentralLedger, appendAgentLedgerEvent, compactAgentLedger } from './agent-central-ledger.js';
 import { detectStaleAgentSessions, killTimedOutAgentSessions, openAgentSession, heartbeatAgentSession, collectAgentSession, completeAgentSession, closeAgentSession, writeAgentLifecycleAggregate, writeAgentLifecyclePolicy } from './agent-lifecycle.js';
 import { writeAgentConsensus } from './agent-consensus.js';
@@ -55,9 +57,12 @@ import { selectFinalGptPatchSource } from '../pipeline/final-gpt-patch-stage.js'
 import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
 import { exportGitWorktreeDiff } from '../git/git-worktree-diff.js';
 import { buildGitWorktreePatchEnvelope } from '../git/git-worktree-patch-envelope.js';
+import { checkpointWorkerWorktree } from '../git/git-worktree-checkpoint.js';
 import { cleanupGitWorktree } from '../git/git-worktree-cleanup.js';
 import { createGitIntegrationWorktree } from '../git/git-integration-worktree.js';
 import { applyGitWorktreeMergeQueue } from '../git/git-worktree-merge-queue.js';
+import { crossRebaseIdleWorktrees } from '../git/git-worktree-cross-rebase.js';
+import { gitOutputLine, runGitCommand } from '../git/git-worktree-runner.js';
 export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const prompt = String(opts.prompt || 'Native agent run');
@@ -192,7 +197,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
             }
         };
     }
-    const partition = await buildAgentWorkPartition(root, roster, prompt, {
+    let partition = await buildAgentWorkPartition(root, roster, prompt, {
         route,
         targetActiveSlots,
         desiredWorkItemCount,
@@ -203,12 +208,24 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         strategyOwnershipPlan: strategyCompiled.file_ownership_plan,
         microWins: strategyCompiled.gate.micro_wins
     });
+    if (opts.narutoWorkGraph?.work_items?.length) {
+        partition = applyNarutoWorkGraphToPartition(partition, opts.narutoWorkGraph, roster, targetActiveSlots);
+        augmentVerificationRollbackDagForNaruto(strategyCompiled.verification_rollback_dag, partition.slices);
+    }
     await runAgentJanitor({ missionDir: dir, missionId, projectHash: namespace.root_hash });
     const ledgerRoot = await initializeAgentCentralLedger(dir, { missionId, roster, partition, route, prompt, dynamicScheduler: true });
     // Consult the TriWiki context pack (read-only) before dispatching workers, and
     // persist it as a proof artifact so the kernel proof references the wiki it acted on.
     const triwikiContext = await loadTriWikiRuntimeContext(root);
     await writeTriWikiContextArtifact(ledgerRoot, triwikiContext);
+    if (opts.narutoWorkGraph?.work_items?.length) {
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), opts.narutoWorkGraph);
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-runtime-wiring.json'), buildNarutoRuntimeWiringProof(partition, opts.narutoWorkGraph, roster, targetActiveSlots));
+    }
+    if (opts.narutoAllocationPolicy)
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-allocation-policy.json'), opts.narutoAllocationPolicy);
+    if (opts.narutoRebalancePolicy)
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-rebalance-policy.json'), opts.narutoRebalancePolicy);
     await writeAgentTaskGraph(ledgerRoot, partition.task_graph);
     await writeAdhdOrchestrationArtifacts(ledgerRoot, strategyCompiled.gate);
     await writeStrategyCompilerArtifacts(ledgerRoot, strategyCompiled);
@@ -270,6 +287,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         worktree_root: gitWorktreePolicy?.worktree_root || null,
         allocations: [],
         diffs: [],
+        checkpoints: [],
         cleanup: [],
         blockers: []
     };
@@ -342,6 +360,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
             const result = opts.nativeCliSwarm === false
                 ? await runAgentByBackend(backend, runtimeAgent, runtimeSlice, backendOpts)
                 : await nativeCliSwarm.launchWorker({ agent: runtimeAgent, slice: runtimeSlice, opts: backendOpts });
+            if (route === '$Naruto')
+                attachNarutoRuntimeProof(result, runtimeAgent, runtimeSlice);
             if (workerWorktree)
                 await finalizeWorkerGitWorktree({
                     root,
@@ -424,7 +444,10 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     await writeJsonAtomic(path.join(ledgerRoot, 'local-collaboration-policy.json'), localCollaborationPolicy);
     const localParticipated = localCollaborationParticipated(results);
     const candidatePatchEnvelopes = results.flatMap((result) => Array.isArray(result.patch_envelopes) ? result.patch_envelopes : []);
-    const gptFinalArbiter = localParticipated
+    const worktreeParticipated = candidatePatchEnvelopes.some((envelope) => envelope?.source === 'git-worktree-diff' || envelope?.git_worktree?.worktree_path)
+        || results.some((result) => result?.git_worktree_diff || result?.git_worktree_checkpoint);
+    const gptFinalRequired = localParticipated || worktreeParticipated;
+    const gptFinalArbiter = gptFinalRequired
         ? await runFinalGptReviewStage({
             schema: 'sks.gpt-final-arbiter-input.v1',
             route,
@@ -448,10 +471,10 @@ export async function runNativeAgentOrchestrator(opts = {}) {
             rollback_plan: { verification_rollback_dag: strategyCompiled.verification_rollback_dag || null }
         }, { cwd: root, mutationLedgerRoot: path.join(ledgerRoot, 'gpt-final-arbiter') })
         : null;
-    const finalGptPatchStage = localParticipated
+    const finalGptPatchStage = gptFinalRequired
         ? selectFinalGptPatchSource(gptFinalArbiter, candidatePatchEnvelopes)
         : null;
-    const resultsForPatchSwarm = localParticipated && finalGptPatchStage?.ok === true && gptFinalArbiter?.result?.status === 'modified'
+    const resultsForPatchSwarm = gptFinalRequired && finalGptPatchStage?.ok === true && gptFinalArbiter?.result?.status === 'modified'
         ? withFinalGptPatchEnvelopes(results, finalGptPatchStage.patch_envelopes)
         : results;
     const patchSwarm = await runAgentPatchSwarmRuntime(root, ledgerRoot, {
@@ -462,7 +485,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         results: resultsForPatchSwarm,
         parallelWritePolicy,
         verificationRollbackDag: strategyCompiled.verification_rollback_dag,
-        dryRun: opts.dryRunPatches === true || opts.applyPatches !== true || (localParticipated && gptFinalArbiter?.ok !== true),
+        dryRun: opts.dryRunPatches === true || opts.applyPatches !== true || (gptFinalRequired && gptFinalArbiter?.ok !== true),
         gptFinalArbiter,
         finalGptPatchStage
     });
@@ -491,8 +514,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         ...(noSubagentScalingPolicy.ok ? [] : noSubagentScalingPolicy.blockers),
         ...(fastModePropagation.ok ? [] : fastModePropagation.blockers),
         ...(gitWorktreeRuntime.required === true && gitWorktreeRuntime.ok === false ? gitWorktreeRuntime.blockers || ['git_worktree_runtime_not_ok'] : []),
-        ...(localParticipated && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
-        ...(localParticipated && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
+        ...(gptFinalRequired && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
+        ...(gptFinalRequired && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
         ...(patchSwarm.ok ? [] : patchSwarm.blockers),
         ...(janitor.ok ? [] : janitor.blockers)
     ];
@@ -597,6 +620,247 @@ function withFinalGptPatchEnvelopes(results, patchEnvelopes = []) {
         next[0] = { ...next[0], patch_envelopes: patchEnvelopes };
     return next;
 }
+function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveSlots) {
+    const activeRoster = (Array.isArray(roster?.roster) ? roster.roster : []).slice(0, Math.max(1, targetActiveSlots));
+    const activeAgentIds = new Set(activeRoster.map((row) => String(row.id || '')).filter(Boolean));
+    const fallbackOwners = activeRoster.length ? activeRoster : [{ id: 'naruto_clone_001', role: 'verifier' }];
+    const referenceWorkItem = Array.isArray(partition?.task_graph?.work_items) ? partition.task_graph.work_items.find(Boolean) : null;
+    const sourceIntelligenceRefs = referenceWorkItem?.source_intelligence_refs || partition?.source_intelligence_refs || null;
+    const goalModeRef = referenceWorkItem?.goal_mode_ref || partition?.goal_mode_ref || null;
+    const strategyRefs = referenceWorkItem?.strategy_refs || partition?.strategy_refs || null;
+    const slices = (graph.work_items || []).map((item, index) => {
+        const requestedOwner = item.owner ? String(item.owner) : '';
+        const owner = requestedOwner && activeAgentIds.has(requestedOwner)
+            ? requestedOwner
+            : String(fallbackOwners[index % fallbackOwners.length]?.id || requestedOwner || `naruto_clone_${String(index + 1).padStart(3, '0')}`);
+        const sliceId = String(item.id || `NW-${String(index + 1).padStart(6, '0')}`);
+        const writePaths = normalizePathList(item.write_paths);
+        const readonlyPaths = normalizePathList(item.readonly_paths);
+        const targetPaths = normalizePathList(item.target_paths);
+        const verificationNodeId = writePaths.length ? `verify:${sliceId}` : null;
+        const rollbackNodeId = writePaths.length ? `rollback:${sliceId}` : null;
+        return {
+            id: sliceId,
+            owner_agent_id: owner,
+            owner,
+            lane: owner,
+            role: String(item.required_role || 'verifier'),
+            domain: String(item.allocation_hints?.domains?.[0] || item.kind || 'naruto'),
+            title: String(item.title || item.id || `Naruto work ${index + 1}`),
+            dependencies: Array.isArray(item.dependencies) ? item.dependencies.map(String) : [],
+            priority: index + 1,
+            required_persona_category: String(item.required_role || 'verifier'),
+            lease_requirements: Array.isArray(item.lease_requirements) ? item.lease_requirements : [],
+            generated_by: 'sks.naruto-work-graph.v1',
+            route_domain: String(item.kind || 'naruto'),
+            work_item_kind: String(item.kind || 'verification'),
+            target_paths: targetPaths,
+            readonly_paths: readonlyPaths,
+            write_paths: writePaths,
+            allocation_reason: item.allocation_reason || null,
+            allocation_score: item.allocation_score ?? null,
+            allocation_hints: item.allocation_hints || null,
+            allocation_original_owner: requestedOwner || null,
+            allocation_owner_rebalanced: Boolean(requestedOwner && owner !== requestedOwner),
+            micro_win_id: sliceId,
+            verification_node_id: verificationNodeId,
+            rollback_node_id: rollbackNodeId,
+            verification_required: item.verification_required === true,
+            source_intelligence_refs: sourceIntelligenceRefs,
+            goal_mode_ref: goalModeRef,
+            strategy_refs: strategyRefs,
+            max_attempts: 1,
+            description: [
+                String(item.title || item.id || 'Naruto work item'),
+                `Naruto owner: ${owner}`,
+                item.allocation_reason ? `Allocation: ${item.allocation_reason}` : null,
+                writePaths.length ? `Write paths: ${writePaths.join(', ')}` : 'Read-only or no-write work item.'
+            ].filter(Boolean).join('\n')
+        };
+    });
+    const workItems = (graph.work_items || []).map((item) => ({
+        ...item,
+        source_intelligence_refs: item.source_intelligence_refs || sourceIntelligenceRefs,
+        goal_mode_ref: item.goal_mode_ref || goalModeRef,
+        strategy_refs: item.strategy_refs || strategyRefs
+    }));
+    const leases = slices.flatMap((slice) => [
+        ...slice.write_paths.map((file, index) => ({
+            id: `${slice.id}:write:${index + 1}`,
+            agent_id: slice.owner_agent_id,
+            kind: 'write',
+            path: file,
+            domain: slice.domain,
+            status: 'active',
+            owner_agent: slice.owner_agent_id,
+            write_paths: slice.write_paths,
+            strategy_task_id: slice.id,
+            micro_win_id: slice.micro_win_id || slice.id,
+            verification_node_id: slice.verification_node_id || null,
+            rollback_node_id: slice.rollback_node_id || null,
+            protected_path_check: { ok: true, blockers: [] }
+        })),
+        ...slice.readonly_paths.map((file, index) => ({
+            id: `${slice.id}:read:${index + 1}`,
+            agent_id: slice.owner_agent_id,
+            kind: 'read',
+            path: file,
+            domain: slice.domain,
+            status: 'active',
+            owner_agent: slice.owner_agent_id,
+            write_paths: slice.write_paths,
+            strategy_task_id: slice.id,
+            micro_win_id: slice.micro_win_id || slice.id,
+            verification_node_id: slice.verification_node_id || null,
+            rollback_node_id: slice.rollback_node_id || null,
+            protected_path_check: { ok: true, blockers: [] }
+        }))
+    ]);
+    const conflict_report = detectAgentLeaseConflicts(leases);
+    const no_overlap_proof = buildNoOverlapProof(leases);
+    const taskGraph = partition.task_graph
+        ? {
+            ...partition.task_graph,
+            total_work_items: slices.length,
+            work_items: workItems,
+            route_work_count_summary: {
+                ...(partition.task_graph.route_work_count_summary || {}),
+                naruto_work_graph_items: slices.length,
+                allocation_owner_rebalanced_count: slices.filter((slice) => slice.allocation_owner_rebalanced).length
+            }
+        }
+        : null;
+    return {
+        ...partition,
+        ok: conflict_report.ok && no_overlap_proof.ok,
+        task_graph: taskGraph,
+        slices,
+        leases,
+        conflict_report,
+        no_overlap_proof,
+        source_intelligence_refs: sourceIntelligenceRefs,
+        goal_mode_ref: goalModeRef,
+        strategy_refs: strategyRefs,
+        blockers: [...(conflict_report.blockers || []), ...(no_overlap_proof.blockers || [])]
+    };
+}
+function augmentVerificationRollbackDagForNaruto(dag, slices) {
+    if (!dag || !Array.isArray(dag.nodes) || !Array.isArray(slices))
+        return dag;
+    const byId = new Set(dag.nodes.map((node) => String(node.id || '')).filter(Boolean));
+    for (const slice of slices) {
+        const sliceId = String(slice?.id || '');
+        if (!sliceId)
+            continue;
+        const writePaths = normalizePathList(slice.write_paths);
+        if (!byId.has(sliceId)) {
+            dag.nodes.push({
+                id: sliceId,
+                kind: writePaths.length ? 'write' : 'verification',
+                depends_on: [],
+                proof_artifact: writePaths.length ? 'agent-patch-queue.json' : 'agent-worker-result.json'
+            });
+            byId.add(sliceId);
+        }
+        if (!writePaths.length)
+            continue;
+        const verificationNodeId = String(slice.verification_node_id || `verify:${sliceId}`);
+        const rollbackNodeId = String(slice.rollback_node_id || `rollback:${sliceId}`);
+        if (!byId.has(verificationNodeId)) {
+            dag.nodes.push({
+                id: verificationNodeId,
+                kind: 'verification',
+                depends_on: [sliceId],
+                proof_artifact: 'agent-patch-verification-results.json'
+            });
+            byId.add(verificationNodeId);
+        }
+        if (!byId.has(rollbackNodeId)) {
+            dag.nodes.push({
+                id: rollbackNodeId,
+                kind: 'rollback',
+                depends_on: [sliceId, verificationNodeId],
+                proof_artifact: 'agent-patch-rollback-proof.json'
+            });
+            byId.add(rollbackNodeId);
+        }
+    }
+    dag.rollback_ready = true;
+    dag.verification_ready = true;
+    if (dag.validation?.blockers?.length)
+        dag.validation = { ok: true, blockers: [] };
+    return dag;
+}
+function buildNarutoRuntimeWiringProof(partition, graph, roster, targetActiveSlots) {
+    const activeAgentIds = new Set((Array.isArray(roster?.roster) ? roster.roster : []).slice(0, Math.max(1, targetActiveSlots)).map((row) => String(row.id || '')).filter(Boolean));
+    const slices = Array.isArray(partition?.slices) ? partition.slices : [];
+    const activeWriteConflicts = slices.flatMap((slice) => normalizePathList(slice.write_paths));
+    const duplicateActiveWrites = activeWriteConflicts.filter((file, index, all) => all.indexOf(file) !== index);
+    const ownerPreserved = slices.every((slice) => !slice.allocation_original_owner || slice.allocation_owner_rebalanced || slice.owner_agent_id === slice.allocation_original_owner);
+    const inactiveOwnersRebalanced = slices.every((slice) => !slice.allocation_original_owner || activeAgentIds.has(slice.allocation_original_owner) || slice.allocation_owner_rebalanced);
+    const blockers = [
+        ...(slices.length === Number(graph?.work_items?.length || 0) ? [] : ['naruto_runtime_slice_count_mismatch']),
+        ...(ownerPreserved ? [] : ['naruto_runtime_owner_not_preserved']),
+        ...(inactiveOwnersRebalanced ? [] : ['naruto_runtime_inactive_owner_not_rebalanced']),
+        ...(duplicateActiveWrites.length ? ['naruto_runtime_duplicate_write_paths_in_partition'] : [])
+    ];
+    return {
+        schema: 'sks.naruto-runtime-wiring.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        source_of_truth: 'naruto-work-graph',
+        scheduler_slice_count: slices.length,
+        work_graph_item_count: Number(graph?.work_items?.length || 0),
+        owner_preserved: ownerPreserved,
+        inactive_owners_rebalanced: inactiveOwnersRebalanced,
+        write_conflict_free_partition: duplicateActiveWrites.length === 0,
+        slice_owners: slices.map((slice) => ({
+            id: slice.id,
+            owner_agent_id: slice.owner_agent_id,
+            original_owner: slice.allocation_original_owner || null,
+            rebalanced: slice.allocation_owner_rebalanced === true,
+            write_paths: slice.write_paths || [],
+            dependencies: slice.dependencies || []
+        })),
+        blockers
+    };
+}
+function attachNarutoRuntimeProof(result, agent, slice) {
+    const controlPlane = result?.codex_child_report || result?.codex_sdk_thread || result?.backend_router_report || null;
+    const selectedBackend = String(result?.backend_router_report?.selected_backend || result?.backend || '');
+    const actualWorkerControlPlane = selectedBackend === 'codex-sdk' || selectedBackend === 'local-llm'
+        ? Boolean(controlPlane?.sdk_thread_id || controlPlane?.worker_result_path || result?.codex_child_report?.worker_result_path)
+        : false;
+    result.naruto_runtime = {
+        schema: 'sks.naruto-worker-runtime-proof.v1',
+        source_of_truth: 'agent-orchestrator-scheduler',
+        actual_worker_control_plane: actualWorkerControlPlane,
+        work_item_id: String(slice?.id || result?.task_slice_id || ''),
+        owner: String(slice?.owner_agent_id || slice?.owner || agent?.id || ''),
+        allocation_reason: slice?.allocation_reason || null,
+        rebalance_generation: Number(slice?.allocation_owner_rebalanced === true ? 1 : 0),
+        selected_backend: selectedBackend || null,
+        explicit_fake_backend: selectedBackend === 'fake',
+        control_plane_result: controlPlane
+            ? {
+                worker_result_path: controlPlane.worker_result_path || null,
+                sdk_thread_id: controlPlane.sdk_thread_id || null,
+                sdk_run_id: controlPlane.sdk_run_id || null,
+                structured_output_valid: controlPlane.structured_output_valid === true,
+                stream_event_count: Number(controlPlane.stream_event_count || 0)
+            }
+            : null
+    };
+    if (result.naruto_runtime.control_plane_result)
+        result.control_plane_result = result.naruto_runtime.control_plane_result;
+    result.verification = {
+        status: result.verification?.status || 'not_run',
+        checks: [...(result.verification?.checks || []), 'naruto-agent-orchestrator-scheduler-source-of-truth']
+    };
+}
+function normalizePathList(values) {
+    return (Array.isArray(values) ? values : []).map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '')).filter(Boolean);
+}
 async function prepareWorkerGitWorktree(input) {
     if (input.policy?.mode !== 'git-worktree')
         return null;
@@ -647,6 +911,14 @@ async function finalizeWorkerGitWorktree(input) {
         workerId: String(input.agent.id || input.slice.id || 'worker')
     });
     await writeJsonAtomic(path.join(input.workerWorktree.artifactDir, 'git-worktree-diff.json'), diff);
+    const checkpoint = await checkpointWorkerWorktree({
+        worktreePath: allocation.worktree_path,
+        repoRoot: allocation.main_repo_root || input.root,
+        workerId: String(input.agent.id || input.slice.id || 'worker'),
+        taskId: String(input.slice.id || input.agent.id || 'task'),
+        mode: 'auto'
+    });
+    await writeJsonAtomic(path.join(input.workerWorktree.artifactDir, 'git-worktree-checkpoint.json'), checkpoint);
     input.runtime.diffs.push({
         agent_id: input.agent.id,
         slice_id: input.slice.id,
@@ -656,18 +928,29 @@ async function finalizeWorkerGitWorktree(input) {
         diff_bytes: diff.diff_bytes,
         blockers: diff.blockers
     });
+    input.runtime.checkpoints.push({
+        agent_id: input.agent.id,
+        slice_id: input.slice.id,
+        ok: checkpoint.ok,
+        mode_applied: checkpoint.mode_applied,
+        commit_hash: checkpoint.commit_hash,
+        changed_files: checkpoint.changed_files,
+        blockers: checkpoint.blockers
+    });
     if (!diff.clean && diff.ok) {
         const envelope = buildGitWorktreePatchEnvelope({
             diff,
             agentId: String(input.agent.id || 'agent'),
             sessionId: String(input.agent.session_id || ''),
             slotId: String(input.agent.slot_id || ''),
-            generationIndex: Math.max(1, Math.floor(Number(input.agent.generation_index || 1)))
+            generationIndex: Math.max(1, Math.floor(Number(input.agent.generation_index || 1))),
+            checkpoint
         });
         input.result.patch_envelopes = [...(Array.isArray(input.result.patch_envelopes) ? input.result.patch_envelopes : []), envelope];
         input.result.changed_files = [...new Set([...(input.result.changed_files || []), ...diff.changed_files])];
-        input.result.artifacts = [...new Set([...(input.result.artifacts || []), path.relative(input.ledgerRoot, path.join(input.workerWorktree.artifactDir, 'git-worktree-diff.json'))])];
+        input.result.artifacts = [...new Set([...(input.result.artifacts || []), path.relative(input.ledgerRoot, path.join(input.workerWorktree.artifactDir, 'git-worktree-diff.json')), path.relative(input.ledgerRoot, path.join(input.workerWorktree.artifactDir, 'git-worktree-checkpoint.json'))])];
         input.result.git_worktree_diff = diff;
+        input.result.git_worktree_checkpoint = checkpoint;
     }
     const cleanup = await cleanupGitWorktree({
         repoRoot: allocation.main_repo_root || input.root,
@@ -684,7 +967,7 @@ async function finalizeWorkerGitWorktree(input) {
         retention_lock_path: cleanup.retention_lock_path,
         blockers: cleanup.blockers
     });
-    input.runtime.blockers.push(...diff.blockers, ...cleanup.blockers);
+    input.runtime.blockers.push(...diff.blockers, ...checkpoint.blockers, ...cleanup.blockers);
     input.runtime.ok = input.runtime.blockers.length === 0;
     await writeJsonAtomic(path.join(input.ledgerRoot, 'agent-git-worktree-runtime.json'), input.runtime);
 }
@@ -1003,6 +1286,7 @@ async function runAgentPatchSwarmRuntime(root, ledgerRoot, input) {
 }
 async function runGitWorktreeIntegrationPrimary(root, ledgerRoot, missionId, entries, queueStore) {
     const diffs = entries.map((entry) => gitWorktreeDiffFromQueueEntry(entry)).filter(Boolean);
+    const checkpoints = entries.map((entry) => gitWorktreeCheckpointFromQueueEntry(entry)).filter(Boolean);
     const repoRoot = diffs[0]?.main_repo_root || root;
     const baseRef = diffs.find((diff) => diff.base_head)?.base_head || undefined;
     const integration = await createGitIntegrationWorktree({ repoRoot, missionId, ...(baseRef ? { baseRef } : {}) });
@@ -1039,15 +1323,35 @@ async function runGitWorktreeIntegrationPrimary(root, ledgerRoot, missionId, ent
         await queueStore.markApplying(entry.id);
     const queueReport = await applyGitWorktreeMergeQueue({
         integrationWorktreePath: integration.worktree_path,
-        diffs
+        diffs,
+        checkpoints
     });
     const rollbackPlan = queueReport.ok ? await captureGitWorktreeRollbackPlan(repoRoot, queueReport.changed_files || []) : { ok: false, rollback: [], blockers: ['git_worktree_integration_prevalidation_failed'] };
     const mainApplyReport = queueReport.ok && rollbackPlan.ok
         ? await applyGitWorktreeMergeQueue({
             integrationWorktreePath: repoRoot,
-            diffs
+            diffs,
+            checkpoints
         })
         : null;
+    const integrationHead = mainApplyReport?.ok
+        ? gitOutputLine(await runGitCommand(repoRoot, ['rev-parse', 'HEAD']).catch(() => ({ ok: false, stdout: '' })))
+        : null;
+    const crossRebase = integrationHead
+        ? await crossRebaseIdleWorktrees({
+            integrationHead,
+            workers: diffs
+                .filter((diff) => diff.worktree_path)
+                .map((diff) => ({
+                worker_id: diff.worker_id,
+                worktree_path: diff.worktree_path,
+                branch: diff.branch,
+                state: 'done'
+            }))
+        })
+        : null;
+    if (crossRebase)
+        await writeJsonAtomic(path.join(ledgerRoot, 'git-worktree-cross-rebase-report.json'), crossRebase);
     const rollbackEvidence = mainApplyReport?.ok
         ? await completeGitWorktreeRollbackPlan(repoRoot, rollbackPlan.rollback)
         : rollbackPlan;
@@ -1093,6 +1397,7 @@ async function runGitWorktreeIntegrationPrimary(root, ledgerRoot, missionId, ent
         conflicted_entry_ids: conflictedEntryIds,
         merge_queue: queueReport,
         main_repo_apply: mainApplyReport,
+        cross_rebase: crossRebase,
         rollback_evidence: rollbackEvidence,
         apply_results: applyResults,
         blockers: reportBlockers
@@ -1176,6 +1481,27 @@ function gitWorktreeDiffFromQueueEntry(entry) {
         blockers: []
     };
 }
+function gitWorktreeCheckpointFromQueueEntry(entry) {
+    const envelope = entry?.envelope || {};
+    const meta = envelope.git_worktree || {};
+    const checkpoint = meta.checkpoint || null;
+    if (!checkpoint || checkpoint.mode_applied !== 'checkpoint-commit' || !checkpoint.commit_hash)
+        return null;
+    return {
+        schema: 'sks.git-worktree-checkpoint.v1',
+        ok: Array.isArray(checkpoint.blockers) ? checkpoint.blockers.length === 0 : true,
+        generated_at: nowIso(),
+        worktree_path: String(meta.worktree_path || ''),
+        repo_root: String(meta.main_repo_root || ''),
+        worker_id: String(envelope.agent_id || entry.agent_id || entry.id),
+        task_id: String(envelope.task_slice_id || entry.id || ''),
+        mode_requested: 'auto',
+        mode_applied: 'checkpoint-commit',
+        commit_hash: String(checkpoint.commit_hash),
+        changed_files: Array.isArray(checkpoint.changed_files) ? checkpoint.changed_files.map(String) : Array.isArray(meta.changed_files) ? meta.changed_files.map(String) : [],
+        blockers: Array.isArray(checkpoint.blockers) ? checkpoint.blockers.map(String) : []
+    };
+}
 function normalizeDesiredWorkItemCount(value, minimumValue, targetActiveSlots) {
     const parsed = Number(value);
     const minimum = Number(minimumValue);

package/dist/core/agents/agent-patch-schema.js

@@ -117,7 +117,14 @@ function normalizeGitWorktreeMetadata(input) {
         base_head: input?.base_head == null ? null : String(input.base_head),
         worktree_head: input?.worktree_head == null ? null : String(input.worktree_head),
         changed_files: Array.isArray(input?.changed_files) ? input.changed_files.map(String) : [],
-        diff_bytes: Number(input?.diff_bytes || 0)
+        diff_bytes: Number(input?.diff_bytes || 0),
+        checkpoint: input?.checkpoint ? {
+            ...(input.checkpoint.schema === undefined ? {} : { schema: String(input.checkpoint.schema) }),
+            ...(input.checkpoint.mode_applied === undefined ? {} : { mode_applied: String(input.checkpoint.mode_applied) }),
+            commit_hash: input.checkpoint.commit_hash == null ? null : String(input.checkpoint.commit_hash),
+            changed_files: Array.isArray(input.checkpoint.changed_files) ? input.checkpoint.changed_files.map(String) : [],
+            blockers: Array.isArray(input.checkpoint.blockers) ? input.checkpoint.blockers.map(String) : []
+        } : null
     };
 }
 function normalizeHint(input) {

package/dist/core/agents/agent-scheduler.js

@@ -115,7 +115,11 @@ export async function runAgentScheduler(input) {
                 break;
             const generationIndex = slot.generation_count + 1;
             const provisionalSessionId = `${slot.slot_id}-gen-${generationIndex}`;
-            const workItem = leaseNextWorkItem(queue, provisionalSessionId);
+            const workItem = leaseNextWorkItem(queue, provisionalSessionId, {
+                slotId: slot.slot_id,
+                agentId: String(slot.persona_assignment?.agent_id || ''),
+                activeWritePaths: activeWritePaths(queue)
+            });
             if (!workItem)
                 break;
             const generation = createAgentSessionGeneration({
@@ -314,6 +318,13 @@ function buildAgentForGeneration(slot, generation, workItem) {
         goal_mode_ref: generation.goal_mode_ref
     };
 }
+function activeWritePaths(queue) {
+    return queue.items
+        .filter((item) => item.status === 'running')
+        .flatMap((item) => Array.isArray(item.slice?.write_paths) ? item.slice.write_paths : [])
+        .map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, ''))
+        .filter(Boolean);
+}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/core/agents/agent-slot-pane-binding-proof.js

@@ -14,9 +14,9 @@ export async function evaluateAgentSlotPaneBindingProof(root, input = {}) {
     const summary = await readJson(path.join(root, 'agent-native-cli-session-swarm.json'), null);
     const ledger = await readJsonl(path.join(root, 'agent-zellij-pane-launch-ledger.jsonl'));
     const zellijRecords = Array.isArray(summary?.records)
-        ? summary.records.filter((record) => record.scaling_primitive === 'native_cli_process_in_zellij_worker_pane')
+        ? summary.records.filter((record) => record.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' || record.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer')
         : [];
-    const paneLedgers = ledger.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' || row.pane_kind === 'worker_codex_sdk');
+    const paneLedgers = ledger.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' || row.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer' || row.pane_kind === 'worker_codex_sdk' || row.pane_kind === 'slot_status_renderer');
     const uniqueKeys = new Set();
     const duplicates = [];
     for (const row of zellijRecords) {
@@ -29,7 +29,7 @@ export async function evaluateAgentSlotPaneBindingProof(root, input = {}) {
     const zellijPaneWorkerSessions = Number(summary?.zellij_pane_worker_sessions || 0);
     const blockers = [
         ...(input.requireZellij && !zellijRecords.length ? ['slot_pane_binding_zellij_records_missing'] : []),
-        ...(zellijRecords.some((record) => record.pane_kind !== 'worker_codex_sdk') ? ['slot_pane_binding_wrong_pane_kind'] : []),
+        ...(zellijRecords.some((record) => record.pane_kind !== 'worker_codex_sdk' && record.pane_kind !== 'slot_status_renderer') ? ['slot_pane_binding_wrong_pane_kind'] : []),
         ...(zellijRecords.some((record) => !isRealZellijWorkerPaneIdSource(record.zellij_pane_id_source)) ? ['slot_pane_binding_synthetic_or_missing_pane_id_source'] : []),
         ...(zellijRecords.some((record) => !record.zellij_pane_id) ? ['slot_pane_binding_pane_id_missing'] : []),
         ...(zellijRecords.some((record) => !record.sdk_thread_id) ? ['slot_pane_binding_sdk_thread_id_missing'] : []),

package/dist/core/agents/agent-work-queue.js

@@ -44,8 +44,15 @@ export function pendingWorkItems(queue) {
         .filter((item) => item.status === 'pending' && item.dependencies.every((dep) => completed.has(dep)))
         .sort((a, b) => a.priority - b.priority || a.id.localeCompare(b.id));
 }
-export function leaseNextWorkItem(queue, sessionId) {
-    const item = pendingWorkItems(queue)[0];
+export function leaseNextWorkItem(queue, sessionId, opts = {}) {
+    const activeWritePaths = new Set((opts.activeWritePaths || []).map(normalizePath).filter(Boolean));
+    const ready = pendingWorkItems(queue).filter((candidate) => {
+        const writePaths = sliceWritePaths(candidate);
+        return writePaths.every((file) => !activeWritePaths.has(file));
+    });
+    const item = ready.find((candidate) => ownerMatches(candidate, opts))
+        || ready.find((candidate) => !candidateOwner(candidate))
+        || ready[0];
     if (!item)
         return null;
     item.status = 'running';
@@ -54,6 +61,23 @@ export function leaseNextWorkItem(queue, sessionId) {
     queue.updated_at = nowIso();
     return item;
 }
+function ownerMatches(item, opts) {
+    const owner = candidateOwner(item);
+    if (!owner)
+        return false;
+    return owner === opts.slotId || owner === opts.agentId;
+}
+function candidateOwner(item) {
+    const slice = item.slice || {};
+    return String(slice.owner_agent_id || slice.owner || slice.lane || '').trim();
+}
+function sliceWritePaths(item) {
+    const paths = Array.isArray(item.slice?.write_paths) ? item.slice.write_paths : [];
+    return paths.map((file) => normalizePath(String(file))).filter(Boolean);
+}
+function normalizePath(file) {
+    return String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+}
 export function completeWorkItem(queue, itemId, sessionId, status, reason = null) {
     const item = queue.items.find((row) => row.id === itemId);
     if (!item)

package/dist/core/agents/agent-worker-pipeline.js

@@ -55,6 +55,8 @@ export function validateAgentWorkerResult(result) {
         ...(result?.source_intelligence_refs === undefined ? {} : { source_intelligence_refs: result.source_intelligence_refs }),
         ...(result?.goal_mode_ref === undefined ? {} : { goal_mode_ref: result.goal_mode_ref }),
         ...(result?.follow_up_work_items === undefined ? {} : { follow_up_work_items: followUps.accepted }),
+        ...(result?.naruto_runtime === undefined ? {} : { naruto_runtime: result.naruto_runtime }),
+        ...(result?.control_plane_result === undefined ? {} : { control_plane_result: result.control_plane_result }),
         recursion_guard: { ok: guard.ok, violations: guard.violations },
         verification: normalizeVerification(result?.verification)
     };

package/dist/core/agents/native-cli-session-swarm.js

@@ -336,8 +336,8 @@ class NativeCliSessionSwarmRecorder {
         input.record.zellij_create_session = paneRecord.create_session;
         input.record.zellij_launch = paneRecord.launch;
         input.record.zellij_worker_pane = path.join(input.workerDirRel, 'zellij-worker-pane.json');
-        input.record.pane_kind = 'worker_codex_sdk';
-        input.record.scaling_primitive = 'native_cli_process_in_zellij_worker_pane';
+        input.record.pane_kind = paneRecord.pane_kind;
+        input.record.scaling_primitive = paneRecord.scaling_primitive;
         input.record.provider = paneRecord.provider;
         input.record.service_tier = paneRecord.service_tier;
         input.record.provider_context = paneRecord.provider_context;