@ulpi/cli 0.1.4 → 0.1.6

package/dist/dist-AYBGHEDY.js

@@ -0,0 +1,2541 @@
+import {
+  DEFAULT_ENGINE_CONFIG,
+  ExecutionEngine
+} from "./chunk-EJ7TW77N.js";
+import "./chunk-S6ANCSYO.js";
+import "./chunk-76D3BYJD.js";
+import "./chunk-IZPJHSPX.js";
+import "./chunk-5MI5GIXM.js";
+import "./chunk-SEU7WWNQ.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+
+// ../../packages/parallel-engine/dist/index.js
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import { readFileSync, writeFileSync } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
+var DEFAULT_PARALLEL_CONFIG = {
+  maxWorkers: 3,
+  cwd: process.cwd(),
+  maxIterationsPerWorker: 10,
+  aiConflictResolution: true,
+  maxRequeueCount: 1,
+  minFreeDiskSpace: 500 * 1024 * 1024,
+  enableValidation: true,
+  validationMaxIterations: 15
+};
+function validateDAG(tasks) {
+  const taskMap = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    taskMap.set(task.id, task);
+  }
+  const nodes = buildGraph(tasks, taskMap);
+  const { cyclicIds } = topologicalSort(nodes);
+  return {
+    valid: cyclicIds.size === 0,
+    cyclicTaskIds: [...cyclicIds]
+  };
+}
+function topologicalSortTasks(tasks) {
+  const taskMap = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    taskMap.set(task.id, task);
+  }
+  const nodes = buildGraph(tasks, taskMap);
+  const { order, cyclicIds } = topologicalSort(nodes);
+  if (cyclicIds.size > 0) {
+    throw new Error(
+      `Dependency cycle detected involving tasks: ${[...cyclicIds].join(", ")}`
+    );
+  }
+  return order;
+}
+function buildParallelGroups(tasks) {
+  const analysis = analyzeTaskGraph(tasks);
+  return analysis.groups;
+}
+function analyzeTaskGraph(tasks) {
+  const taskMap = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    taskMap.set(task.id, task);
+  }
+  const nodes = buildGraph(tasks, taskMap);
+  const { depths, order, cyclicIds } = topologicalSort(nodes);
+  for (const id of cyclicIds) {
+    const node = nodes.get(id);
+    if (node) {
+      node.inCycle = true;
+    }
+  }
+  for (const [id, depth] of depths) {
+    const node = nodes.get(id);
+    if (node) {
+      node.depth = depth;
+    }
+  }
+  const groups = groupByDepth(nodes, depths, cyclicIds);
+  const warnings = [];
+  if (cyclicIds.size > 0) {
+    warnings.push(
+      `Dependency cycle detected involving ${cyclicIds.size} task(s): ${[...cyclicIds].join(", ")}. These tasks cannot be scheduled.`
+    );
+  }
+  const affectedFiles = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const affects = task.metadata?.affects;
+    if (Array.isArray(affects)) {
+      for (const file of affects) {
+        if (typeof file === "string") {
+          const existing = affectedFiles.get(file) ?? [];
+          existing.push(task.id);
+          affectedFiles.set(file, existing);
+        }
+      }
+    }
+  }
+  for (const [file, taskIds] of affectedFiles) {
+    if (taskIds.length > 1) {
+      for (let i = 0; i < taskIds.length; i++) {
+        for (let j = i + 1; j < taskIds.length; j++) {
+          const a = taskIds[i];
+          const b = taskIds[j];
+          const nodeA = nodes.get(a);
+          const nodeB = nodes.get(b);
+          if (nodeA && nodeB && !nodeA.dependencies.includes(b) && !nodeB.dependencies.includes(a)) {
+            warnings.push(
+              `Tasks "${a}" and "${b}" both affect "${file}" but have no explicit dependency. Consider adding a dependency to avoid merge conflicts.`
+            );
+          }
+        }
+      }
+    }
+  }
+  const maxParallelism = groups.length > 0 ? Math.max(...groups.map((g) => g.tasks.length)) : 0;
+  return {
+    groups,
+    order,
+    warnings,
+    nodes,
+    cyclicTaskIds: [...cyclicIds],
+    maxParallelism
+  };
+}
+function buildGraph(tasks, taskMap) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    nodes.set(task.id, {
+      task,
+      dependencies: [],
+      dependents: [],
+      depth: 0,
+      inCycle: false
+    });
+  }
+  for (const task of tasks) {
+    const node = nodes.get(task.id);
+    if (!node) continue;
+    if (task.dependsOn) {
+      for (const depId of task.dependsOn) {
+        if (taskMap.has(depId) && !node.dependencies.includes(depId)) {
+          node.dependencies.push(depId);
+          const depNode = nodes.get(depId);
+          if (depNode && !depNode.dependents.includes(task.id)) {
+            depNode.dependents.push(task.id);
+          }
+        }
+      }
+    }
+    if (task.blocks) {
+      for (const blockedId of task.blocks) {
+        if (taskMap.has(blockedId)) {
+          const blockedNode = nodes.get(blockedId);
+          if (blockedNode && !blockedNode.dependencies.includes(task.id)) {
+            blockedNode.dependencies.push(task.id);
+          }
+          if (!node.dependents.includes(blockedId)) {
+            node.dependents.push(blockedId);
+          }
+        }
+      }
+    }
+  }
+  return nodes;
+}
+function topologicalSort(nodes) {
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const [id, node] of nodes) {
+    inDegree.set(id, node.dependencies.length);
+  }
+  let currentLevel = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) {
+      currentLevel.push(id);
+    }
+  }
+  const depths = /* @__PURE__ */ new Map();
+  const order = [];
+  let depth = 0;
+  let processedCount = 0;
+  while (currentLevel.length > 0) {
+    const nextLevel = [];
+    currentLevel.sort((a, b) => {
+      const nodeA = nodes.get(a);
+      const nodeB = nodes.get(b);
+      return (nodeA?.task.priority ?? 2) - (nodeB?.task.priority ?? 2);
+    });
+    for (const id of currentLevel) {
+      depths.set(id, depth);
+      order.push(id);
+      processedCount++;
+      const node = nodes.get(id);
+      if (!node) continue;
+      for (const dependentId of node.dependents) {
+        const currentDeg = inDegree.get(dependentId) ?? 0;
+        const newDeg = currentDeg - 1;
+        inDegree.set(dependentId, newDeg);
+        if (newDeg === 0) {
+          nextLevel.push(dependentId);
+        }
+      }
+    }
+    currentLevel = nextLevel;
+    depth++;
+  }
+  const cyclicIds = /* @__PURE__ */ new Set();
+  if (processedCount < nodes.size) {
+    for (const [id] of nodes) {
+      if (!depths.has(id)) {
+        cyclicIds.add(id);
+      }
+    }
+  }
+  return { depths, order, cyclicIds };
+}
+function groupByDepth(nodes, depths, cyclicIds) {
+  const depthBuckets = /* @__PURE__ */ new Map();
+  for (const [id, d] of depths) {
+    if (cyclicIds.has(id)) continue;
+    const node = nodes.get(id);
+    if (!node) continue;
+    let bucket = depthBuckets.get(d);
+    if (!bucket) {
+      bucket = [];
+      depthBuckets.set(d, bucket);
+    }
+    bucket.push(node.task);
+  }
+  const sortedDepths = [...depthBuckets.keys()].sort((a, b) => a - b);
+  const groups = [];
+  for (const d of sortedDepths) {
+    const tasks = depthBuckets.get(d);
+    if (!tasks || tasks.length === 0) continue;
+    tasks.sort((a, b) => a.priority - b.priority);
+    groups.push({
+      depth: d,
+      tasks
+    });
+  }
+  return groups;
+}
+var DEFAULT_MIN_FREE_DISK_SPACE = 500 * 1024 * 1024;
+var DEFAULT_MAX_WORKTREES = 8;
+function sanitizeBranchName(taskId) {
+  let sanitized = taskId;
+  sanitized = sanitized.replace(/[\s~^:?*[\]\\@{]/g, "-");
+  sanitized = sanitized.replace(/\/+/g, "/").replace(/-+/g, "-");
+  sanitized = sanitized.replace(/\.{2,}/g, ".");
+  sanitized = sanitized.replace(/^[./-]+|[./-]+$/g, "");
+  if (sanitized.endsWith(".lock")) {
+    sanitized = sanitized.slice(0, -5);
+  }
+  if (!sanitized) {
+    sanitized = Buffer.from(taskId).toString("base64").replace(/[^a-zA-Z0-9]/g, "").slice(0, 8) || "task";
+  }
+  return sanitized;
+}
+function getWorktreeBaseDir(cwd) {
+  const parentDir = path.dirname(cwd);
+  const projectName = path.basename(cwd);
+  return path.join(parentDir, ".ulpi-worktrees", projectName);
+}
+var WorktreeManager = class {
+  cwd;
+  worktreeBaseDir;
+  maxWorktrees;
+  minFreeDiskSpace;
+  worktrees = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.cwd = config.cwd;
+    this.worktreeBaseDir = getWorktreeBaseDir(config.cwd);
+    this.maxWorktrees = config.maxWorktrees ?? DEFAULT_MAX_WORKTREES;
+    this.minFreeDiskSpace = config.minFreeDiskSpace ?? DEFAULT_MIN_FREE_DISK_SPACE;
+  }
+  /**
+   * Create a worktree for a worker.
+   * Creates a new git worktree with a dedicated branch from current HEAD.
+   *
+   * @param workerId - Identifier for the worker using this worktree
+   * @param taskId - Task that will be executed in this worktree
+   * @returns Information about the created worktree
+   * @throws If worktree creation fails or disk space is insufficient
+   */
+  async create(workerId, taskId) {
+    const activeCount = this.getActiveCount();
+    if (activeCount >= this.maxWorktrees) {
+      throw new Error(
+        `Maximum worktrees reached (${this.maxWorktrees}). Release existing worktrees before creating new ones.`
+      );
+    }
+    await this.checkDiskSpace();
+    const worktreeId = `worker-${workerId}`;
+    const sanitizedTaskId = sanitizeBranchName(taskId);
+    const branchName = `ulpi-parallel/${sanitizedTaskId}`;
+    const worktreePath = path.join(this.worktreeBaseDir, worktreeId);
+    fs.mkdirSync(this.worktreeBaseDir, { recursive: true });
+    await this.cleanupStale(worktreePath, branchName);
+    this.git(["worktree", "add", "-b", branchName, worktreePath, "HEAD"]);
+    this.copyConfig(worktreePath);
+    const info = {
+      id: worktreeId,
+      path: worktreePath,
+      branch: branchName,
+      workerId,
+      taskId,
+      active: true,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.worktrees.set(worktreeId, info);
+    return info;
+  }
+  /**
+   * Remove a specific worktree but KEEP the branch for merging.
+   * The branch is cleaned up later by `cleanup()` at session end.
+   *
+   * @param workerId - Worker ID whose worktree to remove
+   */
+  async remove(workerId) {
+    const worktreeId = `worker-${workerId}`;
+    const info = this.worktrees.get(worktreeId);
+    if (!info) return;
+    await this.removeWorktreeDir(info);
+    info.active = false;
+  }
+  /**
+   * List all active (tracked) worktrees.
+   */
+  listActive() {
+    return [...this.worktrees.values()].filter((w) => w.active);
+  }
+  /**
+   * Get information about all managed worktrees.
+   */
+  getAll() {
+    return [...this.worktrees.values()];
+  }
+  /**
+   * Get information about a specific worktree.
+   */
+  get(workerId) {
+    return this.worktrees.get(`worker-${workerId}`);
+  }
+  /**
+   * Remove ALL worktrees for this project.
+   * Called at session end or during crash recovery cleanup.
+   */
+  async cleanup() {
+    const errors = [];
+    for (const [id, info] of this.worktrees) {
+      try {
+        await this.removeWorktree(info);
+      } catch (err) {
+        errors.push(`Failed to clean up ${id}: ${err}`);
+      }
+    }
+    this.worktrees.clear();
+    try {
+      const entries = fs.readdirSync(this.worktreeBaseDir);
+      if (entries.length === 0) {
+        fs.rmdirSync(this.worktreeBaseDir);
+        const parentDir = path.dirname(this.worktreeBaseDir);
+        const parentEntries = fs.readdirSync(parentDir);
+        if (parentEntries.length === 0) {
+          fs.rmdirSync(parentDir);
+        }
+      }
+    } catch {
+    }
+    try {
+      this.git(["worktree", "prune"]);
+    } catch {
+    }
+    try {
+      const branches = this.git(["branch", "--list", "ulpi-parallel/*"]);
+      for (const line of branches.split("\n")) {
+        const name = line.trim().replace(/^\*\s*/, "");
+        if (name) {
+          try {
+            this.git(["branch", "-D", name]);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Worktree cleanup had ${errors.length} error(s):
+${errors.join("\n")}`
+      );
+    }
+  }
+  /**
+   * Check if there is enough disk space to create a worktree.
+   * Uses Node.js fs.statfs() first, then falls back to `df` on failure.
+   * @throws If available space is below the minimum threshold
+   */
+  async checkDiskSpace() {
+    const minimumRequired = this.minFreeDiskSpace;
+    try {
+      let available = await this.getAvailableFromStatFs();
+      if (available === null || available <= 0) {
+        available = this.getAvailableFromDf();
+      }
+      if (available === null) {
+        return;
+      }
+      if (available < minimumRequired) {
+        const availMB = Math.round(available / (1024 * 1024));
+        const reqMB = Math.round(minimumRequired / (1024 * 1024));
+        throw new Error(
+          `Insufficient disk space for worktree: ${availMB}MB available, ${reqMB}MB required`
+        );
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("Insufficient disk space")) {
+        throw err;
+      }
+    }
+  }
+  // ─── Private Methods ───
+  getActiveCount() {
+    let count = 0;
+    for (const info of this.worktrees.values()) {
+      if (info.active) count++;
+    }
+    return count;
+  }
+  /**
+   * Remove the worktree directory only, keeping the branch alive for merging.
+   */
+  async removeWorktreeDir(info) {
+    try {
+      this.git(["worktree", "remove", "--force", info.path]);
+    } catch {
+      if (fs.existsSync(info.path)) {
+        fs.rmSync(info.path, { recursive: true, force: true });
+      }
+      try {
+        this.git(["worktree", "prune"]);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Remove the worktree directory AND delete the branch.
+   * Used by cleanup() for full teardown.
+   */
+  async removeWorktree(info) {
+    await this.removeWorktreeDir(info);
+    try {
+      this.git(["branch", "-D", info.branch]);
+    } catch {
+    }
+  }
+  async cleanupStale(worktreePath, branchName) {
+    if (fs.existsSync(worktreePath)) {
+      try {
+        this.git(["worktree", "remove", "--force", worktreePath]);
+      } catch {
+        fs.rmSync(worktreePath, { recursive: true, force: true });
+        this.git(["worktree", "prune"]);
+      }
+    }
+    try {
+      this.git(["branch", "-D", branchName]);
+    } catch {
+    }
+  }
+  /**
+   * Copy .ulpi configuration into a worktree so the agent has project context.
+   */
+  copyConfig(worktreePath) {
+    const configDir = path.join(this.cwd, ".ulpi");
+    const targetDir = path.join(worktreePath, ".ulpi");
+    if (!fs.existsSync(configDir)) return;
+    try {
+      fs.mkdirSync(targetDir, { recursive: true });
+      const guardsFile = path.join(configDir, "guards.yml");
+      if (fs.existsSync(guardsFile)) {
+        fs.copyFileSync(guardsFile, path.join(targetDir, "guards.yml"));
+      }
+      const entries = fs.readdirSync(configDir);
+      for (const entry of entries) {
+        if (entry.endsWith(".yml") || entry.endsWith(".yaml") || entry.endsWith(".json")) {
+          const srcPath = path.join(configDir, entry);
+          const dstPath = path.join(targetDir, entry);
+          if (!fs.existsSync(dstPath)) {
+            fs.copyFileSync(srcPath, dstPath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Read available bytes from fs.statfs.
+   * Returns null if unavailable or unreadable.
+   */
+  async getAvailableFromStatFs() {
+    try {
+      const stats = await fs.promises.statfs(this.cwd);
+      const available = Number(stats.bavail) * Number(stats.bsize);
+      if (!Number.isFinite(available)) {
+        return null;
+      }
+      return available;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Read available bytes from `df -k <path>`.
+   * Returns null if parsing fails or output is unavailable.
+   */
+  getAvailableFromDf() {
+    try {
+      const output = execFileSync("df", ["-k", this.cwd], {
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+      return this.parseDfAvailableBytes(output);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Parse `df` output and return available bytes.
+   */
+  parseDfAvailableBytes(output) {
+    const lines = output.trim().split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length < 2) return null;
+    const header = lines[0]?.toLowerCase();
+    if (!header) return null;
+    const normalizedHeader = header.trim().split(/\s+/).map((value) => value.replace("%", "").trim());
+    const availIndex = normalizedHeader.findIndex(
+      (h) => h === "avail" || h === "available"
+    );
+    if (availIndex < 0) return null;
+    const dataLine = lines.at(-1);
+    if (!dataLine) return null;
+    const values = dataLine.trim().split(/\s+/);
+    if (values.length <= availIndex) return null;
+    const availableKb = Number.parseInt(values[availIndex] ?? "", 10);
+    if (Number.isNaN(availableKb) || !Number.isFinite(availableKb) || availableKb < 0) {
+      return null;
+    }
+    return availableKb * 1024;
+  }
+  /**
+   * Execute a git command in the main repository.
+   * Uses execFileSync with argument array to prevent shell injection.
+   */
+  git(args) {
+    return execFileSync("git", ["-C", this.cwd, ...args], {
+      encoding: "utf-8",
+      timeout: 3e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+};
+function validateGitRef(ref, context) {
+  if (!ref || ref.trim() === "") {
+    throw new Error(`Invalid git ref for ${context}: ref is empty`);
+  }
+  if (ref === "@") {
+    throw new Error(`Invalid git ref for ${context}: is '@'`);
+  }
+  if (ref.includes(" ")) {
+    throw new Error(`Invalid git ref for ${context}: contains spaces`);
+  }
+  if (ref.includes("..")) {
+    throw new Error(`Invalid git ref for ${context}: contains '..'`);
+  }
+  for (let i = 0; i < ref.length; i++) {
+    const code = ref.charCodeAt(i);
+    if (code < 32 || code === 127) {
+      throw new Error(
+        `Invalid git ref for ${context}: contains control characters`
+      );
+    }
+  }
+  if (ref.startsWith(".") || ref.includes("/.")) {
+    throw new Error(`Invalid git ref for ${context}: starts with '.'`);
+  }
+  if (ref.endsWith(".")) {
+    throw new Error(`Invalid git ref for ${context}: ends with '.'`);
+  }
+  if (ref.includes("//")) {
+    throw new Error(
+      `Invalid git ref for ${context}: contains consecutive slashes`
+    );
+  }
+  if (ref.endsWith(".lock")) {
+    throw new Error(`Invalid git ref for ${context}: ends with '.lock'`);
+  }
+  if (ref.endsWith("/")) {
+    throw new Error(`Invalid git ref for ${context}: ends with '/'`);
+  }
+  if (/[~^:?*[\]\\]/.test(ref)) {
+    throw new Error(
+      `Invalid git ref for ${context}: contains invalid characters`
+    );
+  }
+  if (ref.includes("@{")) {
+    throw new Error(
+      `Invalid git ref for ${context}: contains '@{' sequence`
+    );
+  }
+}
+var MergeEngine = class {
+  cwd;
+  queue = [];
+  processing = false;
+  sessionStartTag = null;
+  listeners = [];
+  /** Saved tracker state files (path -> content) for save/restore around merges */
+  savedTrackerState = null;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  /**
+   * Register an event listener.
+   * @returns Unsubscribe function
+   */
+  on(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const idx = this.listeners.indexOf(listener);
+      if (idx >= 0) this.listeners.splice(idx, 1);
+    };
+  }
+  /**
+   * Create a session-level backup tag before any merges begin.
+   * Used for full rollback of the entire parallel session.
+   */
+  createSessionBackup(sessionId) {
+    const tag = `ulpi/session-start/${sessionId}`;
+    validateGitRef(tag, "sessionBackupTag");
+    this.git(["tag", tag, "HEAD"]);
+    this.sessionStartTag = tag;
+    return tag;
+  }
+  /**
+   * Get the session start tag for full rollback.
+   */
+  getSessionStartTag() {
+    return this.sessionStartTag;
+  }
+  /**
+   * Enqueue a completed worker's branch for merging.
+   *
+   * @param sourceBranch - Branch name to merge from
+   * @param targetBranch - Branch name to merge into (typically current branch)
+   * @param taskId - Task ID associated with this merge
+   * @returns The created merge operation
+   */
+  enqueue(sourceBranch, targetBranch, taskId) {
+    const operation = {
+      sourceBranch,
+      targetBranch,
+      taskId,
+      status: "queued",
+      backupTag: `ulpi/backup/${Date.now()}`,
+      commitMessage: `feat(parallel): merge task ${taskId}`
+    };
+    this.queue.push(operation);
+    return operation;
+  }
+  /**
+   * Process all queued merges sequentially.
+   * @returns Array of merge results
+   */
+  async processAll() {
+    const results = [];
+    while (true) {
+      const result = await this.processNext();
+      if (!result) break;
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Process the next merge in the queue.
+   * Returns the merge result, or null if the queue is empty or already processing.
+   */
+  async processNext() {
+    if (this.processing) return null;
+    const operation = this.queue.find((op) => op.status === "queued");
+    if (!operation) return null;
+    this.processing = true;
+    try {
+      return await this.executeMerge(operation);
+    } finally {
+      this.processing = false;
+    }
+  }
+  /**
+   * Get the current merge queue.
+   */
+  getQueue() {
+    return this.queue;
+  }
+  /**
+   * Get the number of pending merges.
+   */
+  getPendingCount() {
+    return this.queue.filter((op) => op.status === "queued").length;
+  }
+  /**
+   * Rollback a specific merge operation using its backup tag.
+   */
+  rollbackMerge(operation) {
+    validateGitRef(operation.backupTag, "backupTag");
+    this.git(["reset", "--hard", operation.backupTag]);
+    this.git(["clean", "-fd"]);
+    operation.status = "rolled-back";
+  }
+  /**
+   * Rollback all merges in this session to the session start point.
+   */
+  rollbackSession() {
+    if (!this.sessionStartTag) {
+      throw new Error("No session start tag available for rollback");
+    }
+    validateGitRef(this.sessionStartTag, "sessionStartTag");
+    this.git(["reset", "--hard", this.sessionStartTag]);
+    this.git(["clean", "-fd"]);
+    for (const op of this.queue) {
+      if (op.status === "completed") {
+        op.status = "rolled-back";
+      }
+    }
+  }
+  /**
+   * Clean up backup tags created during this session.
+   */
+  cleanupTags() {
+    for (const op of this.queue) {
+      try {
+        this.git(["tag", "-d", op.backupTag]);
+      } catch {
+      }
+    }
+    if (this.sessionStartTag) {
+      try {
+        this.git(["tag", "-d", this.sessionStartTag]);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Save tracker state files before a merge operation.
+   * Prevents merge from overwriting tracker state with stale worktree copies.
+   *
+   * @param stateFiles - Array of absolute file paths to save
+   */
+  saveTrackerState(stateFiles) {
+    const saved = /* @__PURE__ */ new Map();
+    for (const filePath of stateFiles) {
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        saved.set(filePath, content);
+      } catch {
+      }
+    }
+    this.savedTrackerState = saved;
+  }
+  /**
+   * Restore tracker state files after a merge operation.
+   * Ensures tracker state is not overwritten by stale worktree versions.
+   */
+  restoreTrackerState() {
+    if (!this.savedTrackerState) return;
+    for (const [filePath, content] of this.savedTrackerState) {
+      try {
+        writeFileSync(filePath, content, "utf-8");
+      } catch {
+      }
+    }
+    this.savedTrackerState = null;
+  }
+  // ─── Private Methods ───
+  /**
+   * Execute a single merge operation.
+   */
+  async executeMerge(operation) {
+    operation.status = "in-progress";
+    const taskId = operation.taskId;
+    this.emit({
+      type: "merge-started",
+      taskId,
+      sourceBranch: operation.sourceBranch,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (!this.branchHasCommits(operation.sourceBranch)) {
+      operation.status = "completed";
+      this.emit({
+        type: "merge-completed",
+        taskId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return {
+        success: true,
+        strategy: "fast-forward",
+        filesChanged: 0
+      };
+    }
+    try {
+      validateGitRef(operation.backupTag, "backupTag");
+      this.git(["tag", operation.backupTag, "HEAD"]);
+    } catch (err) {
+      return this.failMerge(
+        operation,
+        `Failed to create backup tag: ${err}`
+      );
+    }
+    try {
+      validateGitRef(operation.sourceBranch, "sourceBranch");
+      this.git(["merge", "--ff-only", operation.sourceBranch]);
+      const filesChanged = this.getFilesChangedCount(operation.backupTag);
+      const commitSha = this.git(["rev-parse", "--short", "HEAD"]).trim();
+      return this.completeMerge(operation, "fast-forward", filesChanged, commitSha);
+    } catch {
+    }
+    try {
+      this.git([
+        "merge",
+        "--no-edit",
+        "-m",
+        operation.commitMessage,
+        operation.sourceBranch
+      ]);
+      const commitSha = this.git(["rev-parse", "--short", "HEAD"]).trim();
+      const filesChanged = this.getFilesChangedCount(operation.backupTag);
+      return this.completeMerge(operation, "merge-commit", filesChanged, commitSha);
+    } catch {
+    }
+    const conflictedFiles = this.getConflictedFiles();
+    if (conflictedFiles.length > 0) {
+      operation.conflictFiles = conflictedFiles;
+      operation.status = "conflicted";
+      try {
+        this.git(["merge", "--abort"]);
+      } catch {
+      }
+      this.git(["reset", "--hard", operation.backupTag]);
+      this.git(["clean", "-fd"]);
+      const result = {
+        success: false,
+        conflictFiles: conflictedFiles,
+        strategy: "merge-commit",
+        error: `Merge conflicts in ${conflictedFiles.length} file(s): ${conflictedFiles.join(", ")}`
+      };
+      this.emit({
+        type: "merge-failed",
+        taskId,
+        error: result.error ?? "Unknown merge error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return result;
+    }
+    try {
+      this.git(["reset", "--hard", operation.backupTag]);
+      this.git(["clean", "-fd"]);
+    } catch {
+    }
+    return this.failMerge(operation, "Merge failed for unknown reason");
+  }
+  /**
+   * Complete a successful merge operation.
+   */
+  completeMerge(operation, strategy, filesChanged, commitSha) {
+    operation.status = "completed";
+    this.emit({
+      type: "merge-completed",
+      taskId: operation.taskId,
+      commitSha,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      success: true,
+      commitSha,
+      strategy,
+      filesChanged
+    };
+  }
+  /**
+   * Fail a merge operation.
+   */
+  failMerge(operation, error) {
+    operation.status = "failed";
+    this.emit({
+      type: "merge-failed",
+      taskId: operation.taskId,
+      error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      success: false,
+      error
+    };
+  }
+  /**
+   * Check if a branch has commits ahead of current HEAD.
+   */
+  branchHasCommits(branchName) {
+    try {
+      validateGitRef(branchName, "branchName");
+      const output = this.git(["rev-list", "--count", `HEAD..${branchName}`]);
+      const count = parseInt(output.trim(), 10);
+      return count > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the number of files changed between a tag and current HEAD.
+   */
+  getFilesChangedCount(fromTag) {
+    try {
+      validateGitRef(fromTag, "fromTag");
+      const output = this.git(["diff", "--name-only", fromTag, "HEAD"]);
+      return output.trim().split("\n").filter((l) => l.trim()).length;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Get list of conflicted files from git status.
+   */
+  getConflictedFiles() {
+    try {
+      const output = this.git(["status", "--porcelain"]);
+      const conflicted = [];
+      for (const line of output.split("\n")) {
+        const status = line.substring(0, 2);
+        if (status === "UU" || status === "AA" || status === "DD" || status === "AU" || status === "UA" || status === "DU" || status === "UD") {
+          conflicted.push(line.substring(3).trim());
+        }
+      }
+      return conflicted;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Emit a parallel event to all listeners.
+   */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Execute a git command in the main repository.
+   * Uses execFileSync with argument array to prevent shell injection.
+   */
+  git(args) {
+    return execFileSync2("git", ["-C", this.cwd, ...args], {
+      encoding: "utf-8",
+      timeout: 3e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+};
+async function enhanceParallelGroups(groups, projectDir) {
+  try {
+    const { loadGraph, computeCoupling } = await import("./dist-4U5L2X2C.js");
+    const { getCurrentBranch } = await import("./dist-NUXMDXZ3.js");
+    const branch = getCurrentBranch(projectDir);
+    const graph = loadGraph(projectDir, branch);
+    if (!graph) {
+      return { groups, warnings: [] };
+    }
+    const coupling = computeCoupling(graph);
+    const warnings = [];
+    const couplingMap = /* @__PURE__ */ new Map();
+    for (const c of coupling) {
+      couplingMap.set(c.filePath, {
+        afferentCoupling: c.afferentCoupling,
+        efferentCoupling: c.efferentCoupling,
+        instability: c.instability
+      });
+    }
+    const dependsOn = /* @__PURE__ */ new Map();
+    for (const edge of graph.edges) {
+      if (!dependsOn.has(edge.source)) {
+        dependsOn.set(edge.source, /* @__PURE__ */ new Set());
+      }
+      dependsOn.get(edge.source).add(edge.target);
+    }
+    for (const group of groups) {
+      if (group.tasks.length < 2) continue;
+      const taskFiles = /* @__PURE__ */ new Map();
+      for (const task of group.tasks) {
+        const files = extractFileReferences(
+          `${task.title} ${task.description ?? ""}`
+        );
+        taskFiles.set(task.id, files);
+      }
+      const taskIds = group.tasks.map((t) => t.id);
+      for (let i = 0; i < taskIds.length; i++) {
+        const filesA = taskFiles.get(taskIds[i]) ?? /* @__PURE__ */ new Set();
+        for (let j = i + 1; j < taskIds.length; j++) {
+          const filesB = taskFiles.get(taskIds[j]) ?? /* @__PURE__ */ new Set();
+          for (const fileA of filesA) {
+            const depsA = dependsOn.get(fileA);
+            if (!depsA) continue;
+            for (const fileB of filesB) {
+              if (depsA.has(fileB) || dependsOn.get(fileB)?.has(fileA)) {
+                const info = couplingMap.get(fileA);
+                if (info && info.instability > 0.5) {
+                  warnings.push({
+                    groupDepth: group.depth,
+                    file: fileA,
+                    coupledWith: [fileB],
+                    instability: info.instability
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return { groups, warnings };
+  } catch {
+    return { groups, warnings: [] };
+  }
+}
+async function getConflictContext(files, projectDir) {
+  try {
+    const { loadGraph, computeCoupling } = await import("./dist-4U5L2X2C.js");
+    const { loadPageRankMap } = await import("./dist-4U5L2X2C.js");
+    const { getCurrentBranch } = await import("./dist-NUXMDXZ3.js");
+    const branch = getCurrentBranch(projectDir);
+    const graph = loadGraph(projectDir, branch);
+    if (!graph) return "";
+    const pageRanks = loadPageRankMap(projectDir, branch);
+    const coupling = computeCoupling(graph);
+    const couplingMap = /* @__PURE__ */ new Map();
+    for (const c of coupling) {
+      couplingMap.set(c.filePath, {
+        afferentCoupling: c.afferentCoupling,
+        efferentCoupling: c.efferentCoupling,
+        instability: c.instability
+      });
+    }
+    const lines = [];
+    lines.push("## Dependency Analysis for Conflicting Files");
+    lines.push("");
+    for (const file of files) {
+      const rank = pageRanks?.get(file);
+      const cInfo = couplingMap.get(file);
+      lines.push(`### ${file}`);
+      if (rank !== void 0) {
+        lines.push(
+          `- **PageRank**: ${rank.toFixed(6)} (${rank > 0.01 ? "high importance" : rank > 1e-3 ? "medium importance" : "low importance"})`
+        );
+      }
+      if (cInfo) {
+        lines.push(`- **Fan-in** (files depending on this): ${cInfo.afferentCoupling}`);
+        lines.push(`- **Fan-out** (files this depends on): ${cInfo.efferentCoupling}`);
+        lines.push(
+          `- **Instability**: ${cInfo.instability.toFixed(2)} (${cInfo.instability > 0.7 ? "unstable \u2014 easy to change" : cInfo.instability < 0.3 ? "stable \u2014 changes here affect many" : "moderate"})`
+        );
+      }
+      lines.push("");
+    }
+    if (pageRanks && files.length >= 2) {
+      const ranked = files.map((f) => ({ file: f, rank: pageRanks.get(f) ?? 0 })).sort((a, b) => b.rank - a.rank);
+      if (ranked[0].rank > ranked[1].rank * 2) {
+        lines.push(
+          `**Note**: ${ranked[0].file} has significantly higher architectural importance. Prefer preserving its interfaces when resolving conflicts.`
+        );
+      }
+    }
+    return lines.join("\n");
+  } catch {
+    return "";
+  }
+}
+function extractFileReferences(text) {
+  const files = /* @__PURE__ */ new Set();
+  const pattern = /(?:^|\s)([\w./-]+\.\w{1,6})(?:\s|$|[,;:])/g;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    const candidate = match[1];
+    if (candidate.includes("/") && !candidate.startsWith("http")) {
+      files.add(candidate);
+    }
+  }
+  return files;
+}
+var ConflictResolver = class {
+  cwd;
+  llmResolver = null;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  /**
+   * Set the LLM resolver callback.
+   * Called by the executor to inject the LLM-backed resolver.
+   */
+  setLlmResolver(resolver) {
+    this.llmResolver = resolver;
+  }
+  /**
+   * Extract conflict information for a file from the git index.
+   * Uses git's merge stages: :1: (base), :2: (ours), :3: (theirs)
+   *
+   * @param filePath - Path to the conflicting file (relative to repo root)
+   * @returns ConflictInfo with base/ours/theirs content, or null if extraction fails
+   */
+  extractConflict(filePath) {
+    try {
+      const base = this.gitContent(`:1:${filePath}`);
+      const ours = this.gitContent(`:2:${filePath}`);
+      const theirs = this.gitContent(`:3:${filePath}`);
+      return { file: filePath, base, ours, theirs };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Attempt to resolve a conflict using fast-path heuristics.
+   * Avoids LLM call for trivial cases.
+   *
+   * @param conflict - The conflict to resolve
+   * @returns ResolutionResult if a fast-path applies, or null to fall through to LLM
+   */
+  tryFastPath(conflict) {
+    const { base, ours, theirs } = conflict;
+    if (ours === theirs) {
+      return {
+        resolved: true,
+        content: ours,
+        strategy: "fast-path-identical"
+      };
+    }
+    const normalizeWs = (s) => s.replace(/\s+/g, " ").trim();
+    if (normalizeWs(ours) === normalizeWs(theirs)) {
+      return {
+        resolved: true,
+        content: ours,
+        strategy: "fast-path-whitespace"
+      };
+    }
+    if (isImportReorderOnly(base, ours, theirs)) {
+      return {
+        resolved: true,
+        content: ours,
+        strategy: "fast-path-import-reorder"
+      };
+    }
+    return null;
+  }
+  /**
+   * Resolve a conflict using the LLM resolver (or fast-path).
+   *
+   * @param conflict - The conflict to resolve
+   * @param taskContext - Context about the task for the LLM prompt
+   * @returns ResolutionResult
+   */
+  async resolve(conflict, taskContext) {
+    const fastResult = this.tryFastPath(conflict);
+    if (fastResult) {
+      return fastResult;
+    }
+    let depgraphContext = "";
+    try {
+      depgraphContext = await getConflictContext([conflict.file], this.cwd);
+    } catch {
+    }
+    const prompt = buildConflictPrompt(conflict, taskContext, depgraphContext);
+    if (!this.llmResolver) {
+      return {
+        resolved: false,
+        content: prompt,
+        strategy: "llm",
+        error: "No LLM resolver configured. Prompt generated but not executed."
+      };
+    }
+    try {
+      const resolved = await this.llmResolver(prompt);
+      if (resolved !== null) {
+        return {
+          resolved: true,
+          content: resolved,
+          strategy: "llm"
+        };
+      }
+      return {
+        resolved: false,
+        strategy: "failed",
+        error: "LLM resolver returned null"
+      };
+    } catch (err) {
+      return {
+        resolved: false,
+        strategy: "failed",
+        error: `LLM resolver failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  /**
+   * Apply a resolution to a conflicted file.
+   * Writes the resolved content and stages it with git add.
+   *
+   * @param filePath - Path to the file (relative to repo root)
+   * @param content - Resolved content to write
+   */
+  applyResolution(filePath, content) {
+    const absPath = path2.resolve(this.cwd, filePath);
+    fs2.writeFileSync(absPath, content, "utf-8");
+    this.git(["add", filePath]);
+  }
+  /**
+   * Resolve all conflicts for a merge.
+   * Expects the merge to be in a conflicted state (git merge was run, not aborted).
+   *
+   * @param conflictFiles - List of conflicted file paths
+   * @param taskContext - Context about the task
+   * @returns Array of resolution results
+   */
+  async resolveAll(conflictFiles, taskContext) {
+    const results = [];
+    for (const filePath of conflictFiles) {
+      const conflict = this.extractConflict(filePath);
+      if (!conflict) {
+        results.push({
+          resolved: false,
+          strategy: "failed",
+          error: `Failed to extract conflict data for ${filePath}`
+        });
+        continue;
+      }
+      const result = await this.resolve(conflict, taskContext);
+      if (result.resolved && result.content) {
+        this.applyResolution(filePath, result.content);
+      }
+      results.push(result);
+      if (!result.resolved) {
+        break;
+      }
+    }
+    return results;
+  }
+  // ─── Private Methods ───
+  /**
+   * Get file content from a git index stage.
+   */
+  gitContent(ref) {
+    try {
+      return this.git(["show", ref]);
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Execute a git command in the main repository.
+   * Uses execFileSync with argument array to prevent shell injection.
+   */
+  git(args) {
+    return execFileSync3("git", ["-C", this.cwd, ...args], {
+      encoding: "utf-8",
+      timeout: 6e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+};
+function buildConflictPrompt(conflict, ctx, depgraphContext) {
+  const taskLine = ctx ? `Task: ${ctx.taskTitle} (${ctx.taskId})` : "Task: (no context provided)";
+  const depgraphSection = depgraphContext ? `
+${depgraphContext}
+` : "";
+  return `You are resolving a git merge conflict. Output ONLY the resolved file content.
+
+## Context
+File: ${conflict.file}
+${taskLine}
+${depgraphSection}
+## Base Version (common ancestor)
+\`\`\`
+${conflict.base || "(file did not exist)"}
+\`\`\`
+
+## Main Branch (ours)
+\`\`\`
+${conflict.ours}
+\`\`\`
+
+## Worker Branch (theirs - implementing the task)
+\`\`\`
+${conflict.theirs}
+\`\`\`
+
+## Instructions
+1. Merge intelligently - keep changes from both branches where they don't conflict
+2. The worker was implementing the task - preserve their functional changes
+3. Keep main branch updates (formatting, unrelated fixes) where possible
+4. If in doubt, prefer the worker's changes since they implement the requested task
+
+OUTPUT ONLY THE RESOLVED FILE CONTENT. No explanation, no markdown code fences.`;
+}
+function isImportReorderOnly(base, ours, theirs) {
+  if (!base.trim() || !ours.trim() || !theirs.trim()) {
+    return false;
+  }
+  const getImportLines = (content) => content.split("\n").filter(
+    (line) => line.trim().startsWith("import ") || line.trim().startsWith("from ") || line.trim().startsWith("require(") || line.trim().startsWith("const ") && line.includes("require(")
+  ).map((l) => l.trim());
+  const getNonImportLines = (content) => content.split("\n").filter(
+    (line) => !line.trim().startsWith("import ") && !line.trim().startsWith("from ") && !line.trim().startsWith("require(") && !(line.trim().startsWith("const ") && line.includes("require("))
+  );
+  const oursImports = getImportLines(ours);
+  const theirsImports = getImportLines(theirs);
+  const oursNonImport = getNonImportLines(ours);
+  const theirsNonImport = getNonImportLines(theirs);
+  if (oursNonImport.join("\n") !== theirsNonImport.join("\n")) {
+    return false;
+  }
+  const sortedOurs = [...oursImports].sort();
+  const sortedTheirs = [...theirsImports].sort();
+  if (sortedOurs.length !== sortedTheirs.length) {
+    return false;
+  }
+  for (let i = 0; i < sortedOurs.length; i++) {
+    if (sortedOurs[i] !== sortedTheirs[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+var ParallelWorker = class {
+  id;
+  config;
+  status = "pending";
+  startTime = 0;
+  endTime = 0;
+  commitCount = 0;
+  error;
+  listeners = [];
+  constructor(config) {
+    this.id = config.id;
+    this.config = config;
+  }
+  /**
+   * Register a parallel event listener.
+   * @returns Unsubscribe function
+   */
+  on(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const idx = this.listeners.indexOf(listener);
+      if (idx >= 0) this.listeners.splice(idx, 1);
+    };
+  }
+  /**
+   * Start the worker's execution.
+   * Calls the provided executor with the task and worktree info.
+   * Returns when the executor completes (task done, max iterations, or error).
+   *
+   * @param executor - Callback that runs the actual task execution
+   * @returns WorkerResult with execution outcome
+   */
+  async start(executor) {
+    this.status = "running";
+    this.startTime = Date.now();
+    this.commitCount = 0;
+    this.error = void 0;
+    this.emit({
+      type: "worker-started",
+      workerId: this.id,
+      taskId: this.config.task.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      const result = await executor(
+        this.config.task,
+        this.config.worktreePath,
+        this.config.branchName
+      );
+      this.commitCount = result.commitCount ?? 0;
+      this.endTime = Date.now();
+      if (result.success) {
+        this.status = "completed";
+        this.emit({
+          type: "worker-completed",
+          workerId: this.id,
+          taskId: this.config.task.id,
+          success: true,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          workerId: this.id,
+          task: this.config.task,
+          success: true,
+          durationMs: Date.now() - this.startTime,
+          branchName: this.config.branchName,
+          commitCount: this.commitCount,
+          worktreePath: this.config.worktreePath
+        };
+      }
+      this.status = "failed";
+      this.error = result.error ?? "Task execution failed";
+      this.emit({
+        type: "worker-failed",
+        workerId: this.id,
+        taskId: this.config.task.id,
+        error: this.error,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return {
+        workerId: this.id,
+        task: this.config.task,
+        success: false,
+        durationMs: Date.now() - this.startTime,
+        error: this.error,
+        branchName: this.config.branchName,
+        commitCount: this.commitCount,
+        worktreePath: this.config.worktreePath
+      };
+    } catch (err) {
+      this.endTime = Date.now();
+      this.status = "failed";
+      this.error = err instanceof Error ? err.message : String(err);
+      this.emit({
+        type: "worker-failed",
+        workerId: this.id,
+        taskId: this.config.task.id,
+        error: this.error,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return {
+        workerId: this.id,
+        task: this.config.task,
+        success: false,
+        durationMs: Date.now() - this.startTime,
+        error: this.error,
+        branchName: this.config.branchName,
+        commitCount: this.commitCount,
+        worktreePath: this.config.worktreePath
+      };
+    }
+  }
+  /**
+   * Get the current worker state for monitoring.
+   */
+  getState() {
+    return {
+      id: this.id,
+      status: this.status,
+      task: this.config.task,
+      branchName: this.config.branchName,
+      worktreePath: this.config.worktreePath,
+      elapsedMs: this.startTime > 0 ? (this.endTime || Date.now()) - this.startTime : 0,
+      error: this.error,
+      commitCount: this.commitCount
+    };
+  }
+  /**
+   * Get the current worker status.
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get the task assigned to this worker.
+   */
+  getTask() {
+    return this.config.task;
+  }
+  /**
+   * Emit a parallel event to all listeners.
+   */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+};
+var WorkerTrackerProxy = class {
+  meta = { id: "worker-proxy", name: "Worker Proxy", description: "In-memory proxy for parallel workers" };
+  task;
+  taskStatus = "open";
+  completed = false;
+  constructor(task) {
+    this.task = { ...task, status: "open" };
+  }
+  async initialize() {
+  }
+  async isReady() {
+    return true;
+  }
+  async getTasks(filter) {
+    if (filter?.status && !filter.status.includes(this.taskStatus)) return [];
+    if (filter?.excludeIds?.includes(this.task.id)) return [];
+    return [{ ...this.task, status: this.taskStatus }];
+  }
+  async getTask(id) {
+    return id === this.task.id ? { ...this.task, status: this.taskStatus } : void 0;
+  }
+  async getNextTask(filter) {
+    if (this.completed) return void 0;
+    if (filter?.status && !filter.status.includes(this.taskStatus)) return void 0;
+    if (filter?.excludeIds?.includes(this.task.id)) return void 0;
+    return { ...this.task, status: this.taskStatus };
+  }
+  async completeTask(id) {
+    if (id !== this.task.id) return { success: false, message: "Unknown task" };
+    this.taskStatus = "done";
+    this.completed = true;
+    return { success: true, message: "Task completed" };
+  }
+  async updateTaskStatus(id, status) {
+    if (id !== this.task.id) return void 0;
+    this.taskStatus = status;
+    if (status === "done") this.completed = true;
+    return { ...this.task, status: this.taskStatus };
+  }
+  async isComplete() {
+    return this.completed;
+  }
+  async isTaskReady() {
+    return !this.completed;
+  }
+  async sync() {
+    return { success: true, message: "Proxy sync", added: 0, updated: 0, removed: 0 };
+  }
+  getStateFiles() {
+    return [];
+  }
+  getTemplate() {
+    return "";
+  }
+  async dispose() {
+  }
+  /** Check if the forced task was completed. */
+  wasTaskCompleted() {
+    return this.completed;
+  }
+};
+var SESSION_FILE = ".ulpi/parallel-session.json";
+function createParallelSession(sessionId, dagAnalysis, sessionStartTag) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    sessionId,
+    dagAnalysis,
+    lastCompletedGroupIndex: -1,
+    mergedTaskIds: [],
+    failedTaskIds: [],
+    sessionStartTag,
+    startedAt: now,
+    lastUpdatedAt: now
+  };
+}
+function saveParallelSession(cwd, state) {
+  const filePath = path3.join(cwd, SESSION_FILE);
+  const dir = path3.dirname(filePath);
+  fs3.mkdirSync(dir, { recursive: true });
+  const serializable = {
+    ...state,
+    dagAnalysis: serializeDAGAnalysis(state.dagAnalysis)
+  };
+  fs3.writeFileSync(filePath, JSON.stringify(serializable, null, 2), "utf-8");
+}
+function loadParallelSession(cwd) {
+  const filePath = path3.join(cwd, SESSION_FILE);
+  try {
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return {
+      ...parsed,
+      dagAnalysis: deserializeDAGAnalysis(
+        parsed.dagAnalysis
+      )
+    };
+  } catch {
+    return null;
+  }
+}
+function deleteParallelSession(cwd) {
+  const filePath = path3.join(cwd, SESSION_FILE);
+  try {
+    fs3.unlinkSync(filePath);
+  } catch {
+  }
+}
+function hasParallelSession(cwd) {
+  const filePath = path3.join(cwd, SESSION_FILE);
+  return fs3.existsSync(filePath);
+}
+function updateSessionAfterGroup(state, groupIndex, mergedTaskIds, failedTaskIds) {
+  return {
+    ...state,
+    lastCompletedGroupIndex: groupIndex,
+    mergedTaskIds: [...state.mergedTaskIds, ...mergedTaskIds],
+    failedTaskIds: [...state.failedTaskIds, ...failedTaskIds],
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function findOrphanedWorktrees(cwd) {
+  const parentDir = path3.dirname(cwd);
+  const projectName = path3.basename(cwd);
+  const worktreeBase = path3.join(parentDir, ".ulpi-worktrees", projectName);
+  if (!fs3.existsSync(worktreeBase)) {
+    return [];
+  }
+  try {
+    const entries = fs3.readdirSync(worktreeBase, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => path3.join(worktreeBase, e.name));
+  } catch {
+    return [];
+  }
+}
+function cleanupOrphanedSession(cwd) {
+  const orphans = findOrphanedWorktrees(cwd);
+  const errors = [];
+  let cleaned = 0;
+  for (const worktreePath of orphans) {
+    try {
+      execFileSync4("git", ["-C", cwd, "worktree", "remove", "--force", worktreePath], {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      cleaned++;
+    } catch {
+      try {
+        fs3.rmSync(worktreePath, { recursive: true, force: true });
+        execFileSync4("git", ["-C", cwd, "worktree", "prune"], {
+          encoding: "utf-8",
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        cleaned++;
+      } catch (err) {
+        errors.push(`Failed to clean up ${worktreePath}: ${err}`);
+      }
+    }
+  }
+  try {
+    const branches = execFileSync4(
+      "git",
+      ["-C", cwd, "branch", "--list", "ulpi-parallel/*"],
+      {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    for (const line of branches.split("\n")) {
+      const name = line.trim().replace(/^\*\s*/, "");
+      if (name) {
+        try {
+          execFileSync4("git", ["-C", cwd, "branch", "-D", name], {
+            encoding: "utf-8",
+            timeout: 1e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  const parentDir = path3.dirname(cwd);
+  const projectName = path3.basename(cwd);
+  const worktreeBase = path3.join(parentDir, ".ulpi-worktrees", projectName);
+  try {
+    const entries = fs3.readdirSync(worktreeBase);
+    if (entries.length === 0) {
+      fs3.rmdirSync(worktreeBase);
+      const parent = path3.join(parentDir, ".ulpi-worktrees");
+      const parentEntries = fs3.readdirSync(parent);
+      if (parentEntries.length === 0) {
+        fs3.rmdirSync(parent);
+      }
+    }
+  } catch {
+  }
+  deleteParallelSession(cwd);
+  return { cleaned, errors };
+}
+function isOrphanedSession(cwd) {
+  if (!hasParallelSession(cwd)) {
+    return false;
+  }
+  const orphans = findOrphanedWorktrees(cwd);
+  return orphans.length > 0;
+}
+function serializeDAGAnalysis(analysis) {
+  return {
+    ...analysis,
+    nodes: [...analysis.nodes.entries()]
+  };
+}
+function deserializeDAGAnalysis(data) {
+  const entries = data.nodes;
+  return {
+    ...data,
+    nodes: new Map(entries)
+  };
+}
+var DEFAULT_ENGINE_CONFIG_FOR_PARALLEL = {
+  ...DEFAULT_ENGINE_CONFIG,
+  autoCommit: true,
+  workerMode: true
+};
+var ParallelExecutor = class {
+  config;
+  worktreeManager;
+  mergeEngine;
+  conflictResolver;
+  status = "idle";
+  dagAnalysis = null;
+  currentGroupIndex = 0;
+  activeWorkers = [];
+  allWorkerStates = [];
+  totalTasksCompleted = 0;
+  totalTasksFailed = 0;
+  startedAt = null;
+  sessionId;
+  shouldStop = false;
+  /** Re-queue counts per task to prevent infinite retry loops */
+  requeueCounts = /* @__PURE__ */ new Map();
+  /** Track completed task summaries for validation */
+  taskSummaries = [];
+  listeners = [];
+  /** Task executor callback -- injected by the caller (legacy mode) */
+  taskExecutor = null;
+  /** Base engine config for engine-based execution (new mode) */
+  baseEngineConfig;
+  constructor(config, baseEngineConfig) {
+    this.config = {
+      ...DEFAULT_PARALLEL_CONFIG,
+      ...config
+    };
+    this.baseEngineConfig = baseEngineConfig;
+    this.sessionId = `parallel-${Date.now()}`;
+    this.worktreeManager = new WorktreeManager({
+      cwd: this.config.cwd,
+      maxWorktrees: this.config.maxWorkers * 2,
+      // Buffer for re-queued tasks
+      minFreeDiskSpace: this.config.minFreeDiskSpace
+    });
+    this.mergeEngine = new MergeEngine(this.config.cwd);
+    this.conflictResolver = new ConflictResolver(this.config.cwd);
+    this.mergeEngine.on((event) => this.emit(event));
+  }
+  /**
+   * Register a parallel event listener.
+   * @returns Unsubscribe function
+   */
+  on(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const idx = this.listeners.indexOf(listener);
+      if (idx >= 0) this.listeners.splice(idx, 1);
+    };
+  }
+  /**
+   * Set the task executor callback.
+   * This is called for each task to perform the actual work in the worktree.
+   */
+  setTaskExecutor(executor) {
+    this.taskExecutor = executor;
+  }
+  /**
+   * Set the LLM resolver for AI conflict resolution.
+   */
+  setLlmResolver(resolver) {
+    this.conflictResolver.setLlmResolver(resolver);
+  }
+  /**
+   * Initialize the executor with tasks.
+   * Validates the DAG, builds parallel groups, and checks disk space.
+   *
+   * @param tasks - All tasks to execute in parallel
+   * @throws If the DAG has cycles or disk space is insufficient
+   */
+  async initialize(tasks) {
+    this.status = "analyzing";
+    this.dagAnalysis = analyzeTaskGraph(tasks);
+    if (this.dagAnalysis.cyclicTaskIds.length > 0) {
+      throw new Error(
+        `Cannot execute: dependency cycle detected involving tasks: ${this.dagAnalysis.cyclicTaskIds.join(", ")}`
+      );
+    }
+    if (this.dagAnalysis.groups.length === 0) {
+      throw new Error("No tasks to execute after DAG analysis");
+    }
+    await this.worktreeManager.checkDiskSpace();
+    this.status = "idle";
+  }
+  /**
+   * Execute all parallel groups.
+   * Main entry point for the parallel execution flow.
+   *
+   * @throws If initialize() has not been called or no task executor is set
+   */
+  async execute() {
+    if (!this.dagAnalysis) {
+      throw new Error("ParallelExecutor not initialized. Call initialize() first.");
+    }
+    if (!this.taskExecutor && !this.baseEngineConfig) {
+      throw new Error("No task executor or engine config set. Call setTaskExecutor() or provide baseEngineConfig.");
+    }
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.status = "executing";
+    this.totalTasksCompleted = 0;
+    this.totalTasksFailed = 0;
+    this.taskSummaries = [];
+    const totalTasks = this.dagAnalysis.groups.reduce(
+      (sum, g) => sum + g.tasks.length,
+      0
+    );
+    const backupTag = this.mergeEngine.createSessionBackup(this.sessionId);
+    let sessionState = createParallelSession(
+      this.sessionId,
+      this.dagAnalysis,
+      backupTag
+    );
+    saveParallelSession(this.config.cwd, sessionState);
+    try {
+      try {
+        const { warnings } = await enhanceParallelGroups(
+          this.dagAnalysis.groups,
+          this.config.cwd
+        );
+        for (const warning of warnings) {
+          this.emit({
+            type: "merge-failed",
+            taskId: warning.file,
+            error: `Coupling warning: ${warning.file} (instability: ${warning.instability.toFixed(2)}) is coupled with ${warning.coupledWith.join(", ")} in group ${warning.groupDepth}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      } catch {
+      }
+      const allTasks = /* @__PURE__ */ new Map();
+      for (const group of this.dagAnalysis.groups) {
+        for (const task of group.tasks) {
+          allTasks.set(task.id, task);
+        }
+      }
+      for (let i = 0; i < this.dagAnalysis.groups.length; i++) {
+        if (this.shouldStop) break;
+        this.currentGroupIndex = i;
+        const group = this.dagAnalysis.groups[i];
+        const { merged, failed } = await this.executeGroup(group, i);
+        for (const taskId of merged) {
+          const task = allTasks.get(taskId);
+          this.taskSummaries.push({
+            taskId,
+            title: task?.title ?? taskId,
+            success: true,
+            commitShas: this.getCommitShasForTask(taskId)
+          });
+        }
+        for (const taskId of failed) {
+          const task = allTasks.get(taskId);
+          this.taskSummaries.push({
+            taskId,
+            title: task?.title ?? taskId,
+            success: false,
+            error: "Task failed or merge conflict unresolved"
+          });
+        }
+        sessionState = updateSessionAfterGroup(
+          sessionState,
+          i,
+          merged,
+          failed
+        );
+        saveParallelSession(this.config.cwd, sessionState);
+      }
+      if (!this.shouldStop && this.config.enableValidation && this.baseEngineConfig && this.taskSummaries.some((t) => t.success)) {
+        await this.runValidationWorker();
+      }
+      this.status = this.shouldStop ? "interrupted" : "completed";
+      this.emit({
+        type: "all-completed",
+        totalCompleted: this.totalTasksCompleted,
+        totalFailed: this.totalTasksFailed,
+        durationMs: Date.now() - new Date(this.startedAt).getTime(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (err) {
+      this.status = "failed";
+      throw err;
+    } finally {
+      await this.cleanup();
+      if (this.status === "completed") {
+        deleteParallelSession(this.config.cwd);
+      }
+    }
+  }
+  /**
+   * Stop parallel execution gracefully.
+   */
+  stop() {
+    this.shouldStop = true;
+    this.status = "interrupted";
+  }
+  /**
+   * Get the current executor state for monitoring.
+   */
+  getState() {
+    return {
+      status: this.status,
+      dagAnalysis: this.dagAnalysis,
+      currentGroupIndex: this.currentGroupIndex,
+      totalGroups: this.dagAnalysis?.groups.length ?? 0,
+      workers: this.activeWorkers.map((w) => w.getState()),
+      allWorkers: [
+        ...this.allWorkerStates,
+        ...this.activeWorkers.map((w) => w.getState())
+      ],
+      mergeQueue: [...this.mergeEngine.getQueue()],
+      totalTasksCompleted: this.totalTasksCompleted,
+      totalTasks: this.dagAnalysis?.groups.reduce(
+        (sum, g) => sum + g.tasks.length,
+        0
+      ) ?? 0,
+      startedAt: this.startedAt,
+      elapsedMs: this.startedAt ? Date.now() - new Date(this.startedAt).getTime() : 0
+    };
+  }
+  /**
+   * Get the DAG analysis results.
+   */
+  getDAGAnalysis() {
+    return this.dagAnalysis;
+  }
+  /**
+   * Check if a previous session can be resumed.
+   */
+  canResume() {
+    return hasParallelSession(this.config.cwd);
+  }
+  /**
+   * Load a previous session for resume.
+   */
+  loadPreviousSession() {
+    const state = loadParallelSession(this.config.cwd);
+    if (!state) return null;
+    return { state };
+  }
+  // ─── Private Methods ───
+  /**
+   * Execute a single parallel group.
+   * Tasks within a group have no mutual dependencies and can run in parallel.
+   */
+  async executeGroup(group, groupIndex) {
+    const merged = [];
+    const failed = [];
+    const batches = this.batchTasks(group.tasks);
+    for (const batch of batches) {
+      if (this.shouldStop) break;
+      const results = await this.executeBatch(batch);
+      this.status = "merging";
+      for (const result of results) {
+        if (this.shouldStop) {
+          failed.push(result.task.id);
+          this.totalTasksFailed++;
+          continue;
+        }
+        if (result.success && result.commitCount > 0) {
+          const currentBranch = this.getCurrentBranch();
+          this.mergeEngine.enqueue(
+            result.branchName,
+            currentBranch,
+            result.task.id
+          );
+          const mergeResult = await this.mergeEngine.processNext();
+          if (mergeResult?.success) {
+            merged.push(result.task.id);
+            this.totalTasksCompleted++;
+          } else if (mergeResult?.conflictFiles && mergeResult.conflictFiles.length > 0) {
+            const resolved = await this.handleConflicts(
+              result,
+              mergeResult.conflictFiles
+            );
+            if (resolved) {
+              merged.push(result.task.id);
+              this.totalTasksCompleted++;
+            } else {
+              failed.push(result.task.id);
+              this.totalTasksFailed++;
+            }
+          } else {
+            failed.push(result.task.id);
+            this.totalTasksFailed++;
+          }
+        } else if (result.success && result.commitCount === 0) {
+          merged.push(result.task.id);
+          this.totalTasksCompleted++;
+        } else {
+          const taskId = result.task.id;
+          const count = this.requeueCounts.get(taskId) ?? 0;
+          if (count < this.config.maxRequeueCount) {
+            this.requeueCounts.set(taskId, count + 1);
+            const retryResult = await this.executeSingleTask(result.task);
+            if (retryResult.success) {
+              if (retryResult.commitCount > 0) {
+                const currentBranch = this.getCurrentBranch();
+                this.mergeEngine.enqueue(
+                  retryResult.branchName,
+                  currentBranch,
+                  taskId
+                );
+                const mergeResult = await this.mergeEngine.processNext();
+                if (mergeResult?.success) {
+                  merged.push(taskId);
+                  this.totalTasksCompleted++;
+                } else {
+                  failed.push(taskId);
+                  this.totalTasksFailed++;
+                }
+              } else {
+                merged.push(taskId);
+                this.totalTasksCompleted++;
+              }
+            } else {
+              failed.push(taskId);
+              this.totalTasksFailed++;
+            }
+          } else {
+            failed.push(taskId);
+            this.totalTasksFailed++;
+          }
+        }
+      }
+      if (!this.shouldStop) {
+        this.status = "executing";
+      }
+    }
+    this.emit({
+      type: "group-completed",
+      groupIndex,
+      tasksCompleted: merged.length,
+      tasksFailed: failed.length,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { merged, failed };
+  }
+  /**
+   * Create a TaskExecutor callback that wraps an ExecutionEngine for a given worktree.
+   * Used when baseEngineConfig is provided (engine-based mode).
+   */
+  createEngineExecutor(workerId) {
+    return async (task, worktreePath, _branchName) => {
+      const proxy = new WorkerTrackerProxy(task);
+      const engineConfig = {
+        ...DEFAULT_ENGINE_CONFIG_FOR_PARALLEL,
+        ...this.baseEngineConfig,
+        workingDir: worktreePath,
+        sourceProjectDir: this.config.cwd,
+        autoCommit: this.baseEngineConfig?.autoCommit ?? true,
+        // Wire parallel config's per-worker iteration limit to the engine
+        maxIterations: this.config.maxIterationsPerWorker
+      };
+      const engine = new ExecutionEngine(engineConfig);
+      engine.on((event) => {
+        const base = {
+          type: "worker-progress",
+          workerId,
+          taskId: task.id,
+          engineEventType: event.type,
+          timestamp: event.timestamp
+        };
+        if (event.type === "iteration:started") {
+          base.iteration = event.iteration;
+          base.message = "Iteration started";
+        } else if (event.type === "iteration:completed") {
+          const res = event.result;
+          base.iteration = res?.iteration;
+          base.message = res?.taskCompleted ? `Task completed (${Math.round((res?.durationMs ?? 0) / 1e3)}s)` : `Iteration done, no completion signal (${Math.round((res?.durationMs ?? 0) / 1e3)}s)`;
+        } else if (event.type === "iteration:failed") {
+          base.message = `Failed: ${event.error ?? "unknown"}`;
+        } else if (event.type === "task:completed") {
+          base.message = "Task completed";
+        } else if (event.type === "task:skipped") {
+          base.message = `Skipped: ${event.reason ?? "unknown"}`;
+        } else if (event.type === "engine:stopped") {
+          base.message = `Engine stopped: ${event.reason ?? "unknown"}`;
+        } else if (event.type === "agent:output") {
+          const ev = event;
+          base.stream = ev.stream;
+          base.data = ev.data;
+        }
+        this.emit(base);
+      });
+      await engine.initialize({ tracker: proxy, forcedTask: task });
+      await engine.start();
+      try {
+        const statusOutput = execFileSync5("git", ["status", "--porcelain"], {
+          cwd: worktreePath,
+          encoding: "utf-8",
+          timeout: 1e4
+        }).toString().trim();
+        if (statusOutput.length > 0) {
+          execFileSync5("git", ["add", "-A"], { cwd: worktreePath, timeout: 1e4 });
+          execFileSync5("git", ["commit", "-m", `feat: ${task.id} - ${task.title}`], {
+            cwd: worktreePath,
+            encoding: "utf-8",
+            timeout: 1e4
+          });
+        }
+      } catch {
+      }
+      let commitCount = 0;
+      try {
+        const sourceBranch = this.getCurrentBranch();
+        const countOutput = execFileSync5("git", ["rev-list", "--count", `${sourceBranch}..HEAD`], {
+          cwd: worktreePath,
+          encoding: "utf-8",
+          timeout: 1e4
+        }).toString().trim();
+        commitCount = parseInt(countOutput, 10) || 0;
+      } catch {
+        const state2 = engine.getState();
+        commitCount = state2.iterations.filter((it) => it.commitSha).length;
+      }
+      const state = engine.getState();
+      return {
+        success: proxy.wasTaskCompleted(),
+        commitCount,
+        error: state.failedTasks.length > 0 ? `Task failed after ${state.currentIteration} iterations` : void 0
+      };
+    };
+  }
+  /**
+   * Execute a batch of tasks in parallel using workers.
+   */
+  async executeBatch(tasks) {
+    this.activeWorkers = [];
+    const workerPromises = [];
+    for (let i = 0; i < tasks.length; i++) {
+      const task = tasks[i];
+      const workerId = `${this.currentGroupIndex}-${i}`;
+      try {
+        const worktreeInfo = await this.worktreeManager.create(workerId, task.id);
+        const worker = new ParallelWorker({
+          id: workerId,
+          task,
+          worktreePath: worktreeInfo.path,
+          branchName: worktreeInfo.branch,
+          cwd: this.config.cwd
+        });
+        worker.on((event) => this.emit(event));
+        this.activeWorkers.push(worker);
+        const executor = this.baseEngineConfig ? this.createEngineExecutor(workerId) : this.taskExecutor;
+        workerPromises.push(worker.start(executor));
+      } catch (err) {
+        workerPromises.push(
+          Promise.resolve({
+            workerId,
+            task,
+            success: false,
+            durationMs: 0,
+            error: err instanceof Error ? err.message : String(err),
+            branchName: "",
+            commitCount: 0,
+            worktreePath: ""
+          })
+        );
+      }
+    }
+    const settledResults = await Promise.allSettled(workerPromises);
+    const results = settledResults.map((result, i) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      return {
+        workerId: `${this.currentGroupIndex}-${i}`,
+        task: tasks[i],
+        success: false,
+        durationMs: 0,
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+        branchName: "",
+        commitCount: 0,
+        worktreePath: ""
+      };
+    });
+    for (const worker of this.activeWorkers) {
+      this.allWorkerStates.push(worker.getState());
+    }
+    for (const worker of this.activeWorkers) {
+      try {
+        await this.worktreeManager.remove(worker.id);
+      } catch {
+      }
+    }
+    this.activeWorkers = [];
+    return results;
+  }
+  /**
+   * Execute a single task (for retries).
+   */
+  async executeSingleTask(task) {
+    const workerId = `retry-${task.id}-${Date.now()}`;
+    try {
+      const worktreeInfo = await this.worktreeManager.create(workerId, task.id);
+      const worker = new ParallelWorker({
+        id: workerId,
+        task,
+        worktreePath: worktreeInfo.path,
+        branchName: worktreeInfo.branch,
+        cwd: this.config.cwd
+      });
+      worker.on((event) => this.emit(event));
+      const executor = this.baseEngineConfig ? this.createEngineExecutor(workerId) : this.taskExecutor;
+      const result = await worker.start(executor);
+      await this.worktreeManager.remove(workerId);
+      return result;
+    } catch (err) {
+      return {
+        workerId,
+        task,
+        success: false,
+        durationMs: 0,
+        error: err instanceof Error ? err.message : String(err),
+        branchName: "",
+        commitCount: 0,
+        worktreePath: ""
+      };
+    }
+  }
+  /**
+   * Handle merge conflicts for a worker result.
+   * Attempts AI conflict resolution if configured.
+   *
+   * @returns true if conflicts were resolved, false otherwise
+   */
+  async handleConflicts(workerResult, conflictFiles) {
+    if (!this.config.aiConflictResolution) {
+      return false;
+    }
+    try {
+      try {
+        execFileSyncSafe("git", [
+          "-C",
+          this.config.cwd,
+          "merge",
+          "--no-commit",
+          workerResult.branchName
+        ]);
+      } catch {
+      }
+      const results = await this.conflictResolver.resolveAll(conflictFiles, {
+        taskId: workerResult.task.id,
+        taskTitle: workerResult.task.title
+      });
+      const allResolved = results.every((r) => r.resolved);
+      if (allResolved) {
+        try {
+          execFileSyncSafe("git", [
+            "-C",
+            this.config.cwd,
+            "commit",
+            "--no-edit",
+            "-m",
+            `feat(parallel): merge task ${workerResult.task.id} (conflicts resolved)`
+          ]);
+          return true;
+        } catch {
+        }
+      }
+      try {
+        execFileSyncSafe("git", ["-C", this.config.cwd, "merge", "--abort"]);
+      } catch {
+      }
+      return false;
+    } catch {
+      try {
+        execFileSyncSafe("git", ["-C", this.config.cwd, "merge", "--abort"]);
+      } catch {
+      }
+      return false;
+    }
+  }
+  /**
+   * Run a validation worker after all parallel groups complete.
+   * The validation worker operates in the main working directory (all merges are done)
+   * and validates + fixes the integrated work against the original PRD.
+   */
+  async runValidationWorker() {
+    const mergedCount = this.taskSummaries.filter((t) => t.success).length;
+    const failedCount = this.taskSummaries.filter((t) => !t.success).length;
+    this.emit({
+      type: "validation-started",
+      totalMerged: mergedCount,
+      totalFailed: failedCount,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const validationStart = Date.now();
+    try {
+      let prdMarkdown = this.config.prdMarkdown ?? "";
+      if (!prdMarkdown) {
+        try {
+          const fs4 = await import("fs");
+          const path4 = await import("path");
+          const prdDir = path4.join(this.config.cwd, ".ulpi", "prds");
+          const files = fs4.readdirSync(prdDir).filter((f) => f.endsWith(".md"));
+          if (files.length > 0) {
+            const sorted = files.map((f) => ({
+              name: f,
+              mtime: fs4.statSync(path4.join(prdDir, f)).mtimeMs
+            })).sort((a, b) => b.mtime - a.mtime);
+            prdMarkdown = fs4.readFileSync(path4.join(prdDir, sorted[0].name), "utf-8");
+          }
+        } catch {
+        }
+      }
+      let validationPrompt;
+      try {
+        const prdEngine = await import("@ulpi/prd-engine");
+        validationPrompt = prdEngine.buildPrdValidationPrompt(prdMarkdown, this.taskSummaries);
+      } catch {
+        validationPrompt = buildFallbackValidationPrompt(prdMarkdown, this.taskSummaries);
+      }
+      const validationTask = {
+        id: "VALIDATION",
+        title: "Post-Parallel Validation & Integration Fix",
+        status: "open",
+        priority: 0,
+        // Critical
+        description: validationPrompt,
+        labels: ["validation", "integration"],
+        type: "validation"
+      };
+      const proxy = new WorkerTrackerProxy(validationTask);
+      const engineConfig = {
+        ...DEFAULT_ENGINE_CONFIG_FOR_PARALLEL,
+        ...this.baseEngineConfig,
+        workingDir: this.config.cwd,
+        sourceProjectDir: this.config.cwd,
+        autoCommit: true,
+        maxIterations: this.config.validationMaxIterations,
+        // Override agent for verification if configured
+        ...this.config.verificationAgentName ? { agentName: this.config.verificationAgentName } : {},
+        ...this.config.verificationAgentConfig ? { agentConfig: this.config.verificationAgentConfig } : {}
+      };
+      const engine = new ExecutionEngine(engineConfig);
+      engine.on((event) => {
+        this.emit({
+          type: "worker-progress",
+          workerId: "validation",
+          taskId: "VALIDATION",
+          engineEventType: event.type,
+          timestamp: event.timestamp,
+          message: event.type === "iteration:completed" ? "Validation iteration completed" : event.type === "task:completed" ? "Validation completed" : void 0
+        });
+      });
+      await engine.initialize({ tracker: proxy, forcedTask: validationTask });
+      await engine.start();
+      let commitCount = 0;
+      try {
+        const statusOutput = execFileSync5("git", ["status", "--porcelain"], {
+          cwd: this.config.cwd,
+          encoding: "utf-8",
+          timeout: 1e4
+        }).toString().trim();
+        if (statusOutput.length > 0) {
+          execFileSync5("git", ["add", "-A"], { cwd: this.config.cwd, timeout: 1e4 });
+          execFileSync5("git", ["commit", "-m", "fix: post-parallel validation fixes"], {
+            cwd: this.config.cwd,
+            encoding: "utf-8",
+            timeout: 1e4
+          });
+          commitCount++;
+        }
+      } catch {
+      }
+      const state = engine.getState();
+      commitCount += state.iterations.filter((it) => it.commitSha).length;
+      this.emit({
+        type: "validation-completed",
+        success: proxy.wasTaskCompleted(),
+        commitCount,
+        durationMs: Date.now() - validationStart,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (err) {
+      this.emit({
+        type: "validation-completed",
+        success: false,
+        commitCount: 0,
+        durationMs: Date.now() - validationStart,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  /**
+   * Get commit SHAs for a merged task from the allWorkerStates.
+   */
+  getCommitShasForTask(taskId) {
+    const workerState = this.allWorkerStates.find(
+      (w) => w.task.id === taskId && w.status === "completed"
+    );
+    if (!workerState?.branchName) return [];
+    try {
+      const currentBranch = this.getCurrentBranch();
+      const output = execFileSyncSafe("git", [
+        "-C",
+        this.config.cwd,
+        "log",
+        "--oneline",
+        "--grep",
+        `merge task ${taskId}`,
+        "-n",
+        "1",
+        "--format=%H"
+      ]).trim();
+      return output ? [output] : [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get the current branch name.
+   */
+  getCurrentBranch() {
+    try {
+      return execFileSyncSafe("git", [
+        "-C",
+        this.config.cwd,
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD"
+      ]).trim();
+    } catch {
+      return "HEAD";
+    }
+  }
+  /**
+   * Split tasks into batches of maxWorkers size.
+   */
+  batchTasks(tasks) {
+    const batches = [];
+    for (let i = 0; i < tasks.length; i += this.config.maxWorkers) {
+      batches.push(tasks.slice(i, i + this.config.maxWorkers));
+    }
+    return batches;
+  }
+  /**
+   * Clean up all resources.
+   */
+  async cleanup() {
+    try {
+      await this.worktreeManager.cleanup();
+    } catch {
+    }
+    try {
+      this.mergeEngine.cleanupTags();
+    } catch {
+    }
+  }
+  /**
+   * Emit a parallel event to all listeners.
+   */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+};
+function execFileSyncSafe(command, args) {
+  return execFileSync5(command, args, {
+    encoding: "utf-8",
+    timeout: 3e4,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+function buildFallbackValidationPrompt(prdMarkdown, _taskSummaries) {
+  const parts = [];
+  parts.push("## Your Role\n");
+  parts.push("You are a senior engineer performing post-implementation validation.");
+  parts.push("Multiple agents worked on tasks in parallel. Their work has been merged into this branch.");
+  parts.push("You do NOT care about what the agents did or didn't do. You only care about the current state of the code.\n");
+  parts.push("## Instructions\n");
+  parts.push("### Step 1: Run the build\n");
+  parts.push("Run the project's build command first. Note any errors.\n");
+  parts.push("### Step 2: Validate task by task\n");
+  parts.push("Go through each task in the PRD below, one by one.");
+  parts.push("For each task: read the files, check if the code exists and is correct.");
+  parts.push("If it's there and correct \u2014 move on. If missing or broken \u2014 implement or fix it.\n");
+  parts.push("### Step 3: Fix build errors\n");
+  parts.push("Run the build again. Fix errors. Repeat until clean.\n");
+  if (prdMarkdown) {
+    parts.push("## PRD\n");
+    parts.push(prdMarkdown);
+  }
+  return parts.join("\n");
+}
+export {
+  ConflictResolver,
+  DEFAULT_PARALLEL_CONFIG,
+  MergeEngine,
+  ParallelExecutor,
+  ParallelWorker,
+  WorkerTrackerProxy,
+  WorktreeManager,
+  analyzeTaskGraph,
+  buildConflictPrompt,
+  buildParallelGroups,
+  cleanupOrphanedSession,
+  createParallelSession,
+  deleteParallelSession,
+  enhanceParallelGroups,
+  findOrphanedWorktrees,
+  getConflictContext,
+  hasParallelSession,
+  isOrphanedSession,
+  loadParallelSession,
+  saveParallelSession,
+  topologicalSortTasks,
+  updateSessionAfterGroup,
+  validateDAG
+};