sneakoscope 2.0.11 → 2.0.12

package/README.md

@@ -16,12 +16,14 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.11** is the slot-only Zellij and Naruto runtime stabilization release. Compact slot panes are now the default visual worker surface, the initial Zellij session stays main-only until the first visible worker is reserved, overflow workers continue headlessly with runtime evidence instead of opening excess panes, and dashboard panes stay opt-in. The release path remains manifest-backed through the v2 DAG runner, with real Zellij/Naruto/worktree proof gates split into `real-check`.
+SKS **2.0.12** is the public-ready parallel runtime stabilization release. It closes release DAG coverage around Zellij slot renderer proof semantics, wires Naruto allocation/rebalance into the production scheduler, keeps pre-run worker smoke opt-in, and requires GPT Final approval before local/worktree candidate output can apply.
 
 What changed:
 
-- Zellij slot panes render compact worker slots without nested dashboard chrome, and right-column state records visible panes plus headless overflow lifecycle.
-- Naruto active-pool checks now exercise real child-worker spawn/result collection paths, including high-fanout overflow and completed-worker collection order.
+- Zellij slot panes distinguish `slot_status_renderer` panes from Codex worker panes, and the first visible worker now stacks downward below the `SLOTS` anchor with real geometry proof available under `real-check`.
+- Naruto allocation owners now flow into work graph items, scheduler slices, queue ownership, and worker runtime proof; inactive owners are rebalanced and active write conflicts stay out of concurrent execution.
+- Naruto active-pool checks now exercise actual child-worker spawn/result collection paths while production source-of-truth stays with the agent orchestrator scheduler.
+- Worktree candidate output requires GPT Final approval before apply; GPT `modified` output replaces candidate patches and GPT `rejected` blocks apply.
 - Visible Zellij reservations are capped before pane launch so concurrent worker starts cannot over-open the right column.
 - Git worktree integration now proves the primary repo receives validated worktree diffs, with rollback hash evidence recorded around the apply step.
 - Agent role config repair detects stale generated role files and rewrites structured GPT-5.5-compatible configs atomically.

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "2.0.11"
+version = "2.0.12"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.11"
+version = "2.0.12"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 2.0.11"),
+        Some("--version") => println!("sks-rs 2.0.12"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "2.0.11",
-  "source_digest": "7f7339938c95fb98e1fb072192115eb0ca8cbc8136800d007b85d51fe413de19",
-  "source_file_count": 2046,
-  "built_at_source_time": 1780821479881
+  "package_version": "2.0.12",
+  "source_digest": "6f9f20ed184ebe714b41b9176d8414b7fded251a30591ada3c3bac53e49fcf61",
+  "source_file_count": 2053,
+  "built_at_source_time": 1780833723608
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '2.0.11';
+const FAST_PACKAGE_VERSION = '2.0.12';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "2.0.11",
-  "package_version": "2.0.11",
+  "version": "2.0.12",
+  "package_version": "2.0.12",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1108,
-  "compiled_js_count": 1108,
+  "compiled_file_count": 1111,
+  "compiled_js_count": 1111,
   "compiled_dts_count": 0,
-  "source_digest": "7f7339938c95fb98e1fb072192115eb0ca8cbc8136800d007b85d51fe413de19",
-  "source_file_count": 2046,
-  "source_files_hash": "b94b6d01c22138f134b831e0e793a981744316d3e78bf457e00d81cadd9d5c07",
-  "source_list_hash": "b94b6d01c22138f134b831e0e793a981744316d3e78bf457e00d81cadd9d5c07",
+  "source_digest": "6f9f20ed184ebe714b41b9176d8414b7fded251a30591ada3c3bac53e49fcf61",
+  "source_file_count": 2053,
+  "source_files_hash": "cf94f337fb28d923dd91214e01c2b80794f0d24659e7aaac0baf5c3110f1eb7a",
+  "source_list_hash": "cf94f337fb28d923dd91214e01c2b80794f0d24659e7aaac0baf5c3110f1eb7a",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -905,6 +905,7 @@
     "scripts/local-collab-gpt-final-availability-check.js",
     "scripts/local-collab-no-local-only-final-check.js",
     "scripts/local-collab-policy-check.js",
+    "scripts/local-collab-worktree-gpt-final-apply-policy-check.js",
     "scripts/local-llm-all-pipelines-check.js",
     "scripts/local-llm-cache-performance-check.js",
     "scripts/local-llm-capability-check.js",
@@ -942,6 +943,7 @@
     "scripts/naruto-active-pool-check.js",
     "scripts/naruto-actual-worker-control-plane-check.js",
     "scripts/naruto-allocation-policy-check.js",
+    "scripts/naruto-allocation-runtime-wiring-check.js",
     "scripts/naruto-concurrency-governor-check.js",
     "scripts/naruto-extreme-parallelism-check.js",
     "scripts/naruto-extreme-parallelism-real-check.js",
@@ -1117,6 +1119,7 @@
     "scripts/zellij-slot-column-anchor-check.js",
     "scripts/zellij-slot-only-ui-check.js",
     "scripts/zellij-slot-pane-renderer-check.js",
+    "scripts/zellij-slot-renderer-proof-semantics-check.js",
     "scripts/zellij-spawn-on-demand-layout-check.js",
     "scripts/zellij-ui-design-check.js",
     "scripts/zellij-worker-pane-manager-check.js",

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';
@@ -59,6 +61,8 @@ 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');
@@ -193,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,
@@ -204,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);
@@ -344,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,
@@ -602,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;
@@ -1075,6 +1334,24 @@ async function runGitWorktreeIntegrationPrimary(root, ledgerRoot, missionId, ent
             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;
@@ -1120,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

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;