Method dryRunMerge

src/orchestration/staging.ts:104–141

* Dry-run a candidate result. Stages its edits provisionally, then runs the * conflict checks. Returns conflicts (empty = clean). Does NOT commit.

(node: TaskNode, result: WorkerResult)

   * conflict checks. Returns conflicts (empty = clean). Does NOT commit.
   */
  async dryRunMerge(node: TaskNode, result: WorkerResult): Promise<ConflictRecord[]> {
    const conflicts: ConflictRecord[] = [];

    for (const edit of result.fileEdits) {
      // (a) same-file-write against another in-flight/committed node.
      const prior = this.staged.get(edit.path);
      if (prior && prior.taskId !== node.id) {
        conflicts.push({
          taskA: prior.taskId, taskB: node.id, file: edit.path,
          kind: 'same-file-write', resolution: 'serialized',
        });
      }

      // (b) import-broken: did this edit REMOVE an export that a known importer needs?
      const before = await this.currentContent(edit.path);
      if (before && !edit.isNew) {
        const removed = setDiff(extractExports(before), extractExports(edit.content));
        if (removed.size > 0) {
          const broken = await this.findBrokenImporters(edit.path, removed);
          for (const b of broken) {
            conflicts.push({
              taskA: node.id, taskB: b.importerTask ?? '(committed)', file: b.importer,
              kind: 'import-broken', resolution: 'manual-required',
            });
          }
        }
      }
    }

    // Provisionally stage (so subsequent dry-runs this tick see it). If the
    // scheduler decides the conflicts are fatal it will not call commit, and the
    // stage is rolled back via unstage().
    for (const edit of result.fileEdits) {
      this.staged.set(edit.path, { taskId: node.id, content: edit.content, isNew: edit.isNew });
    }

    return conflicts;
  }

  /**
   * Find files (committed or staged) that import one of `removedExports` from