oxe-cc 1.8.3 → 1.9.1

package/packages/runtime/src/scheduler/multi-agent-coordinator.ts

@@ -2,7 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import { appendEvent } from '../events/bus';
 import type { ExecutionGraph, GraphNode } from '../compiler/graph-compiler';
-import type { WorkspaceManager } from '../workspace/workspace-manager';
+import type { WorkspaceManager, WorkspaceRequest } from '../workspace/workspace-manager';
+import type { WorkspaceLease, SnapshotRef } from '../models/workspace';
 import type { TaskExecutor, TaskResult, SchedulerContext, RunResult } from './scheduler';
 import { Scheduler } from './scheduler';
 import { buildHandoff } from './agent-roles';
@@ -27,6 +28,7 @@ export interface CoordinationOptions {
   runId: string;
   onEvent?: SchedulerContext['onEvent'];
   heartbeatTimeoutMs?: number;
+  applyWorkspaceMerges?: boolean;
 }
 
 export interface ArbitrationRecord {
@@ -40,10 +42,39 @@ export interface ArbitrationRecord {
   recorded_at: string;
 }
 
-export interface MultiAgentOwnership {
-  work_item_id: string;
-  owner_agent_id: string;
-}
+export interface MultiAgentOwnership {
+  work_item_id: string;
+  owner_agent_id: string;
+}
+
+export interface WorkspaceMergeRecord {
+  work_item_id: string;
+  agent_id: string;
+  workspace_id: string;
+  strategy: string;
+  isolation_level: 'shared' | 'isolated';
+  branch: string | null;
+  base_commit: string | null;
+  root_path: string | null;
+  mutation_scope: string[];
+  diff_paths: string[];
+  evidence_count: number;
+  verify_status: 'pass' | 'fail' | 'partial';
+  status: 'ready' | 'merged' | 'blocked' | 'skipped';
+  blocker: string | null;
+  recorded_at: string;
+}
+
+export interface WorkspaceMergeReport {
+  schema_version: 1;
+  run_id: string;
+  generated_at: string;
+  workspace_isolation: 'git_worktree';
+  merge_readiness: 'ready' | 'blocked' | 'partial';
+  arbitration_required: boolean;
+  blockers: string[];
+  records: WorkspaceMergeRecord[];
+}
 
 export interface MultiAgentStatusSnapshot {
   run_id: string;
@@ -64,6 +95,10 @@ export interface MultiAgentStatusSnapshot {
     timed_out: boolean;
     reassigned_task_ids: string[];
   }>;
+  worktrees: WorkspaceMergeRecord[];
+  workspace_merge: WorkspaceMergeReport;
+  merge_blockers: string[];
+  arbitration_required: boolean;
   orphan_reassignments: Array<{ from_agent_id: string; to_agent_id: string; work_item_ids: string[] }>;
   timed_out_agents: Array<{ agent_id: string; work_item_ids: string[]; detected_at: string }>;
   updated_at: string;
@@ -83,6 +118,10 @@ export interface MultiAgentOperationalSummary {
   orphan_reassignment_count: number;
   timeout_count: number;
   participating_agents: string[];
+  workspace_isolation: 'git_worktree';
+  merge_readiness: WorkspaceMergeReport['merge_readiness'];
+  arbitration_required: boolean;
+  merge_blocker_count: number;
   health: 'healthy' | 'degraded';
   updated_at: string;
 }
@@ -96,6 +135,7 @@ export interface CoordinationResult {
   agent_results: Array<{ agent_id: string; completed: string[]; failed: string[] }>;
   handoffs?: CooperativeHandoff[];
   arbitration_results?: ArbitrationRecord[];
+  workspace_merge_report?: WorkspaceMergeReport;
   state?: MultiAgentStatusSnapshot;
   summary?: MultiAgentOperationalSummary;
 }
@@ -111,12 +151,14 @@ function persistMultiAgentArtifacts(
   runId: string,
   state: MultiAgentStatusSnapshot,
   handoffs: CooperativeHandoff[] = [],
-  arbitrationResults: ArbitrationRecord[] = []
+  arbitrationResults: ArbitrationRecord[] = [],
+  workspaceMergeReport: WorkspaceMergeReport = emptyWorkspaceMergeReport(runId)
 ): void {
   const runDir = ensureRunDir(projectRoot, runId);
   fs.writeFileSync(path.join(runDir, 'multi-agent-state.json'), JSON.stringify(state, null, 2), 'utf8');
   fs.writeFileSync(path.join(runDir, 'handoffs.json'), JSON.stringify(handoffs, null, 2), 'utf8');
   fs.writeFileSync(path.join(runDir, 'arbitration-results.json'), JSON.stringify(arbitrationResults, null, 2), 'utf8');
+  fs.writeFileSync(path.join(runDir, 'workspace-merge-report.json'), JSON.stringify(workspaceMergeReport, null, 2), 'utf8');
   const summary: MultiAgentOperationalSummary = {
     run_id: state.run_id,
     mode: state.mode,
@@ -131,13 +173,17 @@ function persistMultiAgentArtifacts(
     orphan_reassignment_count: state.orphan_reassignments.length,
     timeout_count: state.timed_out_agents.length,
     participating_agents: state.agent_results.map((entry) => entry.agent_id),
+    workspace_isolation: 'git_worktree',
+    merge_readiness: workspaceMergeReport.merge_readiness,
+    arbitration_required: workspaceMergeReport.arbitration_required,
+    merge_blocker_count: workspaceMergeReport.blockers.length,
     health: state.timed_out_agents.length > 0 || state.failed.length > 0 ? 'degraded' : 'healthy',
     updated_at: state.updated_at,
   };
   fs.writeFileSync(path.join(runDir, 'multi-agent-summary.json'), JSON.stringify(summary, null, 2), 'utf8');
 }
 
-function ensureIsolatedAgents(agents: AgentSpec[]): void {
+function ensureIsolatedAgents(agents: AgentSpec[]): void {
   const shared = agents.filter((agent) => agent.workspaceManager.isolation_level !== 'isolated');
   if (shared.length === 0) return;
   const ids = shared.map((agent) => `${agent.id}:${agent.workspaceManager.isolation_level}`).join(', ');
@@ -167,7 +213,8 @@ function makeState(
   failed: string[],
   blocked: string[],
   orphanReassignments: Array<{ from_agent_id: string; to_agent_id: string; work_item_ids: string[] }>,
-  timedOutAgents: Array<{ agent_id: string; work_item_ids: string[]; detected_at: string }>
+  timedOutAgents: Array<{ agent_id: string; work_item_ids: string[]; detected_at: string }>,
+  workspaceMergeReport: WorkspaceMergeReport = emptyWorkspaceMergeReport(runId)
 ): MultiAgentStatusSnapshot {
   return {
     run_id: runId,
@@ -179,7 +226,7 @@ function makeState(
     completed,
     failed,
     blocked,
-    agent_results: agents.map((agent, idx) => {
+    agent_results: agents.map((agent, idx) => {
       const result = agentResults.find((entry) => entry.agent_id === agent.id);
       return {
         agent_id: agent.id,
@@ -191,12 +238,150 @@ function makeState(
         reassigned_task_ids: result?.reassigned_task_ids ?? [],
       };
     }),
+    worktrees: workspaceMergeReport.records,
+    workspace_merge: workspaceMergeReport,
+    merge_blockers: workspaceMergeReport.blockers,
+    arbitration_required: workspaceMergeReport.arbitration_required,
     orphan_reassignments: orphanReassignments,
     timed_out_agents: timedOutAgents,
     updated_at: new Date().toISOString(),
   };
 }
 
+function emptyWorkspaceMergeReport(runId: string): WorkspaceMergeReport {
+  return {
+    schema_version: 1,
+    run_id: runId,
+    generated_at: new Date().toISOString(),
+    workspace_isolation: 'git_worktree',
+    merge_readiness: 'ready',
+    arbitration_required: false,
+    blockers: [],
+    records: [],
+  };
+}
+
+function ensureGitWorktreeLease(agent: AgentSpec, lease: WorkspaceLease): void {
+  if (lease.isolation_level !== 'isolated' || lease.strategy !== 'git_worktree') {
+    throw new Error(`Multi-agent real requires git_worktree isolated workspace. Agent ${agent.id} received ${lease.strategy}/${lease.isolation_level}.`);
+  }
+}
+
+function mutationScopeOf(node?: GraphNode): string[] {
+  return Array.isArray(node?.mutation_scope) ? node!.mutation_scope.map(String).filter(Boolean) : [];
+}
+
+function createMergeRecord(
+  agent: AgentSpec,
+  node: GraphNode,
+  lease: WorkspaceLease,
+  result?: TaskResult
+): WorkspaceMergeRecord {
+  const evidenceCount = Array.isArray(result?.evidence) ? result!.evidence.length : 0;
+  return {
+    work_item_id: node.id,
+    agent_id: agent.id,
+    workspace_id: lease.workspace_id,
+    strategy: lease.strategy,
+    isolation_level: lease.isolation_level,
+    branch: lease.branch ?? null,
+    base_commit: lease.base_commit ?? null,
+    root_path: lease.root_path ?? null,
+    mutation_scope: mutationScopeOf(node),
+    diff_paths: mutationScopeOf(node),
+    evidence_count: evidenceCount,
+    verify_status: result ? (result.success ? 'pass' : 'fail') : 'partial',
+    status: result ? (result.success ? 'ready' : 'blocked') : 'ready',
+    blocker: result && !result.success ? `verify_failed:${result.failure_class}` : null,
+    recorded_at: new Date().toISOString(),
+  };
+}
+
+function buildWorkspaceMergeReport(
+  runId: string,
+  records: WorkspaceMergeRecord[],
+  extraBlockers: string[] = [],
+  arbitrationRequired = false
+): WorkspaceMergeReport {
+  const blockers = [
+    ...extraBlockers,
+    ...records.filter((record) => record.status === 'blocked' && record.blocker).map((record) => `${record.work_item_id}:${record.blocker}`),
+  ];
+  return {
+    schema_version: 1,
+    run_id: runId,
+    generated_at: new Date().toISOString(),
+    workspace_isolation: 'git_worktree',
+    merge_readiness: blockers.length > 0 ? 'blocked' : records.some((record) => record.status === 'ready') ? 'partial' : 'ready',
+    arbitration_required: arbitrationRequired,
+    blockers,
+    records,
+  };
+}
+
+function detectMutationConflicts(graph: ExecutionGraph, agents: AgentSpec[], partitions: string[][]): string[] {
+  const owners = new Map<string, string>();
+  const conflicts: string[] = [];
+  for (let idx = 0; idx < agents.length; idx += 1) {
+    for (const nodeId of partitions[idx] ?? []) {
+      const node = graph.nodes.get(nodeId);
+      for (const scope of mutationScopeOf(node)) {
+        const previous = owners.get(scope);
+        if (previous && previous !== agents[idx].id) {
+          conflicts.push(`mutation_scope_overlap:${scope}:${previous}:${agents[idx].id}`);
+        } else {
+          owners.set(scope, agents[idx].id);
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+
+function applyWorkspaceRecord(projectRoot: string, record: WorkspaceMergeRecord): WorkspaceMergeRecord {
+  if (!record.root_path || record.status !== 'ready') return record;
+  for (const relativePath of record.mutation_scope) {
+    const source = path.join(record.root_path, relativePath);
+    const target = path.join(projectRoot, relativePath);
+    if (!fs.existsSync(source) || fs.statSync(source).isDirectory()) {
+      return { ...record, status: 'blocked', blocker: `missing_output:${relativePath}` };
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(source, target);
+  }
+  return { ...record, status: 'merged', blocker: null };
+}
+
+function createTrackingWorkspaceManager(
+  base: WorkspaceManager,
+  agent: AgentSpec,
+  graph: ExecutionGraph,
+  records: WorkspaceMergeRecord[]
+): WorkspaceManager & { disposeDeferred(): Promise<void> } {
+  const leases = new Map<string, WorkspaceLease>();
+  return {
+    isolation_level: base.isolation_level,
+    allocate: async (req: WorkspaceRequest) => {
+      const lease = await base.allocate(req);
+      ensureGitWorktreeLease(agent, lease);
+      leases.set(lease.workspace_id, lease);
+      const node = graph.nodes.get(req.work_item_id);
+      if (node) records.push(createMergeRecord(agent, node, lease));
+      return lease;
+    },
+    snapshot: (id: string): Promise<SnapshotRef> => base.snapshot(id),
+    reset: (id: string, snapRef: SnapshotRef): Promise<void> => base.reset(id, snapRef),
+    dispose: async () => {
+      // Scheduler calls dispose before the coordinator can reconcile diffs.
+      // Defer real cleanup until the merge report has been produced.
+    },
+    disposeDeferred: async () => {
+      await Promise.all([...leases.keys()].map((id) => base.dispose(id).catch(() => {})));
+      leases.clear();
+    },
+  };
+}
+
 async function runGraphForAgent(
   graph: ExecutionGraph,
   nodeIds: string[],
@@ -211,8 +396,11 @@ async function runGraphForAgent(
   timed_out: boolean;
   assigned_task_ids: string[];
   reassigned_task_ids: string[];
+  workspace_records: WorkspaceMergeRecord[];
+  cleanup: () => Promise<void>;
 }> {
   const subGraph = subGraphFor(graph, nodeIds);
+  const workspaceRecords: WorkspaceMergeRecord[] = [];
   if (subGraph.nodes.size === 0) {
     return {
       agent_id: agent.id,
@@ -221,14 +409,17 @@ async function runGraphForAgent(
       timed_out: false,
       assigned_task_ids: nodeIds,
       reassigned_task_ids: [],
+      workspace_records: workspaceRecords,
+      cleanup: async () => {},
     };
   }
+  const trackingWorkspaceManager = createTrackingWorkspaceManager(agent.workspaceManager, agent, graph, workspaceRecords);
   const ctx: SchedulerContext = {
     projectRoot: opts.projectRoot,
     sessionId: opts.sessionId,
     runId: `${opts.runId}-agent${idx}`,
     executor: agent.executor,
-    workspaceManager: agent.workspaceManager,
+    workspaceManager: trackingWorkspaceManager,
     onEvent: opts.onEvent,
   };
   const scheduler = new Scheduler();
@@ -242,6 +433,8 @@ async function runGraphForAgent(
       timed_out: false,
       assigned_task_ids: nodeIds,
       reassigned_task_ids: [],
+      workspace_records: workspaceRecords,
+      cleanup: () => trackingWorkspaceManager.disposeDeferred(),
     };
   }
   let timer: NodeJS.Timeout | null = null;
@@ -260,6 +453,8 @@ async function runGraphForAgent(
       timed_out: true,
       assigned_task_ids: nodeIds,
       reassigned_task_ids: [],
+      workspace_records: workspaceRecords,
+      cleanup: () => trackingWorkspaceManager.disposeDeferred(),
     };
   }
   const result = raced.result;
@@ -270,6 +465,8 @@ async function runGraphForAgent(
     timed_out: false,
     assigned_task_ids: nodeIds,
     reassigned_task_ids: [],
+    workspace_records: workspaceRecords,
+    cleanup: () => trackingWorkspaceManager.disposeDeferred(),
   };
 }
 
@@ -290,6 +487,30 @@ async function runParallel(
       partitions[index % agents.length].push(id);
     });
   }
+  const mutationConflicts = detectMutationConflicts(graph, agents, partitions);
+  if (mutationConflicts.length > 0) {
+    const blocked = mutationConflicts;
+    const workspaceMergeReport = buildWorkspaceMergeReport(runId, [], blocked);
+    const state = makeState('parallel', runId, agents, partitions, [], [], [], blocked, [], [], workspaceMergeReport);
+    persistMultiAgentArtifacts(projectRoot, runId, state, [], [], workspaceMergeReport);
+    appendEvent(projectRoot, sessionId, {
+      type: 'WorkItemBlocked',
+      run_id: runId,
+      payload: { mode: 'parallel', blockers: blocked },
+    });
+    return {
+      mode: 'parallel',
+      run_id: runId,
+      completed: [],
+      failed: [],
+      blocked,
+      agent_results: [],
+      arbitration_results: [],
+      workspace_merge_report: workspaceMergeReport,
+      state,
+      summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
+    };
+  }
   const registry = new AgentRegistry(heartbeatTimeoutMs == null ? 30_000 : heartbeatTimeoutMs);
   agents.forEach((agent, idx) => {
     registry.register(agent.id, agent.executor, agent.workspaceManager, partitions[idx] ?? []);
@@ -331,7 +552,13 @@ async function runParallel(
     const rerun = await runGraphForAgent(graph, timedOut.assigned_task_ids, agents[fallbackIdx], fallbackIdx, opts, null);
     fallback.completed.push(...rerun.completed);
     fallback.failed.push(...rerun.failed);
+    fallback.workspace_records.push(...rerun.workspace_records);
     fallback.reassigned_task_ids.push(...timedOut.assigned_task_ids);
+    const previousCleanup = fallback.cleanup;
+    fallback.cleanup = async () => {
+      await previousCleanup?.();
+      await rerun.cleanup?.();
+    };
     partitions[fallbackIdx] = [...partitions[fallbackIdx], ...timedOut.assigned_task_ids];
     partitions[timeoutIdx] = [];
     orphanReassignments.push({
@@ -343,8 +570,14 @@ async function runParallel(
 
   const completed = Array.from(new Set(agentResults.flatMap((result) => result.completed)));
   const failed = Array.from(new Set(agentResults.flatMap((result) => result.failed)));
-  const state = makeState('parallel', runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments, timedOutAgents);
-  persistMultiAgentArtifacts(projectRoot, runId, state);
+  const rawRecords = agentResults.flatMap((result) => result.workspace_records || []);
+  const mergedRecords = opts.applyWorkspaceMerges
+    ? rawRecords.map((record) => applyWorkspaceRecord(projectRoot, record))
+    : rawRecords;
+  await Promise.all(agentResults.map((result) => result.cleanup?.().catch(() => {})));
+  const workspaceMergeReport = buildWorkspaceMergeReport(runId, mergedRecords, blocked);
+  const state = makeState('parallel', runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments, timedOutAgents, workspaceMergeReport);
+  persistMultiAgentArtifacts(projectRoot, runId, state, [], [], workspaceMergeReport);
 
   appendEvent(projectRoot, sessionId, {
     type: 'RunCompleted',
@@ -357,9 +590,10 @@ async function runParallel(
     run_id: runId,
     completed,
     failed,
-    blocked,
+    blocked,
     agent_results: agentResults,
     arbitration_results: [],
+    workspace_merge_report: workspaceMergeReport,
     state,
     summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
   };
@@ -387,12 +621,13 @@ async function runCompetitive(
   const completed: string[] = [];
   const failed: string[] = [];
   const blocked: string[] = [];
-  const arbitrationResults: ArbitrationRecord[] = [];
+  const arbitrationResults: ArbitrationRecord[] = [];
+  const workspaceRecords: WorkspaceMergeRecord[] = [];
 
   for (const wave of graph.waves) {
     for (const nodeId of wave.node_ids) {
       const node = graph.nodes.get(nodeId)!;
-      const result = await competeTwoAgents(nodeId, node, agentA, agentB, opts, arbitrationResults);
+      const result = await competeTwoAgents(nodeId, node, agentA, agentB, opts, arbitrationResults, workspaceRecords);
       if (result.success) completed.push(nodeId);
       else failed.push(nodeId);
       if (failed.length > 0) break;
@@ -401,6 +636,7 @@ async function runCompetitive(
   }
 
   const partitions = [Array.from(graph.nodes.keys()), Array.from(graph.nodes.keys())];
+  const workspaceMergeReport = buildWorkspaceMergeReport(runId, workspaceRecords, blocked, true);
   const state = makeState(
     'competitive',
     runId,
@@ -414,9 +650,10 @@ async function runCompetitive(
     failed,
     blocked,
     [],
-    []
+    [],
+    workspaceMergeReport
   );
-  persistMultiAgentArtifacts(projectRoot, runId, state, [], arbitrationResults);
+  persistMultiAgentArtifacts(projectRoot, runId, state, [], arbitrationResults, workspaceMergeReport);
 
   appendEvent(projectRoot, sessionId, {
     type: 'RunCompleted',
@@ -435,6 +672,7 @@ async function runCompetitive(
       { agent_id: agentB.id, completed: [], failed: [] },
     ],
     arbitration_results: arbitrationResults,
+    workspace_merge_report: workspaceMergeReport,
     state,
     summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
   };
@@ -443,19 +681,22 @@ async function runCompetitive(
 async function competeTwoAgents(
   nodeId: string,
   node: GraphNode,
-  agentA: AgentSpec,
-  agentB: AgentSpec,
-  opts: CoordinationOptions,
-  arbitrationResults: ArbitrationRecord[]
-): Promise<TaskResult> {
+  agentA: AgentSpec,
+  agentB: AgentSpec,
+  opts: CoordinationOptions,
+  arbitrationResults: ArbitrationRecord[],
+  workspaceRecords: WorkspaceMergeRecord[]
+): Promise<TaskResult> {
   const { projectRoot, sessionId, runId } = opts;
 
-  const allocA = await agentA.workspaceManager.allocate({
-    work_item_id: nodeId, attempt_number: 1, strategy: node.workspace_strategy, mutation_scope: node.mutation_scope,
-  });
-  const allocB = await agentB.workspaceManager.allocate({
-    work_item_id: nodeId, attempt_number: 1, strategy: node.workspace_strategy, mutation_scope: node.mutation_scope,
-  });
+  const allocA = await agentA.workspaceManager.allocate({
+    work_item_id: nodeId, attempt_number: 1, strategy: node.workspace_strategy, mutation_scope: node.mutation_scope,
+  });
+  ensureGitWorktreeLease(agentA, allocA);
+  const allocB = await agentB.workspaceManager.allocate({
+    work_item_id: nodeId, attempt_number: 1, strategy: node.workspace_strategy, mutation_scope: node.mutation_scope,
+  });
+  ensureGitWorktreeLease(agentB, allocB);
 
   appendEvent(projectRoot, sessionId, {
     type: 'AttemptStarted',
@@ -473,13 +714,24 @@ async function competeTwoAgents(
     })),
   ]);
 
-  await Promise.all([
-    agentA.workspaceManager.dispose(allocA.workspace_id).catch(() => {}),
-    agentB.workspaceManager.dispose(allocB.workspace_id).catch(() => {}),
-  ]);
-
-  const winner = resultA.success ? resultA : resultB.success ? resultB : resultA;
-  const winnerAgentId = resultA.success ? agentA.id : resultB.success ? agentB.id : agentA.id;
+  const candidates = [
+    { agent: agentA, alloc: allocA, result: resultA },
+    { agent: agentB, alloc: allocB, result: resultB },
+  ].sort((left, right) => {
+    const leftScore = (left.result.success ? 10_000 : 0) + left.result.evidence.length * 100 - String(left.result.output || '').length;
+    const rightScore = (right.result.success ? 10_000 : 0) + right.result.evidence.length * 100 - String(right.result.output || '').length;
+    return rightScore - leftScore;
+  });
+  const winnerCandidate = candidates[0];
+  const winner = winnerCandidate.result;
+  const winnerAgentId = winnerCandidate.agent.id;
+  const winnerRecord = createMergeRecord(winnerCandidate.agent, node, winnerCandidate.alloc, winner);
+  workspaceRecords.push(opts.applyWorkspaceMerges ? applyWorkspaceRecord(projectRoot, winnerRecord) : winnerRecord);
+
+  await Promise.all([
+    agentA.workspaceManager.dispose(allocA.workspace_id).catch(() => {}),
+    agentB.workspaceManager.dispose(allocB.workspace_id).catch(() => {}),
+  ]);
   arbitrationResults.push({
     work_item_id: nodeId,
     mode: 'competitive',
@@ -512,7 +764,8 @@ async function runCooperative(
   ensureIsolatedAgents(opts.agents);
   const [planner, executor] = opts.agents;
   const { projectRoot, sessionId, runId } = opts;
-  const handoffs: CooperativeHandoff[] = [];
+  const handoffs: CooperativeHandoff[] = [];
+  const workspaceRecords: WorkspaceMergeRecord[] = [];
 
   appendEvent(projectRoot, sessionId, {
     type: 'RunStarted',
@@ -528,13 +781,14 @@ async function runCooperative(
     for (const nodeId of wave.node_ids) {
       const node = graph.nodes.get(nodeId)!;
 
-      const planAlloc = await planner.workspaceManager.allocate({
+      const planAlloc = await planner.workspaceManager.allocate({
         work_item_id: nodeId,
         attempt_number: 1,
         strategy: node.workspace_strategy,
-        mutation_scope: node.mutation_scope,
-      });
-      await planner.workspaceManager.dispose(planAlloc.workspace_id).catch(() => {});
+        mutation_scope: node.mutation_scope,
+      });
+      ensureGitWorktreeLease(planner, planAlloc);
+      await planner.workspaceManager.dispose(planAlloc.workspace_id).catch(() => {});
 
       const handoff = buildHandoff({
         from_agent_id: planner.id,
@@ -553,12 +807,13 @@ async function runCooperative(
         payload: { mode: 'cooperative', handoff_id: handoff.handoff_id },
       });
 
-      const execAlloc = await executor.workspaceManager.allocate({
+      const execAlloc = await executor.workspaceManager.allocate({
         work_item_id: nodeId,
         attempt_number: 1,
         strategy: node.workspace_strategy,
-        mutation_scope: node.mutation_scope,
-      });
+        mutation_scope: node.mutation_scope,
+      });
+      ensureGitWorktreeLease(executor, execAlloc);
 
       let result: TaskResult;
       try {
@@ -566,7 +821,9 @@ async function runCooperative(
       } catch (error) {
         result = { success: false, failure_class: 'env', evidence: [], output: String(error) };
       }
-      await executor.workspaceManager.dispose(execAlloc.workspace_id).catch(() => {});
+      const mergeRecord = createMergeRecord(executor, node, execAlloc, result);
+      workspaceRecords.push(opts.applyWorkspaceMerges ? applyWorkspaceRecord(projectRoot, mergeRecord) : mergeRecord);
+      await executor.workspaceManager.dispose(execAlloc.workspace_id).catch(() => {});
 
       if (result.success) {
         completed.push(nodeId);
@@ -581,6 +838,7 @@ async function runCooperative(
   }
 
   const partitions = [Array.from(graph.nodes.keys()), Array.from(graph.nodes.keys())];
+  const workspaceMergeReport = buildWorkspaceMergeReport(runId, workspaceRecords, blocked);
   const state = makeState(
     'cooperative',
     runId,
@@ -594,9 +852,10 @@ async function runCooperative(
     failed,
     blocked,
     [],
-    []
+    [],
+    workspaceMergeReport
   );
-  persistMultiAgentArtifacts(projectRoot, runId, state, handoffs, []);
+  persistMultiAgentArtifacts(projectRoot, runId, state, handoffs, [], workspaceMergeReport);
 
   appendEvent(projectRoot, sessionId, {
     type: 'RunCompleted',
@@ -616,6 +875,7 @@ async function runCooperative(
     ],
     handoffs,
     arbitration_results: [],
+    workspace_merge_report: workspaceMergeReport,
     state,
     summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
   };
@@ -643,6 +903,10 @@ export function multiAgentSummaryPath(projectRoot: string, runId: string): strin
   return path.join(projectRoot, '.oxe', 'runs', runId, 'multi-agent-summary.json');
 }
 
+export function workspaceMergeReportPath(projectRoot: string, runId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, 'workspace-merge-report.json');
+}
+
 export function loadMultiAgentState(projectRoot: string, runId: string): MultiAgentStatusSnapshot | null {
   const statePath = multiAgentStatePath(projectRoot, runId);
   if (!fs.existsSync(statePath)) return null;
@@ -662,6 +926,16 @@ export function loadMultiAgentSummary(projectRoot: string, runId: string): Multi
     return null;
   }
 }
+
+export function loadWorkspaceMergeReport(projectRoot: string, runId: string): WorkspaceMergeReport | null {
+  const reportPath = workspaceMergeReportPath(projectRoot, runId);
+  if (!fs.existsSync(reportPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(reportPath, 'utf8')) as WorkspaceMergeReport;
+  } catch {
+    return null;
+  }
+}
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────