@locusai/sdk 0.10.6 → 0.11.0

package/dist/index-node.js

@@ -574,9 +574,6 @@ var init_config = __esm(() => {
     "# Locus AI - Plans (generated per task)",
     ".locus/plans/",
     "",
-    "# Locus AI - Agent worktrees (parallel execution)",
-    ".locus-worktrees/",
-    "",
     "# Locus AI - Settings (contains API key, telegram config, etc.)",
     ".locus/settings.json",
     "",
@@ -1753,583 +1750,247 @@ var init_knowledge_base = __esm(() => {
   import_node_path5 = require("node:path");
 });
 
-// src/git/pr-service.ts
-class PrService {
-  projectPath;
+// src/agent/git-workflow.ts
+class GitWorkflow {
+  config;
   log;
-  constructor(projectPath, log) {
-    this.projectPath = projectPath;
+  projectPath;
+  branchName = null;
+  baseBranch = null;
+  ghUsername;
+  constructor(config, log) {
+    this.config = config;
     this.log = log;
-  }
-  createPr(options) {
-    const {
-      task,
-      branch,
-      baseBranch: requestedBaseBranch,
-      agentId,
-      summary
-    } = options;
-    const provider = detectRemoteProvider(this.projectPath);
-    if (provider !== "github") {
-      throw new Error(`PR creation is only supported for GitHub repositories (detected: ${provider})`);
-    }
-    if (!isGhAvailable(this.projectPath)) {
-      throw new Error("GitHub CLI (gh) is not installed or not authenticated. Install from https://cli.github.com/");
-    }
-    const title = `[Locus] ${task.title}`;
-    const body = this.buildPrBody(task, agentId, summary);
-    const baseBranch = requestedBaseBranch ?? getDefaultBranch(this.projectPath);
-    this.validateCreatePrInputs(baseBranch, branch);
-    this.log(`Creating PR: ${title} (${branch} → ${baseBranch})`, "info");
-    const output = import_node_child_process4.execFileSync("gh", [
-      "pr",
-      "create",
-      "--title",
-      title,
-      "--body",
-      body,
-      "--base",
-      baseBranch,
-      "--head",
-      branch
-    ], {
-      cwd: this.projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const url = output;
-    const prNumber = this.extractPrNumber(url);
-    this.log(`PR created: ${url}`, "success");
-    return { url, number: prNumber };
-  }
-  validateCreatePrInputs(baseBranch, headBranch) {
-    if (!this.hasRemoteBranch(baseBranch)) {
-      throw new Error(`Base branch "${baseBranch}" does not exist on origin. Push/fetch refs and retry.`);
-    }
-    if (!this.hasRemoteBranch(headBranch)) {
-      throw new Error(`Head branch "${headBranch}" is not available on origin. Ensure it is pushed before PR creation.`);
-    }
-    const baseRef = this.resolveBranchRef(baseBranch);
-    const headRef = this.resolveBranchRef(headBranch);
-    if (!baseRef) {
-      throw new Error(`Could not resolve base branch "${baseBranch}" locally.`);
+    this.projectPath = config.projectPath || process.cwd();
+    this.ghUsername = getGhUsername();
+    if (this.ghUsername) {
+      this.log(`GitHub user: ${this.ghUsername}`, "info");
     }
-    if (!headRef) {
-      throw new Error(`Could not resolve head branch "${headBranch}" locally.`);
-    }
-    const commitsAhead = this.countCommitsAhead(baseRef, headRef);
-    if (commitsAhead <= 0) {
-      throw new Error(`No commits between "${baseBranch}" and "${headBranch}". Skipping PR creation.`);
-    }
-  }
-  countCommitsAhead(baseRef, headRef) {
-    const output = import_node_child_process4.execFileSync("git", ["rev-list", "--count", `${baseRef}..${headRef}`], {
-      cwd: this.projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const value = Number.parseInt(output || "0", 10);
-    return Number.isNaN(value) ? 0 : value;
-  }
-  resolveBranchRef(branch) {
-    if (this.hasLocalBranch(branch)) {
-      return branch;
-    }
-    if (this.hasRemoteTrackingBranch(branch)) {
-      return `origin/${branch}`;
-    }
-    return null;
   }
-  hasLocalBranch(branch) {
+  createBranch(sprintId) {
+    const defaultBranch = getDefaultBranch(this.projectPath);
+    this.baseBranch = defaultBranch;
     try {
-      import_node_child_process4.execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
-        cwd: this.projectPath,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      return true;
+      this.gitExec(["checkout", defaultBranch]);
+      this.gitExec(["pull", "origin", defaultBranch]);
     } catch {
-      return false;
+      this.log(`Could not pull latest from ${defaultBranch}, continuing with current state`, "warn");
     }
+    const suffix = sprintId ? sprintId.slice(0, 8) : Date.now().toString(36);
+    this.branchName = `locus/${suffix}`;
+    try {
+      this.gitExec(["branch", "-D", this.branchName]);
+    } catch {}
+    this.gitExec(["checkout", "-b", this.branchName]);
+    this.log(`Created branch: ${this.branchName} (from ${defaultBranch})`, "success");
+    return this.branchName;
   }
-  hasRemoteTrackingBranch(branch) {
+  commitAndPush(task) {
+    if (!this.branchName) {
+      this.log("No branch created yet, skipping commit", "warn");
+      return { branch: null, pushed: false, pushFailed: false };
+    }
     try {
-      import_node_child_process4.execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${branch}`], {
-        cwd: this.projectPath,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      return true;
-    } catch {
-      return false;
+      const status = this.gitExec(["status", "--porcelain"]).trim();
+      if (!status) {
+        const baseBranchCommit = this.getBaseCommit();
+        const headCommit = this.gitExec(["rev-parse", "HEAD"]).trim();
+        if (baseBranchCommit && headCommit !== baseBranchCommit) {
+          return this.pushBranch();
+        }
+        this.log("No changes to commit for this task", "info");
+        return {
+          branch: this.branchName,
+          pushed: false,
+          pushFailed: false,
+          noChanges: true,
+          skipReason: "No changes were made for this task."
+        };
+      }
+      this.gitExec(["add", "-A"]);
+      const staged = this.gitExec(["diff", "--cached", "--name-only"]).trim();
+      if (!staged) {
+        this.log("All changes were ignored by .gitignore — nothing to commit", "warn");
+        return {
+          branch: this.branchName,
+          pushed: false,
+          pushFailed: false,
+          noChanges: true,
+          skipReason: "All changes were ignored by .gitignore."
+        };
+      }
+      this.log(`Staging ${staged.split(`
+`).length} file(s) for commit`, "info");
+      const trailers = [
+        `Task-ID: ${task.id}`,
+        `Agent: ${this.config.agentId}`,
+        "Co-authored-by: LocusAI <agent@locusai.team>"
+      ];
+      if (this.ghUsername) {
+        trailers.push(`Co-authored-by: ${this.ghUsername} <${this.ghUsername}@users.noreply.github.com>`);
+      }
+      const commitMessage = `feat(agent): ${task.title}
+
+${trailers.join(`
+`)}`;
+      this.gitExec(["commit", "-m", commitMessage]);
+      const hash = this.gitExec(["rev-parse", "HEAD"]).trim();
+      this.log(`Committed: ${hash.slice(0, 8)}`, "success");
+      return this.pushBranch();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.log(`Git commit failed: ${errorMessage}`, "error");
+      return {
+        branch: this.branchName,
+        pushed: false,
+        pushFailed: true,
+        pushError: `Git commit/push failed: ${errorMessage}`
+      };
     }
   }
-  hasRemoteBranch(branch) {
+  pushBranch() {
+    if (!this.branchName) {
+      return { branch: null, pushed: false, pushFailed: false };
+    }
     try {
-      import_node_child_process4.execFileSync("git", ["ls-remote", "--exit-code", "--heads", "origin", branch], {
-        cwd: this.projectPath,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      return true;
-    } catch {
-      return false;
+      this.gitExec(["push", "-u", "origin", this.branchName]);
+      this.log(`Pushed ${this.branchName} to origin`, "success");
+      return { branch: this.branchName, pushed: true, pushFailed: false };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (msg.includes("non-fast-forward") || msg.includes("[rejected]") || msg.includes("fetch first")) {
+        this.log(`Push rejected (non-fast-forward). Retrying with --force-with-lease.`, "warn");
+        try {
+          this.gitExec([
+            "push",
+            "--force-with-lease",
+            "-u",
+            "origin",
+            this.branchName
+          ]);
+          this.log(`Pushed ${this.branchName} to origin with --force-with-lease`, "success");
+          return { branch: this.branchName, pushed: true, pushFailed: false };
+        } catch (retryErr) {
+          const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+          this.log(`Git push retry failed: ${retryMsg}`, "error");
+          return {
+            branch: this.branchName,
+            pushed: false,
+            pushFailed: true,
+            pushError: retryMsg
+          };
+        }
+      }
+      this.log(`Git push failed: ${msg}`, "error");
+      return {
+        branch: this.branchName,
+        pushed: false,
+        pushFailed: true,
+        pushError: msg
+      };
     }
   }
-  getPrDiff(branch) {
-    return import_node_child_process4.execFileSync("gh", ["pr", "diff", branch], {
-      cwd: this.projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      maxBuffer: 10 * 1024 * 1024
-    });
-  }
-  submitReview(prIdentifier, body, event) {
+  createPullRequest(completedTasks, summaries) {
+    if (!this.branchName || !this.baseBranch) {
+      return { url: null, error: "No branch or base branch available." };
+    }
+    const provider = detectRemoteProvider(this.projectPath);
+    if (provider !== "github") {
+      return {
+        url: null,
+        error: `PR creation is only supported for GitHub repositories (detected: ${provider})`
+      };
+    }
+    if (!isGhAvailable(this.projectPath)) {
+      return {
+        url: null,
+        error: "GitHub CLI (gh) is not installed or not authenticated. Install from https://cli.github.com/"
+      };
+    }
+    const title = `[Locus] Sprint tasks (${completedTasks.length} task${completedTasks.length !== 1 ? "s" : ""})`;
+    const body = this.buildPrBody(completedTasks, summaries);
+    this.log(`Creating PR: ${title} (${this.branchName} → ${this.baseBranch})`, "info");
     try {
-      import_node_child_process4.execFileSync("gh", [
+      const output = import_node_child_process4.execFileSync("gh", [
         "pr",
-        "review",
-        prIdentifier,
+        "create",
+        "--title",
+        title,
         "--body",
         body,
-        `--${event.toLowerCase().replace("_", "-")}`
+        "--base",
+        this.baseBranch,
+        "--head",
+        this.branchName
       ], {
         cwd: this.projectPath,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
-      });
+      }).trim();
+      this.log(`PR created: ${output}`, "success");
+      return { url: output };
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (event === "REQUEST_CHANGES" && msg.includes("own pull request")) {
-        import_node_child_process4.execFileSync("gh", ["pr", "review", prIdentifier, "--body", body, "--comment"], {
-          cwd: this.projectPath,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        return;
-      }
-      throw err;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.log(`PR creation failed: ${errorMessage}`, "error");
+      return { url: null, error: errorMessage };
     }
   }
-  listLocusPrs() {
+  checkoutBaseBranch() {
+    if (!this.baseBranch)
+      return;
     try {
-      const output = import_node_child_process4.execFileSync("gh", [
-        "pr",
-        "list",
-        "--search",
-        "[Locus] in:title",
-        "--state",
-        "open",
-        "--json",
-        "number,title,url,headRefName"
-      ], {
-        cwd: this.projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      const prs = JSON.parse(output || "[]");
-      return prs.map((pr) => ({
-        number: pr.number,
-        title: pr.title,
-        url: pr.url,
-        branch: pr.headRefName
-      }));
-    } catch {
-      this.log("Failed to list Locus PRs", "warn");
-      return [];
+      this.gitExec(["checkout", this.baseBranch]);
+      this.log(`Checked out base branch: ${this.baseBranch}`, "info");
+    } catch (err) {
+      this.log(`Could not checkout base branch: ${err instanceof Error ? err.message : String(err)}`, "warn");
     }
   }
-  hasLocusReview(prNumber) {
+  getBranchName() {
+    return this.branchName;
+  }
+  getBaseBranch() {
+    return this.baseBranch;
+  }
+  getBaseCommit() {
+    if (!this.baseBranch)
+      return null;
     try {
-      const output = import_node_child_process4.execFileSync("gh", ["pr", "view", prNumber, "--json", "reviews"], {
-        cwd: this.projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      const data = JSON.parse(output || "{}");
-      return data.reviews?.some((r) => r.body?.includes("## Locus Agent Review")) ?? false;
+      return this.gitExec(["rev-parse", this.baseBranch]).trim();
     } catch {
-      return false;
+      return null;
     }
   }
-  listUnreviewedLocusPrs() {
-    const allPrs = this.listLocusPrs();
-    return allPrs.filter((pr) => !this.hasLocusReview(String(pr.number)));
-  }
-  buildPrBody(task, agentId, summary) {
+  buildPrBody(completedTasks, summaries) {
     const sections = [];
-    sections.push(`## Task: ${task.title}`);
+    sections.push("## Completed Tasks");
     sections.push("");
-    if (task.description) {
-      sections.push(task.description);
-      sections.push("");
-    }
-    if (task.acceptanceChecklist?.length > 0) {
-      sections.push("## Acceptance Criteria");
-      for (const item of task.acceptanceChecklist) {
-        sections.push(`- [ ] ${item.text}`);
+    for (let i = 0;i < completedTasks.length; i++) {
+      const task = completedTasks[i];
+      sections.push(`### ${i + 1}. ${task.title}`);
+      sections.push(`Task ID: \`${task.id}\``);
+      if (summaries[i]) {
+        sections.push("");
+        sections.push(summaries[i]);
       }
       sections.push("");
     }
-    if (summary) {
-      sections.push("## Agent Summary");
-      sections.push(summary);
-      sections.push("");
-    }
     sections.push("---");
-    sections.push(`*Created by Locus Agent \`${agentId.slice(-8)}\`* | Task ID: \`${task.id}\``);
+    sections.push(`*Created by Locus Agent \`${this.config.agentId.slice(-8)}\`*`);
     return sections.join(`
 `);
   }
-  extractPrNumber(url) {
-    const match = url.match(/\/pull\/(\d+)/);
-    return match ? Number.parseInt(match[1], 10) : 0;
-  }
-}
-var import_node_child_process4;
-var init_pr_service = __esm(() => {
-  init_git_utils();
-  import_node_child_process4 = require("node:child_process");
-});
-
-// src/worktree/worktree-config.ts
-var WORKTREE_ROOT_DIR = ".locus-worktrees", WORKTREE_BRANCH_PREFIX = "agent", DEFAULT_WORKTREE_CONFIG;
-var init_worktree_config = __esm(() => {
-  DEFAULT_WORKTREE_CONFIG = {
-    rootDir: WORKTREE_ROOT_DIR,
-    branchPrefix: WORKTREE_BRANCH_PREFIX,
-    cleanupPolicy: "retain-on-failure"
-  };
-});
-
-// src/worktree/worktree-manager.ts
-class WorktreeManager {
-  config;
-  projectPath;
-  log;
-  constructor(projectPath, config, log) {
-    this.projectPath = import_node_path6.resolve(projectPath);
-    this.config = { ...DEFAULT_WORKTREE_CONFIG, ...config };
-    this.log = log ?? ((_msg) => {
-      return;
-    });
-  }
-  get rootPath() {
-    return import_node_path6.join(this.projectPath, this.config.rootDir);
-  }
-  buildBranchName(taskId, taskSlug) {
-    const sanitized = taskSlug.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
-    return `${this.config.branchPrefix}/${taskId}-${sanitized}`;
-  }
-  create(options) {
-    const branch = this.buildBranchName(options.taskId, options.taskSlug);
-    const worktreeDir = `${options.agentId}-${options.taskId}`;
-    const worktreePath = import_node_path6.join(this.rootPath, worktreeDir);
-    this.ensureDirectory(this.rootPath, "Worktree root");
-    const baseBranch = options.baseBranch ?? this.config.baseBranch ?? this.getCurrentBranch();
-    if (!this.branchExists(baseBranch)) {
-      this.log(`Base branch "${baseBranch}" not found locally, fetching from origin`, "info");
-      try {
-        this.gitExec(["fetch", "origin", baseBranch], this.projectPath);
-        this.gitExec(["branch", baseBranch, `origin/${baseBranch}`], this.projectPath);
-      } catch {
-        this.log(`Could not fetch/create local branch for "${baseBranch}", falling back to current branch`, "warn");
-      }
-    }
-    this.log(`Creating worktree: ${worktreeDir} (branch: ${branch}, base: ${baseBranch})`, "info");
-    if (import_node_fs4.existsSync(worktreePath)) {
-      this.log(`Removing stale worktree directory: ${worktreePath}`, "warn");
-      try {
-        this.git(`worktree remove "${worktreePath}" --force`, this.projectPath);
-      } catch {
-        import_node_fs4.rmSync(worktreePath, { recursive: true, force: true });
-        this.git("worktree prune", this.projectPath);
-      }
-    }
-    if (this.branchExists(branch)) {
-      this.log(`Deleting existing branch: ${branch}`, "warn");
-      const branchWorktrees = this.list().filter((wt) => wt.branch === branch);
-      for (const wt of branchWorktrees) {
-        const worktreePath2 = import_node_path6.resolve(wt.path);
-        if (wt.isMain || !this.isManagedWorktreePath(worktreePath2)) {
-          throw new Error(`Branch "${branch}" is checked out at "${worktreePath2}". Remove or detach that worktree before retrying.`);
-        }
-        this.log(`Removing existing worktree for branch: ${branch} (${worktreePath2})`, "warn");
-        this.remove(worktreePath2, false);
-      }
-      try {
-        this.git(`branch -D "${branch}"`, this.projectPath);
-      } catch {
-        this.git("worktree prune", this.projectPath);
-        this.git(`branch -D "${branch}"`, this.projectPath);
-      }
-    }
-    const addWorktree = () => this.git(`worktree add "${worktreePath}" -b "${branch}" "${baseBranch}"`, this.projectPath);
-    try {
-      addWorktree();
-    } catch (error) {
-      if (!this.isMissingDirectoryError(error)) {
-        throw error;
-      }
-      this.log(`Worktree creation failed due to missing directories. Retrying after cleanup: ${worktreePath}`, "warn");
-      this.cleanupFailedWorktree(worktreePath, branch);
-      this.ensureDirectory(this.rootPath, "Worktree root");
-      addWorktree();
-    }
-    const baseCommitHash = this.git("rev-parse HEAD", worktreePath).trim();
-    this.log(`Worktree created at ${worktreePath} (base: ${baseCommitHash.slice(0, 8)})`, "success");
-    return { worktreePath, branch, baseBranch, baseCommitHash };
-  }
-  list() {
-    const output = this.git("worktree list --porcelain", this.projectPath);
-    const worktrees = [];
-    const blocks = output.trim().split(`
-
-`);
-    for (const block of blocks) {
-      if (!block.trim())
-        continue;
-      const lines = block.trim().split(`
-`);
-      let path = "";
-      let head = "";
-      let branch = "";
-      let isMain = false;
-      let isPrunable = false;
-      for (const line of lines) {
-        if (line.startsWith("worktree ")) {
-          path = line.slice("worktree ".length);
-        } else if (line.startsWith("HEAD ")) {
-          head = line.slice("HEAD ".length);
-        } else if (line.startsWith("branch ")) {
-          branch = line.slice("branch ".length).replace("refs/heads/", "");
-        } else if (line === "bare" || path === this.projectPath) {
-          isMain = true;
-        } else if (line === "prunable") {
-          isPrunable = true;
-        } else if (line === "detached") {
-          branch = "(detached)";
-        }
-      }
-      if (import_node_path6.resolve(path) === this.projectPath) {
-        isMain = true;
-      }
-      if (path) {
-        worktrees.push({ path, branch, head, isMain, isPrunable });
-      }
-    }
-    return worktrees;
-  }
-  listAgentWorktrees() {
-    return this.list().filter((wt) => !wt.isMain);
-  }
-  remove(worktreePath, deleteBranch = true) {
-    const absolutePath = import_node_path6.resolve(worktreePath);
-    const worktrees = this.list();
-    const worktree = worktrees.find((wt) => import_node_path6.resolve(wt.path) === absolutePath);
-    const branchToDelete = worktree?.branch;
-    this.log(`Removing worktree: ${absolutePath}`, "info");
-    try {
-      this.git(`worktree remove "${absolutePath}" --force`, this.projectPath);
-    } catch {
-      if (import_node_fs4.existsSync(absolutePath)) {
-        import_node_fs4.rmSync(absolutePath, { recursive: true, force: true });
-      }
-      this.git("worktree prune", this.projectPath);
-    }
-    if (deleteBranch && branchToDelete && !branchToDelete.startsWith("(")) {
-      try {
-        this.git(`branch -D "${branchToDelete}"`, this.projectPath);
-        this.log(`Deleted branch: ${branchToDelete}`, "success");
-      } catch {
-        this.log(`Could not delete branch: ${branchToDelete} (may already be deleted)`, "warn");
-      }
-    }
-    this.log("Worktree removed", "success");
-  }
-  prune() {
-    const before = this.listAgentWorktrees().filter((wt) => wt.isPrunable).length;
-    this.git("worktree prune", this.projectPath);
-    const after = this.listAgentWorktrees().filter((wt) => wt.isPrunable).length;
-    const pruned = before - after;
-    if (pruned > 0) {
-      this.log(`Pruned ${pruned} stale worktree(s)`, "success");
-    }
-    return pruned;
-  }
-  removeAll() {
-    const agentWorktrees = this.listAgentWorktrees();
-    let removed = 0;
-    for (const wt of agentWorktrees) {
-      try {
-        this.remove(wt.path, true);
-        removed++;
-      } catch {
-        this.log(`Failed to remove worktree: ${wt.path}`, "warn");
-      }
-    }
-    if (import_node_fs4.existsSync(this.rootPath)) {
-      try {
-        import_node_fs4.rmSync(this.rootPath, { recursive: true, force: true });
-      } catch {}
-    }
-    return removed;
-  }
-  hasChanges(worktreePath) {
-    const status = this.git("status --porcelain", worktreePath).trim();
-    return status.length > 0;
-  }
-  hasCommitsAhead(worktreePath, baseBranch) {
-    try {
-      const count = this.git(`rev-list --count "${baseBranch}..HEAD"`, worktreePath).trim();
-      return Number.parseInt(count, 10) > 0;
-    } catch (err) {
-      this.log(`Could not compare HEAD against base branch "${baseBranch}": ${err instanceof Error ? err.message : String(err)}`, "warn");
-      return false;
-    }
-  }
-  hasCommitsAheadOfHash(worktreePath, baseHash) {
-    try {
-      const headHash = this.git("rev-parse HEAD", worktreePath).trim();
-      return headHash !== baseHash;
-    } catch {
-      return false;
-    }
-  }
-  commitChanges(worktreePath, message, baseBranch, baseCommitHash) {
-    const hasUncommittedChanges = this.hasChanges(worktreePath);
-    if (hasUncommittedChanges) {
-      const statusOutput = this.git("status --porcelain", worktreePath).trim();
-      this.log(`Detected uncommitted changes:
-${statusOutput.split(`
-`).slice(0, 10).join(`
-`)}${statusOutput.split(`
-`).length > 10 ? `
-... and ${statusOutput.split(`
-`).length - 10} more` : ""}`, "info");
-    }
-    if (!hasUncommittedChanges) {
-      if (baseBranch && this.hasCommitsAhead(worktreePath, baseBranch)) {
-        const hash2 = this.git("rev-parse HEAD", worktreePath).trim();
-        this.log(`Agent already committed changes (${hash2.slice(0, 8)}); skipping additional commit`, "info");
-        return hash2;
-      }
-      if (baseCommitHash && this.hasCommitsAheadOfHash(worktreePath, baseCommitHash)) {
-        const hash2 = this.git("rev-parse HEAD", worktreePath).trim();
-        this.log(`Agent already committed changes (${hash2.slice(0, 8)}, detected via base commit hash); skipping additional commit`, "info");
-        return hash2;
-      }
-      const branch = this.getBranch(worktreePath);
-      this.log(`No changes detected in worktree (branch: ${branch}, baseBranch: ${baseBranch ?? "none"}, baseCommitHash: ${baseCommitHash?.slice(0, 8) ?? "none"})`, "warn");
-      return null;
-    }
-    this.git("add -A", worktreePath);
-    const staged = this.git("diff --cached --name-only", worktreePath).trim();
-    if (!staged) {
-      this.log("All changes were ignored by .gitignore — nothing to commit", "warn");
-      return null;
-    }
-    this.log(`Staging ${staged.split(`
-`).length} file(s) for commit`, "info");
-    this.gitExec(["commit", "-m", message], worktreePath);
-    const hash = this.git("rev-parse HEAD", worktreePath).trim();
-    this.log(`Committed: ${hash.slice(0, 8)}`, "success");
-    return hash;
-  }
-  pushBranch(worktreePath, remote = "origin") {
-    const branch = this.getBranch(worktreePath);
-    this.log(`Pushing branch ${branch} to ${remote}`, "info");
-    try {
-      this.gitExec(["push", "-u", remote, branch], worktreePath);
-      this.log(`Pushed ${branch} to ${remote}`, "success");
-      return branch;
-    } catch (error) {
-      if (!this.isNonFastForwardPushError(error)) {
-        throw error;
-      }
-      this.log(`Push rejected for ${branch} (non-fast-forward). Retrying with --force-with-lease.`, "warn");
-      try {
-        this.gitExec(["fetch", remote, branch], worktreePath);
-      } catch {}
-      this.gitExec(["push", "--force-with-lease", "-u", remote, branch], worktreePath);
-      this.log(`Pushed ${branch} to ${remote} with --force-with-lease`, "success");
-      return branch;
-    }
-  }
-  getBranch(worktreePath) {
-    return this.git("rev-parse --abbrev-ref HEAD", worktreePath).trim();
-  }
-  hasWorktreeForTask(taskId) {
-    return this.listAgentWorktrees().some((wt) => wt.branch.includes(taskId) || wt.path.includes(taskId));
-  }
-  branchExists(branchName) {
-    try {
-      this.git(`rev-parse --verify "refs/heads/${branchName}"`, this.projectPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  getCurrentBranch() {
-    return this.git("rev-parse --abbrev-ref HEAD", this.projectPath).trim();
-  }
-  isManagedWorktreePath(worktreePath) {
-    const rootPath = import_node_path6.resolve(this.rootPath);
-    const candidate = import_node_path6.resolve(worktreePath);
-    const rootWithSep = rootPath.endsWith(import_node_path6.sep) ? rootPath : `${rootPath}${import_node_path6.sep}`;
-    return candidate.startsWith(rootWithSep);
-  }
-  ensureDirectory(dirPath, label) {
-    if (import_node_fs4.existsSync(dirPath)) {
-      if (!import_node_fs4.statSync(dirPath).isDirectory()) {
-        throw new Error(`${label} exists but is not a directory: ${dirPath}`);
-      }
-      return;
-    }
-    import_node_fs4.mkdirSync(dirPath, { recursive: true });
-  }
-  isMissingDirectoryError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes("cannot create directory") || message.includes("No such file or directory");
-  }
-  cleanupFailedWorktree(worktreePath, branch) {
-    try {
-      this.git(`worktree remove "${worktreePath}" --force`, this.projectPath);
-    } catch {}
-    if (import_node_fs4.existsSync(worktreePath)) {
-      import_node_fs4.rmSync(worktreePath, { recursive: true, force: true });
-    }
-    try {
-      this.git("worktree prune", this.projectPath);
-    } catch {}
-    if (this.branchExists(branch)) {
-      try {
-        this.git(`branch -D "${branch}"`, this.projectPath);
-      } catch {}
-    }
-  }
-  isNonFastForwardPushError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes("non-fast-forward") || message.includes("[rejected]") || message.includes("fetch first");
-  }
-  git(args, cwd) {
-    return import_node_child_process5.execSync(`git ${args}`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  }
-  gitExec(args, cwd) {
-    return import_node_child_process5.execFileSync("git", args, {
-      cwd,
+  gitExec(args) {
+    return import_node_child_process4.execFileSync("git", args, {
+      cwd: this.projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
   }
 }
-var import_node_child_process5, import_node_fs4, import_node_path6;
-var init_worktree_manager = __esm(() => {
-  init_worktree_config();
-  import_node_child_process5 = require("node:child_process");
-  import_node_fs4 = require("node:fs");
-  import_node_path6 = require("node:path");
+var import_node_child_process4;
+var init_git_workflow = __esm(() => {
+  init_git_utils();
+  import_node_child_process4 = require("node:child_process");
 });
 
 // src/core/prompt-builder.ts
@@ -2373,9 +2034,9 @@ ${task.description || "No description provided."}
     }
     const contextPath = getLocusPath(this.projectPath, "contextFile");
     let hasLocalContext = false;
-    if (import_node_fs5.existsSync(contextPath)) {
+    if (import_node_fs4.existsSync(contextPath)) {
       try {
-        const context = import_node_fs5.readFileSync(contextPath, "utf-8");
+        const context = import_node_fs4.readFileSync(contextPath, "utf-8");
         if (context.trim().length > 20) {
           prompt += `## Project Context (Local)
 ${context}
@@ -2429,7 +2090,7 @@ ${serverContext.context}
 
 `;
     const indexPath = getLocusPath(this.projectPath, "indexFile");
-    if (import_node_fs5.existsSync(indexPath)) {
+    if (import_node_fs4.existsSync(indexPath)) {
       prompt += `## Codebase Overview
 There is an index file in the .locus/codebase-index.json and if you need you can check it.
 
@@ -2506,9 +2167,9 @@ ${query}
     }
     const contextPath = getLocusPath(this.projectPath, "contextFile");
     let hasLocalContext = false;
-    if (import_node_fs5.existsSync(contextPath)) {
+    if (import_node_fs4.existsSync(contextPath)) {
       try {
-        const context = import_node_fs5.readFileSync(contextPath, "utf-8");
+        const context = import_node_fs4.readFileSync(contextPath, "utf-8");
         if (context.trim().length > 20) {
           prompt += `## Project Context (Local)
 ${context}
@@ -2542,7 +2203,7 @@ ${fallback}
 
 `;
     const indexPath = getLocusPath(this.projectPath, "indexFile");
-    if (import_node_fs5.existsSync(indexPath)) {
+    if (import_node_fs4.existsSync(indexPath)) {
       prompt += `## Codebase Overview
 There is an index file in the .locus/codebase-index.json and if you need you can check it.
 
@@ -2557,9 +2218,9 @@ There is an index file in the .locus/codebase-index.json and if you need you can
   }
   getProjectConfig() {
     const configPath = getLocusPath(this.projectPath, "configFile");
-    if (import_node_fs5.existsSync(configPath)) {
+    if (import_node_fs4.existsSync(configPath)) {
       try {
-        return JSON.parse(import_node_fs5.readFileSync(configPath, "utf-8"));
+        return JSON.parse(import_node_fs4.readFileSync(configPath, "utf-8"));
       } catch {
         return null;
       }
@@ -2567,10 +2228,10 @@ There is an index file in the .locus/codebase-index.json and if you need you can
     return null;
   }
   getFallbackContext() {
-    const readmePath = import_node_path7.join(this.projectPath, "README.md");
-    if (import_node_fs5.existsSync(readmePath)) {
+    const readmePath = import_node_path6.join(this.projectPath, "README.md");
+    if (import_node_fs4.existsSync(readmePath)) {
       try {
-        const content = import_node_fs5.readFileSync(readmePath, "utf-8");
+        const content = import_node_fs4.readFileSync(readmePath, "utf-8");
         const limit = 1000;
         return content.slice(0, limit) + (content.length > limit ? `
 ...(truncated)...` : "");
@@ -2582,12 +2243,12 @@ There is an index file in the .locus/codebase-index.json and if you need you can
   }
   getProjectStructure() {
     try {
-      const entries = import_node_fs5.readdirSync(this.projectPath);
+      const entries = import_node_fs4.readdirSync(this.projectPath);
       const folders = entries.filter((e) => {
         if (e.startsWith(".") || e === "node_modules")
           return false;
         try {
-          return import_node_fs5.statSync(import_node_path7.join(this.projectPath, e)).isDirectory();
+          return import_node_fs4.statSync(import_node_path6.join(this.projectPath, e)).isDirectory();
         } catch {
           return false;
         }
@@ -2628,11 +2289,11 @@ There is an index file in the .locus/codebase-index.json and if you need you can
     }
   }
 }
-var import_node_fs5, import_node_path7, import_shared2;
+var import_node_fs4, import_node_path6, import_shared2;
 var init_prompt_builder = __esm(() => {
   init_config();
-  import_node_fs5 = require("node:fs");
-  import_node_path7 = require("node:path");
+  import_node_fs4 = require("node:fs");
+  import_node_path6 = require("node:path");
   import_shared2 = require("@locusai/shared");
 });
 
@@ -2675,162 +2336,6 @@ var init_task_executor = __esm(() => {
   init_prompt_builder();
 });
 
-// src/agent/git-workflow.ts
-class GitWorkflow {
-  config;
-  log;
-  ghUsername;
-  worktreeManager;
-  prService;
-  constructor(config, log, ghUsername) {
-    this.config = config;
-    this.log = log;
-    this.ghUsername = ghUsername;
-    const projectPath = config.projectPath || process.cwd();
-    this.worktreeManager = config.useWorktrees ? new WorktreeManager(projectPath, { cleanupPolicy: "auto" }, log) : null;
-    this.prService = config.autoPush ? new PrService(projectPath, log) : null;
-  }
-  createTaskWorktree(task, defaultExecutor) {
-    if (!this.worktreeManager) {
-      return {
-        worktreePath: null,
-        baseBranch: null,
-        baseCommitHash: null,
-        executor: defaultExecutor
-      };
-    }
-    const slug = task.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-    const result = this.worktreeManager.create({
-      taskId: task.id,
-      taskSlug: slug,
-      agentId: this.config.agentId,
-      baseBranch: this.config.baseBranch
-    });
-    this.log(`Worktree created: ${result.worktreePath} (${result.branch})`, "info");
-    const provider = this.config.provider ?? PROVIDER.CLAUDE;
-    const taskAiRunner = createAiRunner(provider, {
-      projectPath: result.worktreePath,
-      model: this.config.model,
-      log: this.log
-    });
-    const taskExecutor = new TaskExecutor({
-      aiRunner: taskAiRunner,
-      projectPath: result.worktreePath,
-      log: this.log
-    });
-    return {
-      worktreePath: result.worktreePath,
-      baseBranch: result.baseBranch,
-      baseCommitHash: result.baseCommitHash,
-      executor: taskExecutor
-    };
-  }
-  commitAndPush(worktreePath, task, baseBranch, baseCommitHash) {
-    if (!this.worktreeManager) {
-      return { branch: null, pushed: false, pushFailed: false };
-    }
-    try {
-      const trailers = [
-        `Task-ID: ${task.id}`,
-        `Agent: ${this.config.agentId}`,
-        "Co-authored-by: LocusAI <agent@locusai.team>"
-      ];
-      if (this.ghUsername) {
-        trailers.push(`Co-authored-by: ${this.ghUsername} <${this.ghUsername}@users.noreply.github.com>`);
-      }
-      const commitMessage = `feat(agent): ${task.title}
-
-${trailers.join(`
-`)}`;
-      const hash = this.worktreeManager.commitChanges(worktreePath, commitMessage, baseBranch, baseCommitHash);
-      if (!hash) {
-        this.log("No changes to commit for this task", "info");
-        return {
-          branch: null,
-          pushed: false,
-          pushFailed: false,
-          noChanges: true,
-          skipReason: "No changes were committed, so no branch was pushed."
-        };
-      }
-      const localBranch = this.worktreeManager.getBranch(worktreePath);
-      if (this.config.autoPush) {
-        try {
-          return {
-            branch: this.worktreeManager.pushBranch(worktreePath),
-            pushed: true,
-            pushFailed: false
-          };
-        } catch (err) {
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          this.log(`Git push failed: ${errorMessage}`, "error");
-          return {
-            branch: localBranch,
-            pushed: false,
-            pushFailed: true,
-            pushError: errorMessage
-          };
-        }
-      }
-      this.log("Auto-push disabled; skipping branch push", "info");
-      return {
-        branch: localBranch,
-        pushed: false,
-        pushFailed: false,
-        skipReason: "Auto-push is disabled, so PR creation was skipped."
-      };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      this.log(`Git commit failed: ${errorMessage}`, "error");
-      return {
-        branch: null,
-        pushed: false,
-        pushFailed: true,
-        pushError: `Git commit/push failed: ${errorMessage}`
-      };
-    }
-  }
-  createPullRequest(task, branch, summary, baseBranch) {
-    if (!this.prService) {
-      const errorMessage = "PR service is not initialized. Enable auto-push to allow PR creation.";
-      this.log(`PR creation skipped: ${errorMessage}`, "warn");
-      return { url: null, error: errorMessage };
-    }
-    this.log(`Attempting PR creation from branch: ${branch}`, "info");
-    try {
-      const result = this.prService.createPr({
-        task,
-        branch,
-        baseBranch,
-        agentId: this.config.agentId,
-        summary
-      });
-      return { url: result.url };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      this.log(`PR creation failed: ${errorMessage}`, "error");
-      return { url: null, error: errorMessage };
-    }
-  }
-  cleanupWorktree(worktreePath, keepBranch) {
-    if (!this.worktreeManager || !worktreePath)
-      return;
-    try {
-      this.worktreeManager.remove(worktreePath, !keepBranch);
-      this.log(keepBranch ? "Worktree cleaned up (branch preserved)" : "Worktree cleaned up", "info");
-    } catch {
-      this.log(`Could not clean up worktree: ${worktreePath}`, "warn");
-    }
-  }
-}
-var init_git_workflow = __esm(() => {
-  init_factory();
-  init_config();
-  init_pr_service();
-  init_worktree_manager();
-  init_task_executor();
-});
-
 // src/agent/worker-cli.ts
 var exports_worker_cli = {};
 __export(exports_worker_cli, {
@@ -2863,16 +2368,8 @@ function parseWorkerArgs(argv) {
       config.apiKey = args[++i];
     else if (arg === "--project-path")
       config.projectPath = args[++i];
-    else if (arg === "--main-project-path")
-      config.mainProjectPath = args[++i];
     else if (arg === "--model")
       config.model = args[++i];
-    else if (arg === "--use-worktrees")
-      config.useWorktrees = true;
-    else if (arg === "--auto-push")
-      config.autoPush = true;
-    else if (arg === "--base-branch")
-      config.baseBranch = args[++i];
     else if (arg === "--provider") {
       const value = args[i + 1];
       if (value && !value.startsWith("--"))
@@ -2920,8 +2417,8 @@ class AgentWorker {
   tasksCompleted = 0;
   heartbeatInterval = null;
   currentTaskId = null;
-  currentWorktreePath = null;
-  postCleanupDelayMs = 5000;
+  completedTaskList = [];
+  taskSummaries = [];
   constructor(config) {
     this.config = config;
     const projectPath = config.projectPath || process.cwd();
@@ -2936,17 +2433,12 @@ class AgentWorker {
       }
     });
     const log = this.log.bind(this);
-    if (config.useWorktrees && !isGitAvailable()) {
-      this.log("git is not installed — worktree isolation will not work", "error");
-      config.useWorktrees = false;
+    if (!isGitAvailable()) {
+      this.log("git is not installed — branch management will not work", "error");
     }
-    if (config.autoPush && !isGhAvailable(projectPath)) {
+    if (!isGhAvailable(projectPath)) {
       this.log("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/", "warn");
     }
-    const ghUsername = config.autoPush ? getGhUsername() : null;
-    if (ghUsername) {
-      this.log(`GitHub user: ${ghUsername}`, "info");
-    }
     const provider = config.provider ?? PROVIDER.CLAUDE;
     this.aiRunner = createAiRunner(provider, {
       projectPath,
@@ -2959,18 +2451,9 @@ class AgentWorker {
       log
     });
     this.knowledgeBase = new KnowledgeBase(projectPath);
-    this.gitWorkflow = new GitWorkflow(config, log, ghUsername);
+    this.gitWorkflow = new GitWorkflow(config, log);
     const providerLabel = provider === "codex" ? "Codex" : "Claude";
     this.log(`Using ${providerLabel} CLI for all phases`, "info");
-    if (config.useWorktrees) {
-      this.log("Per-task worktree isolation enabled", "info");
-      if (config.baseBranch) {
-        this.log(`Base branch for worktrees: ${config.baseBranch}`, "info");
-      }
-      if (config.autoPush) {
-        this.log("Auto-push enabled: branches will be pushed to remote", "info");
-      }
-    }
   }
   log(message, level = "info") {
     const timestamp = new Date().toISOString().split("T")[1]?.slice(0, 8) ?? "";
@@ -3019,56 +2502,26 @@ class AgentWorker {
   }
   async executeTask(task) {
     const fullTask = await this.client.tasks.getById(task.id, this.config.workspaceId);
-    const { worktreePath, baseBranch, baseCommitHash, executor } = this.gitWorkflow.createTaskWorktree(fullTask, this.taskExecutor);
-    this.currentWorktreePath = worktreePath;
-    let branchPushed = false;
-    let keepBranch = false;
-    let preserveWorktree = false;
     try {
-      const result = await executor.execute(fullTask);
-      let taskBranch = null;
-      let prUrl = null;
-      let prError = null;
+      const result = await this.taskExecutor.execute(fullTask);
       let noChanges = false;
-      if (result.success && worktreePath) {
-        const commitResult = this.gitWorkflow.commitAndPush(worktreePath, fullTask, baseBranch ?? undefined, baseCommitHash ?? undefined);
+      let taskBranch = null;
+      if (result.success) {
+        const commitResult = this.gitWorkflow.commitAndPush(fullTask);
         taskBranch = commitResult.branch;
-        branchPushed = commitResult.pushed;
-        keepBranch = taskBranch !== null;
         noChanges = Boolean(commitResult.noChanges);
-        if (commitResult.pushFailed) {
-          preserveWorktree = true;
-          prError = commitResult.pushError ?? "Git push failed before PR creation. Please retry manually.";
-          this.log(`Preserving worktree after push failure: ${worktreePath}`, "warn");
-        }
-        if (branchPushed && taskBranch) {
-          const prResult = this.gitWorkflow.createPullRequest(fullTask, taskBranch, result.summary, baseBranch ?? undefined);
-          prUrl = prResult.url;
-          prError = prResult.error ?? null;
-          if (!prUrl) {
-            preserveWorktree = true;
-            this.log(`Preserving worktree for manual follow-up: ${worktreePath}`, "warn");
-          }
-        } else if (commitResult.skipReason) {
-          this.log(`Skipping PR creation: ${commitResult.skipReason}`, "info");
-        }
-      } else if (result.success && !worktreePath) {
-        this.log("Skipping commit/push/PR flow because no task worktree is active.", "warn");
       }
       return {
         ...result,
         branch: taskBranch ?? undefined,
-        prUrl: prUrl ?? undefined,
-        prError: prError ?? undefined,
         noChanges: noChanges || undefined
       };
-    } finally {
-      if (preserveWorktree || keepBranch) {
-        this.currentWorktreePath = null;
-      } else {
-        this.gitWorkflow.cleanupWorktree(worktreePath, keepBranch);
-        this.currentWorktreePath = null;
-      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        summary: `Execution error: ${msg}`
+      };
     }
   }
   updateProgress(task, summary) {
@@ -3101,19 +2554,13 @@ class AgentWorker {
       this.log(`Heartbeat failed: ${err instanceof Error ? err.message : String(err)}`, "warn");
     });
   }
-  async delayAfterCleanup() {
-    if (!this.config.useWorktrees || this.postCleanupDelayMs <= 0)
-      return;
-    this.log(`Waiting ${Math.floor(this.postCleanupDelayMs / 1000)}s after worktree cleanup before next dispatch`, "info");
-    await new Promise((resolve3) => setTimeout(resolve3, this.postCleanupDelayMs));
-  }
   async run() {
     this.log(`Agent started in ${this.config.projectPath || process.cwd()}`, "success");
     const handleShutdown = () => {
       this.log("Received shutdown signal. Aborting...", "warn");
       this.aiRunner.abort();
       this.stopHeartbeat();
-      this.gitWorkflow.cleanupWorktree(this.currentWorktreePath, false);
+      this.gitWorkflow.checkoutBaseBranch();
       process.exit(1);
     };
     process.on("SIGTERM", handleShutdown);
@@ -3125,10 +2572,12 @@ class AgentWorker {
     } else {
       this.log("No active sprint found.", "warn");
     }
+    const branchName = this.gitWorkflow.createBranch(this.config.sprintId);
+    this.log(`Working on branch: ${branchName}`, "info");
     while (this.tasksCompleted < this.maxTasks) {
       const task = await this.getNextTask();
       if (!task) {
-        this.log("No more tasks to process. Exiting.", "info");
+        this.log("No more tasks to process.", "info");
         break;
       }
       this.log(`Claimed: ${task.title}`, "success");
@@ -3144,7 +2593,7 @@ class AgentWorker {
           });
           await this.client.tasks.addComment(task.id, this.config.workspaceId, {
             author: this.config.agentId,
-            text: `⚠️ Agent execution finished with no file changes, so no commit/branch/PR was created.
+            text: `⚠️ Agent execution finished with no file changes, so no commit was created.
 
 ${result.summary}`
           });
@@ -3153,22 +2602,17 @@ ${result.summary}`
           const updatePayload = {
             status: import_shared3.TaskStatus.IN_REVIEW
           };
-          if (result.prUrl) {
-            updatePayload.prUrl = result.prUrl;
-          }
           await this.client.tasks.update(task.id, this.config.workspaceId, updatePayload);
           const branchInfo = result.branch ? `
 
 Branch: \`${result.branch}\`` : "";
-          const prInfo = result.prUrl ? `
-PR: ${result.prUrl}` : "";
-          const prErrorInfo = result.prError ? `
-PR automation error: ${result.prError}` : "";
           await this.client.tasks.addComment(task.id, this.config.workspaceId, {
             author: this.config.agentId,
-            text: `✅ ${result.summary}${branchInfo}${prInfo}${prErrorInfo}`
+            text: `✅ ${result.summary}${branchInfo}`
           });
           this.tasksCompleted++;
+          this.completedTaskList.push({ title: task.title, id: task.id });
+          this.taskSummaries.push(result.summary);
           this.updateProgress(task, result.summary);
         }
       } else {
@@ -3184,8 +2628,24 @@ PR automation error: ${result.prError}` : "";
       }
       this.currentTaskId = null;
       this.sendHeartbeat();
-      await this.delayAfterCleanup();
     }
+    if (this.completedTaskList.length > 0) {
+      this.log("All tasks done. Creating pull request...", "info");
+      const prResult = this.gitWorkflow.createPullRequest(this.completedTaskList, this.taskSummaries);
+      if (prResult.url) {
+        this.log(`PR created: ${prResult.url}`, "success");
+        for (const task of this.completedTaskList) {
+          try {
+            await this.client.tasks.update(task.id, this.config.workspaceId, {
+              prUrl: prResult.url
+            });
+          } catch {}
+        }
+      } else if (prResult.error) {
+        this.log(`PR creation failed: ${prResult.error}`, "error");
+      }
+    }
+    this.gitWorkflow.checkoutBaseBranch();
     this.currentTaskId = null;
     this.stopHeartbeat();
     this.client.workspaces.heartbeat(this.config.workspaceId, this.config.agentId, null, "COMPLETED").catch(() => {});
@@ -3232,10 +2692,7 @@ __export(exports_index_node, {
   detectRemoteProvider: () => detectRemoteProvider,
   createAiRunner: () => createAiRunner,
   c: () => c,
-  WorktreeManager: () => WorktreeManager,
   WorkspacesModule: () => WorkspacesModule,
-  WORKTREE_ROOT_DIR: () => WORKTREE_ROOT_DIR,
-  WORKTREE_BRANCH_PREFIX: () => WORKTREE_BRANCH_PREFIX,
   TasksModule: () => TasksModule,
   TaskExecutor: () => TaskExecutor,
   SprintsModule: () => SprintsModule,
@@ -3263,7 +2720,6 @@ __export(exports_index_node, {
   ExecEventEmitter: () => ExecEventEmitter,
   DocumentFetcher: () => DocumentFetcher,
   DocsModule: () => DocsModule,
-  DEFAULT_WORKTREE_CONFIG: () => DEFAULT_WORKTREE_CONFIG,
   DEFAULT_MODEL: () => DEFAULT_MODEL,
   ContextTracker: () => ContextTracker,
   CodexRunner: () => CodexRunner,
@@ -3279,8 +2735,8 @@ module.exports = __toCommonJS(exports_index_node);
 
 // src/core/indexer.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs6 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path7 = require("node:path");
 var import_globby = require("globby");
 
 class CodebaseIndexer {
@@ -3289,7 +2745,7 @@ class CodebaseIndexer {
   fullReindexRatioThreshold = 0.2;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.indexPath = import_node_path8.join(projectPath, ".locus", "codebase-index.json");
+    this.indexPath = import_node_path7.join(projectPath, ".locus", "codebase-index.json");
   }
   async index(onProgress, treeSummarizer, force = false) {
     if (!treeSummarizer) {
@@ -3345,11 +2801,11 @@ class CodebaseIndexer {
     }
   }
   async getFileTree() {
-    const gitmodulesPath = import_node_path8.join(this.projectPath, ".gitmodules");
+    const gitmodulesPath = import_node_path7.join(this.projectPath, ".gitmodules");
     const submoduleIgnores = [];
-    if (import_node_fs6.existsSync(gitmodulesPath)) {
+    if (import_node_fs5.existsSync(gitmodulesPath)) {
       try {
-        const content = import_node_fs6.readFileSync(gitmodulesPath, "utf-8");
+        const content = import_node_fs5.readFileSync(gitmodulesPath, "utf-8");
         const lines = content.split(`
 `);
         for (const line of lines) {
@@ -3405,9 +2861,9 @@ class CodebaseIndexer {
     });
   }
   loadIndex() {
-    if (import_node_fs6.existsSync(this.indexPath)) {
+    if (import_node_fs5.existsSync(this.indexPath)) {
       try {
-        return JSON.parse(import_node_fs6.readFileSync(this.indexPath, "utf-8"));
+        return JSON.parse(import_node_fs5.readFileSync(this.indexPath, "utf-8"));
       } catch {
         return null;
       }
@@ -3415,11 +2871,11 @@ class CodebaseIndexer {
     return null;
   }
   saveIndex(index) {
-    const dir = import_node_path8.dirname(this.indexPath);
-    if (!import_node_fs6.existsSync(dir)) {
-      import_node_fs6.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path7.dirname(this.indexPath);
+    if (!import_node_fs5.existsSync(dir)) {
+      import_node_fs5.mkdirSync(dir, { recursive: true });
     }
-    import_node_fs6.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+    import_node_fs5.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
   }
   cloneIndex(index) {
     return JSON.parse(JSON.stringify(index));
@@ -3435,7 +2891,7 @@ class CodebaseIndexer {
   }
   hashFile(filePath) {
     try {
-      const content = import_node_fs6.readFileSync(import_node_path8.join(this.projectPath, filePath), "utf-8");
+      const content = import_node_fs5.readFileSync(import_node_path7.join(this.projectPath, filePath), "utf-8");
       return import_node_crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
     } catch {
       return null;
@@ -3586,8 +3042,8 @@ Return ONLY valid JSON, no markdown formatting.`;
 }
 // src/agent/document-fetcher.ts
 init_config();
-var import_node_fs7 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path8 = require("node:path");
 
 class DocumentFetcher {
   deps;
@@ -3596,8 +3052,8 @@ class DocumentFetcher {
   }
   async fetch() {
     const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
-    if (!import_node_fs7.existsSync(documentsDir)) {
-      import_node_fs7.mkdirSync(documentsDir, { recursive: true });
+    if (!import_node_fs6.existsSync(documentsDir)) {
+      import_node_fs6.mkdirSync(documentsDir, { recursive: true });
     }
     try {
       const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
@@ -3610,14 +3066,14 @@ class DocumentFetcher {
           continue;
         }
         const groupName = groupMap.get(doc.groupId || "") || "General";
-        const groupDir = import_node_path9.join(documentsDir, groupName);
-        if (!import_node_fs7.existsSync(groupDir)) {
-          import_node_fs7.mkdirSync(groupDir, { recursive: true });
+        const groupDir = import_node_path8.join(documentsDir, groupName);
+        if (!import_node_fs6.existsSync(groupDir)) {
+          import_node_fs6.mkdirSync(groupDir, { recursive: true });
         }
         const fileName = `${doc.title}.md`;
-        const filePath = import_node_path9.join(groupDir, fileName);
-        if (!import_node_fs7.existsSync(filePath) || import_node_fs7.readFileSync(filePath, "utf-8") !== doc.content) {
-          import_node_fs7.writeFileSync(filePath, doc.content || "");
+        const filePath = import_node_path8.join(groupDir, fileName);
+        if (!import_node_fs6.existsSync(filePath) || import_node_fs6.readFileSync(filePath, "utf-8") !== doc.content) {
+          import_node_fs6.writeFileSync(filePath, doc.content || "");
           fetchedCount++;
         }
       }
@@ -3635,7 +3091,7 @@ class DocumentFetcher {
 init_git_workflow();
 
 // src/agent/review-service.ts
-var import_node_child_process6 = require("node:child_process");
+var import_node_child_process5 = require("node:child_process");
 
 class ReviewService {
   deps;
@@ -3645,7 +3101,7 @@ class ReviewService {
   async reviewStagedChanges(sprint) {
     const { projectPath, log } = this.deps;
     try {
-      import_node_child_process6.execSync("git add -A", { cwd: projectPath, stdio: "pipe" });
+      import_node_child_process5.execSync("git add -A", { cwd: projectPath, stdio: "pipe" });
       log("Staged all changes for review.", "info");
     } catch (err) {
       log(`Failed to stage changes: ${err instanceof Error ? err.message : String(err)}`, "error");
@@ -3653,7 +3109,7 @@ class ReviewService {
     }
     let diff;
     try {
-      diff = import_node_child_process6.execSync("git diff --cached --stat && echo '---' && git diff --cached", {
+      diff = import_node_child_process5.execSync("git diff --cached --stat && echo '---' && git diff --cached", {
         cwd: projectPath,
         maxBuffer: 10 * 1024 * 1024
       }).toString();
@@ -3696,11 +3152,246 @@ Keep the review concise but thorough. Focus on substance over style.`;
 init_factory();
 init_config();
 init_git_utils();
-init_pr_service();
-init_src();
-init_knowledge_base();
-init_colors();
-function resolveProvider2(value) {
+
+// src/git/pr-service.ts
+init_git_utils();
+var import_node_child_process6 = require("node:child_process");
+
+class PrService {
+  projectPath;
+  log;
+  constructor(projectPath, log) {
+    this.projectPath = projectPath;
+    this.log = log;
+  }
+  createPr(options) {
+    const {
+      task,
+      branch,
+      baseBranch: requestedBaseBranch,
+      agentId,
+      summary
+    } = options;
+    const provider = detectRemoteProvider(this.projectPath);
+    if (provider !== "github") {
+      throw new Error(`PR creation is only supported for GitHub repositories (detected: ${provider})`);
+    }
+    if (!isGhAvailable(this.projectPath)) {
+      throw new Error("GitHub CLI (gh) is not installed or not authenticated. Install from https://cli.github.com/");
+    }
+    const title = `[Locus] ${task.title}`;
+    const body = this.buildPrBody(task, agentId, summary);
+    const baseBranch = requestedBaseBranch ?? getDefaultBranch(this.projectPath);
+    this.validateCreatePrInputs(baseBranch, branch);
+    this.log(`Creating PR: ${title} (${branch} → ${baseBranch})`, "info");
+    const output = import_node_child_process6.execFileSync("gh", [
+      "pr",
+      "create",
+      "--title",
+      title,
+      "--body",
+      body,
+      "--base",
+      baseBranch,
+      "--head",
+      branch
+    ], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const url = output;
+    const prNumber = this.extractPrNumber(url);
+    this.log(`PR created: ${url}`, "success");
+    return { url, number: prNumber };
+  }
+  validateCreatePrInputs(baseBranch, headBranch) {
+    if (!this.hasRemoteBranch(baseBranch)) {
+      throw new Error(`Base branch "${baseBranch}" does not exist on origin. Push/fetch refs and retry.`);
+    }
+    if (!this.hasRemoteBranch(headBranch)) {
+      throw new Error(`Head branch "${headBranch}" is not available on origin. Ensure it is pushed before PR creation.`);
+    }
+    const baseRef = this.resolveBranchRef(baseBranch);
+    const headRef = this.resolveBranchRef(headBranch);
+    if (!baseRef) {
+      throw new Error(`Could not resolve base branch "${baseBranch}" locally.`);
+    }
+    if (!headRef) {
+      throw new Error(`Could not resolve head branch "${headBranch}" locally.`);
+    }
+    const commitsAhead = this.countCommitsAhead(baseRef, headRef);
+    if (commitsAhead <= 0) {
+      throw new Error(`No commits between "${baseBranch}" and "${headBranch}". Skipping PR creation.`);
+    }
+  }
+  countCommitsAhead(baseRef, headRef) {
+    const output = import_node_child_process6.execFileSync("git", ["rev-list", "--count", `${baseRef}..${headRef}`], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const value = Number.parseInt(output || "0", 10);
+    return Number.isNaN(value) ? 0 : value;
+  }
+  resolveBranchRef(branch) {
+    if (this.hasLocalBranch(branch)) {
+      return branch;
+    }
+    if (this.hasRemoteTrackingBranch(branch)) {
+      return `origin/${branch}`;
+    }
+    return null;
+  }
+  hasLocalBranch(branch) {
+    try {
+      import_node_child_process6.execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  hasRemoteTrackingBranch(branch) {
+    try {
+      import_node_child_process6.execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${branch}`], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  hasRemoteBranch(branch) {
+    try {
+      import_node_child_process6.execFileSync("git", ["ls-remote", "--exit-code", "--heads", "origin", branch], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getPrDiff(branch) {
+    return import_node_child_process6.execFileSync("gh", ["pr", "diff", branch], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+    });
+  }
+  submitReview(prIdentifier, body, event) {
+    try {
+      import_node_child_process6.execFileSync("gh", [
+        "pr",
+        "review",
+        prIdentifier,
+        "--body",
+        body,
+        `--${event.toLowerCase().replace("_", "-")}`
+      ], {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (event === "REQUEST_CHANGES" && msg.includes("own pull request")) {
+        import_node_child_process6.execFileSync("gh", ["pr", "review", prIdentifier, "--body", body, "--comment"], {
+          cwd: this.projectPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        return;
+      }
+      throw err;
+    }
+  }
+  listLocusPrs() {
+    try {
+      const output = import_node_child_process6.execFileSync("gh", [
+        "pr",
+        "list",
+        "--search",
+        "[Locus] in:title",
+        "--state",
+        "open",
+        "--json",
+        "number,title,url,headRefName"
+      ], {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const prs = JSON.parse(output || "[]");
+      return prs.map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        url: pr.url,
+        branch: pr.headRefName
+      }));
+    } catch {
+      this.log("Failed to list Locus PRs", "warn");
+      return [];
+    }
+  }
+  hasLocusReview(prNumber) {
+    try {
+      const output = import_node_child_process6.execFileSync("gh", ["pr", "view", prNumber, "--json", "reviews"], {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const data = JSON.parse(output || "{}");
+      return data.reviews?.some((r) => r.body?.includes("## Locus Agent Review")) ?? false;
+    } catch {
+      return false;
+    }
+  }
+  listUnreviewedLocusPrs() {
+    const allPrs = this.listLocusPrs();
+    return allPrs.filter((pr) => !this.hasLocusReview(String(pr.number)));
+  }
+  buildPrBody(task, agentId, summary) {
+    const sections = [];
+    sections.push(`## Task: ${task.title}`);
+    sections.push("");
+    if (task.description) {
+      sections.push(task.description);
+      sections.push("");
+    }
+    if (task.acceptanceChecklist?.length > 0) {
+      sections.push("## Acceptance Criteria");
+      for (const item of task.acceptanceChecklist) {
+        sections.push(`- [ ] ${item.text}`);
+      }
+      sections.push("");
+    }
+    if (summary) {
+      sections.push("## Agent Summary");
+      sections.push(summary);
+      sections.push("");
+    }
+    sections.push("---");
+    sections.push(`*Created by Locus Agent \`${agentId.slice(-8)}\`* | Task ID: \`${task.id}\``);
+    return sections.join(`
+`);
+  }
+  extractPrNumber(url) {
+    const match = url.match(/\/pull\/(\d+)/);
+    return match ? Number.parseInt(match[1], 10) : 0;
+  }
+}
+
+// src/agent/reviewer-worker.ts
+init_src();
+init_knowledge_base();
+init_colors();
+function resolveProvider2(value) {
   if (!value || value.startsWith("--"))
     return PROVIDER.CLAUDE;
   if (value === PROVIDER.CLAUDE || value === PROVIDER.CODEX)
@@ -4344,8 +4035,8 @@ class ExecEventEmitter {
 }
 // src/exec/history-manager.ts
 init_config();
-var import_node_fs8 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path9 = require("node:path");
 var DEFAULT_MAX_SESSIONS = 30;
 function generateSessionId2() {
   const timestamp = Date.now().toString(36);
@@ -4357,30 +4048,30 @@ class HistoryManager {
   historyDir;
   maxSessions;
   constructor(projectPath, options) {
-    this.historyDir = options?.historyDir ?? import_node_path10.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
+    this.historyDir = options?.historyDir ?? import_node_path9.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.ensureHistoryDir();
   }
   ensureHistoryDir() {
-    if (!import_node_fs8.existsSync(this.historyDir)) {
-      import_node_fs8.mkdirSync(this.historyDir, { recursive: true });
+    if (!import_node_fs7.existsSync(this.historyDir)) {
+      import_node_fs7.mkdirSync(this.historyDir, { recursive: true });
     }
   }
   getSessionPath(sessionId) {
-    return import_node_path10.join(this.historyDir, `${sessionId}.json`);
+    return import_node_path9.join(this.historyDir, `${sessionId}.json`);
   }
   saveSession(session) {
     const filePath = this.getSessionPath(session.id);
     session.updatedAt = Date.now();
-    import_node_fs8.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+    import_node_fs7.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
   }
   loadSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs8.existsSync(filePath)) {
+    if (!import_node_fs7.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = import_node_fs8.readFileSync(filePath, "utf-8");
+      const content = import_node_fs7.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -4388,18 +4079,18 @@ class HistoryManager {
   }
   deleteSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs8.existsSync(filePath)) {
+    if (!import_node_fs7.existsSync(filePath)) {
       return false;
     }
     try {
-      import_node_fs8.rmSync(filePath);
+      import_node_fs7.rmSync(filePath);
       return true;
     } catch {
       return false;
     }
   }
   listSessions(options) {
-    const files = import_node_fs8.readdirSync(this.historyDir);
+    const files = import_node_fs7.readdirSync(this.historyDir);
     let sessions = [];
     for (const file of files) {
       if (file.endsWith(".json")) {
@@ -4472,11 +4163,11 @@ class HistoryManager {
     return deleted;
   }
   getSessionCount() {
-    const files = import_node_fs8.readdirSync(this.historyDir);
+    const files = import_node_fs7.readdirSync(this.historyDir);
     return files.filter((f) => f.endsWith(".json")).length;
   }
   sessionExists(sessionId) {
-    return import_node_fs8.existsSync(this.getSessionPath(sessionId));
+    return import_node_fs7.existsSync(this.getSessionPath(sessionId));
   }
   findSessionByPartialId(partialId) {
     const sessions = this.listSessions();
@@ -4490,12 +4181,12 @@ class HistoryManager {
     return this.historyDir;
   }
   clearAllSessions() {
-    const files = import_node_fs8.readdirSync(this.historyDir);
+    const files = import_node_fs7.readdirSync(this.historyDir);
     let deleted = 0;
     for (const file of files) {
       if (file.endsWith(".json")) {
         try {
-          import_node_fs8.rmSync(import_node_path10.join(this.historyDir, file));
+          import_node_fs7.rmSync(import_node_path9.join(this.historyDir, file));
           deleted++;
         } catch {}
       }
@@ -4761,7 +4452,6 @@ ${currentPrompt}`);
 }
 // src/git/index.ts
 init_git_utils();
-init_pr_service();
 
 // src/index-node.ts
 init_src();
@@ -4770,59 +4460,128 @@ init_src();
 init_git_utils();
 init_src();
 init_colors();
-init_worktree_manager();
-var import_shared6 = require("@locusai/shared");
-var import_events5 = require("events");
-
-// src/orchestrator/agent-pool.ts
-init_colors();
 init_resolve_bin();
 var import_node_child_process7 = require("node:child_process");
-var import_node_fs9 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path10 = require("node:path");
 var import_node_url = require("node:url");
 var import_shared4 = require("@locusai/shared");
 var import_events4 = require("events");
-var MAX_AGENTS = 5;
 
-class AgentPool extends import_events4.EventEmitter {
+class AgentOrchestrator extends import_events4.EventEmitter {
+  client;
   config;
-  agents = new Map;
+  isRunning = false;
+  processedTasks = new Set;
+  resolvedSprintId = null;
+  agentState = null;
   heartbeatInterval = null;
   constructor(config) {
     super();
     this.config = config;
+    this.client = new LocusClient({
+      baseUrl: config.apiBase,
+      token: config.apiKey
+    });
   }
-  get size() {
-    return this.agents.size;
-  }
-  get effectiveAgentCount() {
-    return Math.min(Math.max(this.config.agentCount ?? 1, 1), MAX_AGENTS);
-  }
-  getAll() {
-    return Array.from(this.agents.values());
-  }
-  get(agentId) {
-    return this.agents.get(agentId);
-  }
-  async spawn(index, resolvedSprintId, baseBranch) {
-    const agentId = `agent-${index}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-    const agentState = {
-      id: agentId,
-      status: "IDLE",
-      currentTaskId: null,
-      tasksCompleted: 0,
+  async resolveSprintId() {
+    if (this.config.sprintId) {
+      return this.config.sprintId;
+    }
+    try {
+      const sprint = await this.client.sprints.getActive(this.config.workspaceId);
+      if (sprint?.id) {
+        console.log(c.info(`\uD83D\uDCCB Using active sprint: ${sprint.name}`));
+        return sprint.id;
+      }
+    } catch {}
+    console.log(c.dim("ℹ  No sprint specified, working with all workspace tasks"));
+    return "";
+  }
+  async start() {
+    if (this.isRunning) {
+      throw new Error("Orchestrator is already running");
+    }
+    this.isRunning = true;
+    this.processedTasks.clear();
+    try {
+      await this.orchestrationLoop();
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    } finally {
+      await this.cleanup();
+    }
+  }
+  async orchestrationLoop() {
+    this.resolvedSprintId = await this.resolveSprintId();
+    this.emit("started", {
+      timestamp: new Date,
+      config: this.config,
+      sprintId: this.resolvedSprintId
+    });
+    this.printBanner();
+    const tasks2 = await this.getAvailableTasks();
+    if (tasks2.length === 0) {
+      console.log(c.dim("ℹ  No available tasks found in the backlog."));
+      return;
+    }
+    if (!this.preflightChecks())
+      return;
+    this.startHeartbeatMonitor();
+    await this.spawnAgent();
+    await this.waitForAgent();
+    console.log(`
+${c.success("✅ Orchestrator finished")}`);
+  }
+  printBanner() {
+    console.log(`
+${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
+    console.log(c.dim("----------------------------------------------"));
+    console.log(`${c.bold("Workspace:")} ${this.config.workspaceId}`);
+    if (this.resolvedSprintId) {
+      console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
+    }
+    console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
+    console.log(c.dim(`----------------------------------------------
+`));
+  }
+  preflightChecks() {
+    if (!isGitAvailable()) {
+      console.log(c.error("git is not installed. Install from https://git-scm.com/"));
+      return false;
+    }
+    if (!isGhAvailable(this.config.projectPath)) {
+      console.log(c.warning("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/"));
+    }
+    return true;
+  }
+  async getAvailableTasks() {
+    try {
+      const tasks2 = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
+      return tasks2.filter((task) => !this.processedTasks.has(task.id));
+    } catch (error) {
+      this.emit("error", error);
+      return [];
+    }
+  }
+  async spawnAgent() {
+    const agentId = `agent-0-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    this.agentState = {
+      id: agentId,
+      status: "IDLE",
+      currentTaskId: null,
+      tasksCompleted: 0,
       tasksFailed: 0,
       lastHeartbeat: new Date
     };
-    this.agents.set(agentId, agentState);
     console.log(`${c.primary("\uD83D\uDE80 Agent started:")} ${c.bold(agentId)}
 `);
     const workerPath = this.resolveWorkerPath();
     if (!workerPath) {
       throw new Error("Worker file not found. Make sure the SDK is properly built and installed.");
     }
-    const workerArgs = this.buildWorkerArgs(agentId, resolvedSprintId, baseBranch);
+    const workerArgs = this.buildWorkerArgs(agentId);
     const agentProcess = import_node_child_process7.spawn(process.execPath, [workerPath, ...workerArgs], {
       stdio: ["pipe", "pipe", "pipe"],
       detached: true,
@@ -4833,60 +4592,64 @@ class AgentPool extends import_events4.EventEmitter {
         LOCUS_WORKSPACE: this.config.workspaceId
       })
     });
-    agentState.process = agentProcess;
-    this.attachProcessHandlers(agentId, agentState, agentProcess);
+    this.agentState.process = agentProcess;
+    this.attachProcessHandlers(agentId, this.agentState, agentProcess);
     this.emit("agent:spawned", { agentId });
   }
-  async waitForAll(isRunning) {
-    while (this.agents.size > 0 && isRunning()) {
+  async waitForAgent() {
+    while (this.agentState && this.isRunning) {
       await sleep(2000);
     }
   }
   startHeartbeatMonitor() {
     this.heartbeatInterval = setInterval(() => {
+      if (!this.agentState)
+        return;
       const now = Date.now();
-      for (const [agentId, agent] of this.agents.entries()) {
-        if (agent.status === "WORKING" && now - agent.lastHeartbeat.getTime() > import_shared4.STALE_AGENT_TIMEOUT_MS) {
-          console.log(c.error(`Agent ${agentId} is stale (no heartbeat for 10 minutes). Killing.`));
-          if (agent.process && !agent.process.killed) {
-            killProcessTree(agent.process);
-          }
-          this.emit("agent:stale", { agentId });
+      if (this.agentState.status === "WORKING" && now - this.agentState.lastHeartbeat.getTime() > import_shared4.STALE_AGENT_TIMEOUT_MS) {
+        console.log(c.error(`Agent ${this.agentState.id} is stale (no heartbeat for 10 minutes). Killing.`));
+        if (this.agentState.process && !this.agentState.process.killed) {
+          killProcessTree(this.agentState.process);
         }
+        this.emit("agent:stale", { agentId: this.agentState.id });
       }
     }, 60000);
   }
+  async stop() {
+    this.isRunning = false;
+    await this.cleanup();
+    this.emit("stopped", { timestamp: new Date });
+  }
   stopAgent(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent)
+    if (!this.agentState || this.agentState.id !== agentId)
       return false;
-    if (agent.process && !agent.process.killed) {
-      killProcessTree(agent.process);
+    if (this.agentState.process && !this.agentState.process.killed) {
+      killProcessTree(this.agentState.process);
     }
     return true;
   }
-  shutdown() {
+  async cleanup() {
     if (this.heartbeatInterval) {
       clearInterval(this.heartbeatInterval);
       this.heartbeatInterval = null;
     }
-    for (const [agentId, agent] of this.agents.entries()) {
-      if (agent.process && !agent.process.killed) {
-        console.log(`Killing agent: ${agentId}`);
-        killProcessTree(agent.process);
-      }
+    if (this.agentState?.process && !this.agentState.process.killed) {
+      console.log(`Killing agent: ${this.agentState.id}`);
+      killProcessTree(this.agentState.process);
     }
-    this.agents.clear();
   }
   getStats() {
     return {
-      activeAgents: this.agents.size,
-      agentCount: this.effectiveAgentCount,
-      totalTasksCompleted: this.getAll().reduce((sum, a) => sum + a.tasksCompleted, 0),
-      totalTasksFailed: this.getAll().reduce((sum, a) => sum + a.tasksFailed, 0)
+      activeAgents: this.agentState ? 1 : 0,
+      totalTasksCompleted: this.agentState?.tasksCompleted ?? 0,
+      totalTasksFailed: this.agentState?.tasksFailed ?? 0,
+      processedTasks: this.processedTasks.size
     };
   }
-  buildWorkerArgs(agentId, resolvedSprintId, baseBranch) {
+  getAgentStates() {
+    return this.agentState ? [this.agentState] : [];
+  }
+  buildWorkerArgs(agentId) {
     const args = [
       "--agent-id",
       agentId,
@@ -4905,17 +4668,8 @@ class AgentPool extends import_events4.EventEmitter {
     if (this.config.provider) {
       args.push("--provider", this.config.provider);
     }
-    if (resolvedSprintId) {
-      args.push("--sprint-id", resolvedSprintId);
-    }
-    if (this.config.useWorktrees ?? true) {
-      args.push("--use-worktrees");
-    }
-    if (this.config.autoPush) {
-      args.push("--auto-push");
-    }
-    if (baseBranch) {
-      args.push("--base-branch", baseBranch);
+    if (this.resolvedSprintId) {
+      args.push("--sprint-id", this.resolvedSprintId);
     }
     return args;
   }
@@ -4938,29 +4692,28 @@ class AgentPool extends import_events4.EventEmitter {
     proc.on("exit", (code) => {
       console.log(`
 ${agentId} finished (exit code: ${code})`);
-      const agent = this.agents.get(agentId);
-      if (agent) {
-        agent.status = code === 0 ? "COMPLETED" : "FAILED";
+      if (this.agentState) {
+        this.agentState.status = code === 0 ? "COMPLETED" : "FAILED";
         this.emit("agent:completed", {
           agentId,
-          status: agent.status,
-          tasksCompleted: agent.tasksCompleted,
-          tasksFailed: agent.tasksFailed
+          status: this.agentState.status,
+          tasksCompleted: this.agentState.tasksCompleted,
+          tasksFailed: this.agentState.tasksFailed
         });
-        this.agents.delete(agentId);
+        this.agentState = null;
       }
     });
   }
   resolveWorkerPath() {
-    const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator/agent-pool.ts");
-    const currentModuleDir = import_node_path11.dirname(currentModulePath);
+    const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator/index.ts");
+    const currentModuleDir = import_node_path10.dirname(currentModulePath);
     const potentialPaths = [
-      import_node_path11.join(currentModuleDir, "..", "agent", "worker.js"),
-      import_node_path11.join(currentModuleDir, "agent", "worker.js"),
-      import_node_path11.join(currentModuleDir, "worker.js"),
-      import_node_path11.join(currentModuleDir, "..", "agent", "worker.ts")
+      import_node_path10.join(currentModuleDir, "..", "agent", "worker.js"),
+      import_node_path10.join(currentModuleDir, "agent", "worker.js"),
+      import_node_path10.join(currentModuleDir, "worker.js"),
+      import_node_path10.join(currentModuleDir, "..", "agent", "worker.ts")
     ];
-    return potentialPaths.find((p) => import_node_fs9.existsSync(p));
+    return potentialPaths.find((p) => import_node_fs8.existsSync(p));
   }
 }
 function killProcessTree(proc) {
@@ -4975,460 +4728,16 @@ function killProcessTree(proc) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-
-// src/orchestrator/execution.ts
-init_git_utils();
-init_colors();
-var import_shared5 = require("@locusai/shared");
-var SPAWN_DELAY_MS = 5000;
-
-class ExecutionStrategy {
-  config;
-  pool;
-  tierMerge;
-  resolvedSprintId;
-  isRunning;
-  constructor(config, pool, tierMerge, resolvedSprintId, isRunning) {
-    this.config = config;
-    this.pool = pool;
-    this.tierMerge = tierMerge;
-    this.resolvedSprintId = resolvedSprintId;
-    this.isRunning = isRunning;
-  }
-  async execute(tasks2) {
-    const hasTiers = tasks2.some((t) => t.tier !== null && t.tier !== undefined);
-    const useWorktrees = this.config.useWorktrees ?? true;
-    if (hasTiers && useWorktrees) {
-      await this.tierBasedExecution(tasks2);
-    } else {
-      await this.legacyExecution(tasks2);
-    }
-  }
-  async tierBasedExecution(allTasks) {
-    const tierMap = groupByTier(allTasks);
-    const tiers = Array.from(tierMap.keys()).sort((a, b) => a - b);
-    const defaultBranch = getDefaultBranch(this.config.projectPath);
-    console.log(c.primary(`\uD83D\uDCCA Tier-based execution: ${tiers.length} tier(s) detected [${tiers.join(", ")}]`));
-    let currentBaseBranch = defaultBranch;
-    for (const tier of tiers) {
-      if (!this.isRunning())
-        break;
-      const tierTasks = tierMap.get(tier) ?? [];
-      const dispatchable = tierTasks.filter(isDispatchable);
-      if (dispatchable.length === 0) {
-        console.log(c.dim(`ℹ  Tier ${tier}: all ${tierTasks.length} task(s) already completed, skipping`));
-        const tierBranch = this.tierMerge.tierBranchName(tier);
-        if (this.tierMerge.remoteBranchExists(tierBranch)) {
-          currentBaseBranch = tierBranch;
-        }
-        continue;
-      }
-      console.log(`
-${c.primary(`\uD83C\uDFD7️  Tier ${tier}:`)} ${dispatchable.length} task(s) | base: ${c.bold(currentBaseBranch)}`);
-      await this.spawnAgentsForTasks(dispatchable.length, currentBaseBranch);
-      await this.pool.waitForAll(this.isRunning);
-      console.log(c.success(`✓ Tier ${tier} complete`));
-      if (this.config.autoPush && tiers.indexOf(tier) < tiers.length - 1) {
-        const mergeBranch = this.tierMerge.createMergeBranch(tier, currentBaseBranch);
-        if (mergeBranch) {
-          currentBaseBranch = mergeBranch;
-          console.log(c.success(`\uD83D\uDCCC Created merge branch: ${mergeBranch} (base for tier ${tier + 1})`));
-        }
-      }
-    }
-  }
-  async legacyExecution(tasks2) {
-    const defaultBranch = getDefaultBranch(this.config.projectPath);
-    await this.spawnAgentsForTasks(tasks2.length, defaultBranch);
-    await this.pool.waitForAll(this.isRunning);
-  }
-  async spawnAgentsForTasks(taskCount, baseBranch) {
-    const agentsToSpawn = Math.min(this.pool.effectiveAgentCount, taskCount);
-    const spawnPromises = [];
-    for (let i = 0;i < agentsToSpawn; i++) {
-      if (i > 0) {
-        await sleep2(SPAWN_DELAY_MS);
-      }
-      spawnPromises.push(this.pool.spawn(i, this.resolvedSprintId, baseBranch));
-    }
-    await Promise.all(spawnPromises);
-  }
-}
-function groupByTier(tasks2) {
-  const tierMap = new Map;
-  for (const task of tasks2) {
-    const tier = task.tier ?? 0;
-    const existing = tierMap.get(tier);
-    if (existing) {
-      existing.push(task);
-    } else {
-      tierMap.set(tier, [task]);
-    }
-  }
-  return tierMap;
-}
-function isDispatchable(task) {
-  return task.status === import_shared5.TaskStatus.BACKLOG || task.status === import_shared5.TaskStatus.IN_PROGRESS && !task.assignedTo;
-}
-function sleep2(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-
-// src/orchestrator/tier-merge.ts
-init_colors();
-var import_node_child_process8 = require("node:child_process");
-var TIER_BRANCH_PREFIX = "locus/tier";
-
-class TierMergeService {
-  projectPath;
-  sprintId;
-  tierTaskIds = new Map;
-  constructor(projectPath, sprintId) {
-    this.projectPath = projectPath;
-    this.sprintId = sprintId;
-  }
-  registerTierTasks(tasks2) {
-    for (const task of tasks2) {
-      const tier = task.tier ?? 0;
-      const existing = this.tierTaskIds.get(tier);
-      if (existing) {
-        existing.push(task.id);
-      } else {
-        this.tierTaskIds.set(tier, [task.id]);
-      }
-    }
-  }
-  tierBranchName(tier) {
-    const suffix = this.sprintId ? `-${this.sprintId.slice(0, 8)}` : "";
-    return `${TIER_BRANCH_PREFIX}-${tier}${suffix}`;
-  }
-  remoteBranchExists(branch) {
-    try {
-      import_node_child_process8.execFileSync("git", ["ls-remote", "--exit-code", "--heads", "origin", branch], {
-        cwd: this.projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  createMergeBranch(tier, baseBranch) {
-    const mergeBranchName = this.tierBranchName(tier);
-    try {
-      this.gitExec(["fetch", "origin"]);
-      const tierTaskBranches = this.findTierTaskBranches(tier);
-      if (tierTaskBranches.length === 0) {
-        console.log(c.dim(`   Tier ${tier}: no pushed task branches found, skipping merge branch creation`));
-        return null;
-      }
-      console.log(c.dim(`   Merging ${tierTaskBranches.length} branch(es) into ${mergeBranchName}: ${tierTaskBranches.join(", ")}`));
-      try {
-        this.gitExec(["branch", "-D", mergeBranchName]);
-      } catch {}
-      this.gitExec(["checkout", "-b", mergeBranchName, `origin/${baseBranch}`]);
-      for (const branch of tierTaskBranches) {
-        try {
-          this.gitExec(["merge", `origin/${branch}`, "--no-edit"]);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          console.log(c.error(`   Merge conflict merging ${branch} into ${mergeBranchName}: ${msg}`));
-          try {
-            this.gitExec(["merge", "--abort"]);
-          } catch {}
-        }
-      }
-      this.gitExec(["push", "-u", "origin", mergeBranchName, "--force"]);
-      this.gitExec(["checkout", baseBranch]);
-      return mergeBranchName;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.log(c.error(`Failed to create tier merge branch: ${msg}`));
-      try {
-        this.gitExec(["checkout", baseBranch]);
-      } catch {}
-      return null;
-    }
-  }
-  findTierTaskBranches(tier) {
-    const tierTaskIds = this.tierTaskIds.get(tier);
-    if (!tierTaskIds || tierTaskIds.length === 0)
-      return [];
-    try {
-      const output = import_node_child_process8.execSync('git branch -r --list "origin/agent/*" --format="%(refname:short)"', { cwd: this.projectPath, encoding: "utf-8" }).trim();
-      if (!output)
-        return [];
-      const remoteBranches = output.split(`
-`).map((b) => b.replace("origin/", ""));
-      return remoteBranches.filter((branch) => {
-        const branchSuffix = branch.replace(/^agent\//, "");
-        if (!branchSuffix)
-          return false;
-        return tierTaskIds.some((id) => branchSuffix.startsWith(`${id}-`) || branchSuffix === id || branchSuffix.startsWith(id));
-      });
-    } catch (err) {
-      console.log(c.dim(`   Could not list remote branches for tier ${tier}: ${err instanceof Error ? err.message : String(err)}`));
-      return [];
-    }
-  }
-  gitExec(args) {
-    return import_node_child_process8.execFileSync("git", args, {
-      cwd: this.projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  }
-}
-
-// src/orchestrator/index.ts
-class AgentOrchestrator extends import_events5.EventEmitter {
-  client;
-  config;
-  pool;
-  isRunning = false;
-  processedTasks = new Set;
-  resolvedSprintId = null;
-  worktreeManager = null;
-  constructor(config) {
-    super();
-    this.config = config;
-    this.client = new LocusClient({
-      baseUrl: config.apiBase,
-      token: config.apiKey
-    });
-    this.pool = new AgentPool(config);
-    this.pool.on("agent:spawned", (data) => this.emit("agent:spawned", data));
-    this.pool.on("agent:completed", (data) => this.emit("agent:completed", data));
-    this.pool.on("agent:stale", (data) => this.emit("agent:stale", data));
-  }
-  get useWorktrees() {
-    return this.config.useWorktrees ?? true;
-  }
-  get worktreeCleanupPolicy() {
-    return this.config.worktreeCleanupPolicy ?? "retain-on-failure";
-  }
-  async resolveSprintId() {
-    if (this.config.sprintId) {
-      return this.config.sprintId;
-    }
-    try {
-      const sprint = await this.client.sprints.getActive(this.config.workspaceId);
-      if (sprint?.id) {
-        console.log(c.info(`\uD83D\uDCCB Using active sprint: ${sprint.name}`));
-        return sprint.id;
-      }
-    } catch {}
-    console.log(c.dim("ℹ  No sprint specified, working with all workspace tasks"));
-    return "";
-  }
-  async start() {
-    if (this.isRunning) {
-      throw new Error("Orchestrator is already running");
-    }
-    this.isRunning = true;
-    this.processedTasks.clear();
-    try {
-      await this.orchestrationLoop();
-    } catch (error) {
-      this.emit("error", error);
-      throw error;
-    } finally {
-      await this.cleanup();
-    }
-  }
-  async orchestrationLoop() {
-    this.resolvedSprintId = await this.resolveSprintId();
-    this.emit("started", {
-      timestamp: new Date,
-      config: this.config,
-      sprintId: this.resolvedSprintId
-    });
-    this.printBanner();
-    const tasks2 = await this.getAvailableTasks();
-    if (tasks2.length === 0) {
-      console.log(c.dim("ℹ  No available tasks found in the backlog."));
-      return;
-    }
-    if (!this.preflightChecks(tasks2))
-      return;
-    if (this.useWorktrees) {
-      this.worktreeManager = new WorktreeManager(this.config.projectPath, {
-        cleanupPolicy: this.worktreeCleanupPolicy
-      });
-    }
-    this.pool.startHeartbeatMonitor();
-    const tierMerge = new TierMergeService(this.config.projectPath, this.resolvedSprintId);
-    tierMerge.registerTierTasks(tasks2);
-    const execution = new ExecutionStrategy(this.config, this.pool, tierMerge, this.resolvedSprintId, () => this.isRunning);
-    await execution.execute(tasks2);
-    console.log(`
-${c.success("✅ Orchestrator finished")}`);
-  }
-  printBanner() {
-    console.log(`
-${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
-    console.log(c.dim("----------------------------------------------"));
-    console.log(`${c.bold("Workspace:")} ${this.config.workspaceId}`);
-    if (this.resolvedSprintId) {
-      console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
-    }
-    console.log(`${c.bold("Agents:")} ${this.pool.effectiveAgentCount}`);
-    console.log(`${c.bold("Worktrees:")} ${this.useWorktrees ? "enabled" : "disabled"}`);
-    if (this.useWorktrees) {
-      console.log(`${c.bold("Cleanup policy:")} ${this.worktreeCleanupPolicy}`);
-      console.log(`${c.bold("Auto-push:")} ${this.config.autoPush ? "enabled" : "disabled"}`);
-    }
-    console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
-    console.log(c.dim(`----------------------------------------------
-`));
-  }
-  preflightChecks(_tasks) {
-    if (this.useWorktrees && !isGitAvailable()) {
-      console.log(c.error("git is not installed. Worktree isolation requires git. Install from https://git-scm.com/"));
-      return false;
-    }
-    if (this.config.autoPush && !isGhAvailable(this.config.projectPath)) {
-      console.log(c.warning("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/"));
-    }
-    return true;
-  }
-  async getAvailableTasks() {
-    try {
-      const tasks2 = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
-      return tasks2.filter((task) => !this.processedTasks.has(task.id));
-    } catch (error) {
-      this.emit("error", error);
-      return [];
-    }
-  }
-  async assignTaskToAgent(agentId) {
-    const agent = this.pool.get(agentId);
-    if (!agent)
-      return null;
-    try {
-      const tasks2 = await this.getAvailableTasks();
-      const priorityOrder = [
-        import_shared6.TaskPriority.CRITICAL,
-        import_shared6.TaskPriority.HIGH,
-        import_shared6.TaskPriority.MEDIUM,
-        import_shared6.TaskPriority.LOW
-      ];
-      let task = tasks2.sort((a, b) => priorityOrder.indexOf(a.priority) - priorityOrder.indexOf(b.priority))[0];
-      if (!task && tasks2.length > 0) {
-        task = tasks2[0];
-      }
-      if (!task)
-        return null;
-      agent.currentTaskId = task.id;
-      agent.status = "WORKING";
-      this.emit("task:assigned", {
-        agentId,
-        taskId: task.id,
-        title: task.title
-      });
-      return task;
-    } catch (error) {
-      this.emit("error", error);
-      return null;
-    }
-  }
-  async completeTask(taskId, agentId, summary) {
-    try {
-      await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared6.TaskStatus.IN_REVIEW
-      });
-      if (summary) {
-        await this.client.tasks.addComment(taskId, this.config.workspaceId, {
-          author: agentId,
-          text: `✅ Task completed
-
-${summary}`
-        });
-      }
-      this.processedTasks.add(taskId);
-      const agent = this.pool.get(agentId);
-      if (agent) {
-        agent.tasksCompleted += 1;
-        agent.currentTaskId = null;
-        agent.status = "IDLE";
-      }
-      this.emit("task:completed", { agentId, taskId });
-    } catch (error) {
-      this.emit("error", error);
-    }
-  }
-  async failTask(taskId, agentId, error) {
-    try {
-      await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared6.TaskStatus.BACKLOG,
-        assignedTo: null
-      });
-      await this.client.tasks.addComment(taskId, this.config.workspaceId, {
-        author: agentId,
-        text: `❌ Agent failed: ${error}`
-      });
-      const agent = this.pool.get(agentId);
-      if (agent) {
-        agent.tasksFailed += 1;
-        agent.currentTaskId = null;
-        agent.status = "IDLE";
-      }
-      this.emit("task:failed", { agentId, taskId, error });
-    } catch (error2) {
-      this.emit("error", error2);
-    }
-  }
-  async stop() {
-    this.isRunning = false;
-    await this.cleanup();
-    this.emit("stopped", { timestamp: new Date });
-  }
-  stopAgent(agentId) {
-    return this.pool.stopAgent(agentId);
-  }
-  async cleanup() {
-    this.pool.shutdown();
-    if (this.worktreeManager) {
-      try {
-        if (this.worktreeCleanupPolicy === "auto") {
-          const removed = this.worktreeManager.removeAll();
-          if (removed > 0) {
-            console.log(c.dim(`Cleaned up ${removed} worktree(s)`));
-          }
-        } else if (this.worktreeCleanupPolicy === "retain-on-failure") {
-          this.worktreeManager.prune();
-          console.log(c.dim("Retaining worktrees for failure analysis (cleanup policy: retain-on-failure)"));
-        } else {
-          console.log(c.dim("Skipping worktree cleanup (cleanup policy: manual)"));
-        }
-      } catch {
-        console.log(c.dim("Could not clean up some worktrees"));
-      }
-    }
-  }
-  getStats() {
-    const poolStats = this.pool.getStats();
-    return {
-      ...poolStats,
-      useWorktrees: this.useWorktrees,
-      processedTasks: this.processedTasks.size
-    };
-  }
-  getAgentStates() {
-    return this.pool.getAll();
-  }
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 // src/planning/plan-manager.ts
 init_config();
 init_knowledge_base();
-var import_node_fs10 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path11 = require("node:path");
 
 // src/planning/sprint-plan.ts
-var import_shared7 = require("@locusai/shared");
+var import_shared5 = require("@locusai/shared");
 function sprintPlanToMarkdown(plan) {
   const lines = [];
   lines.push(`# Sprint Plan: ${plan.name}`);
@@ -5450,32 +4759,25 @@ function sprintPlanToMarkdown(plan) {
   }
   lines.push(`## Tasks (${plan.tasks.length})`);
   lines.push("");
-  const maxTier = Math.max(0, ...plan.tasks.map((t) => t.tier ?? 0));
-  for (let tier = 0;tier <= maxTier; tier++) {
-    const tierTasks = plan.tasks.filter((t) => (t.tier ?? 0) === tier);
-    if (tierTasks.length === 0)
-      continue;
-    lines.push(`### Tier ${tier}${tier === 0 ? " (Foundation)" : ""}`);
-    lines.push(tier === 0 ? "_These tasks run first and must complete before higher tiers start._" : `_These tasks run in parallel after Tier ${tier - 1} completes._`);
+  lines.push("_Tasks are executed sequentially in the order listed below._");
+  lines.push("");
+  for (const task of plan.tasks) {
+    lines.push(`### ${task.index}. ${task.title}`);
+    lines.push(`- **Role:** ${task.assigneeRole}`);
+    lines.push(`- **Priority:** ${task.priority}`);
+    lines.push(`- **Complexity:** ${"█".repeat(task.complexity)}${"░".repeat(5 - task.complexity)} (${task.complexity}/5)`);
+    if (task.labels.length > 0) {
+      lines.push(`- **Labels:** ${task.labels.join(", ")}`);
+    }
     lines.push("");
-    for (const task of tierTasks) {
-      lines.push(`#### ${task.index}. ${task.title}`);
-      lines.push(`- **Role:** ${task.assigneeRole}`);
-      lines.push(`- **Priority:** ${task.priority}`);
-      lines.push(`- **Complexity:** ${"█".repeat(task.complexity)}${"░".repeat(5 - task.complexity)} (${task.complexity}/5)`);
-      if (task.labels.length > 0) {
-        lines.push(`- **Labels:** ${task.labels.join(", ")}`);
+    lines.push(task.description);
+    lines.push("");
+    if (task.acceptanceCriteria.length > 0) {
+      lines.push(`**Acceptance Criteria:**`);
+      for (const ac of task.acceptanceCriteria) {
+        lines.push(`- [ ] ${ac}`);
       }
       lines.push("");
-      lines.push(task.description);
-      lines.push("");
-      if (task.acceptanceCriteria.length > 0) {
-        lines.push(`**Acceptance Criteria:**`);
-        for (const ac of task.acceptanceCriteria) {
-          lines.push(`- [ ] ${ac}`);
-        }
-        lines.push("");
-      }
     }
   }
   if (plan.risks.length > 0) {
@@ -5496,13 +4798,12 @@ function plannedTasksToCreatePayloads(plan, sprintId) {
   return plan.tasks.map((task) => ({
     title: task.title,
     description: task.description,
-    status: import_shared7.TaskStatus.BACKLOG,
+    status: import_shared5.TaskStatus.BACKLOG,
     assigneeRole: task.assigneeRole,
     priority: task.priority,
     labels: task.labels,
     sprintId,
     order: task.index * 10,
-    tier: task.tier,
     acceptanceChecklist: task.acceptanceCriteria.map((text, i) => ({
       id: `ac-${i + 1}`,
       text,
@@ -5526,8 +4827,7 @@ function parseSprintPlanFromAI(raw, directive) {
     priority: t.priority || "MEDIUM",
     complexity: t.complexity || 3,
     acceptanceCriteria: t.acceptanceCriteria || [],
-    labels: t.labels || [],
-    tier: typeof t.tier === "number" ? t.tier : 0
+    labels: t.labels || []
   }));
   return {
     id,
@@ -5558,19 +4858,19 @@ class PlanManager {
   save(plan) {
     this.ensurePlansDir();
     const slug = this.slugify(plan.name);
-    const jsonPath = import_node_path12.join(this.plansDir, `${slug}.json`);
-    const mdPath = import_node_path12.join(this.plansDir, `sprint-${slug}.md`);
-    import_node_fs10.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
-    import_node_fs10.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
+    const jsonPath = import_node_path11.join(this.plansDir, `${slug}.json`);
+    const mdPath = import_node_path11.join(this.plansDir, `sprint-${slug}.md`);
+    import_node_fs9.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
+    import_node_fs9.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
     return plan.id;
   }
   load(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs9.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = import_node_path12.join(this.plansDir, file);
+      const filePath = import_node_path11.join(this.plansDir, file);
       try {
-        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs9.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
           return plan;
         }
@@ -5580,11 +4880,11 @@ class PlanManager {
   }
   list(status) {
     this.ensurePlansDir();
-    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs9.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     const plans = [];
     for (const file of files) {
       try {
-        const plan = JSON.parse(import_node_fs10.readFileSync(import_node_path12.join(this.plansDir, file), "utf-8"));
+        const plan = JSON.parse(import_node_fs9.readFileSync(import_node_path11.join(this.plansDir, file), "utf-8"));
         if (!status || plan.status === status) {
           plans.push(plan);
         }
@@ -5650,18 +4950,18 @@ class PlanManager {
   }
   delete(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs10.readdirSync(this.plansDir);
+    const files = import_node_fs9.readdirSync(this.plansDir);
     for (const file of files) {
-      const filePath = import_node_path12.join(this.plansDir, file);
+      const filePath = import_node_path11.join(this.plansDir, file);
       if (!file.endsWith(".json"))
         continue;
       try {
-        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs9.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
-          import_node_fs10.unlinkSync(filePath);
-          const mdPath = import_node_path12.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
-          if (import_node_fs10.existsSync(mdPath)) {
-            import_node_fs10.unlinkSync(mdPath);
+          import_node_fs9.unlinkSync(filePath);
+          const mdPath = import_node_path11.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
+          if (import_node_fs9.existsSync(mdPath)) {
+            import_node_fs9.unlinkSync(mdPath);
           }
           return;
         }
@@ -5675,8 +4975,8 @@ class PlanManager {
     return sprintPlanToMarkdown(plan);
   }
   ensurePlansDir() {
-    if (!import_node_fs10.existsSync(this.plansDir)) {
-      import_node_fs10.mkdirSync(this.plansDir, { recursive: true });
+    if (!import_node_fs9.existsSync(this.plansDir)) {
+      import_node_fs9.mkdirSync(this.plansDir, { recursive: true });
     }
   }
   slugify(name) {
@@ -5686,7 +4986,7 @@ class PlanManager {
 // src/planning/planning-meeting.ts
 init_config();
 init_knowledge_base();
-var import_node_fs11 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 
 // src/planning/agents/architect.ts
 function buildArchitectPrompt(input) {
@@ -5723,21 +5023,14 @@ Review and refine the Tech Lead's breakdown:
 5. **Missing Tasks** — Add any tasks the Tech Lead missed (database migrations, configuration, testing, etc.).
 6. **Description Quality** — Review and improve each task description to be a clear, actionable implementation guide. Each description must tell the executing agent exactly what to do, where to do it (specific files/modules), how to do it (patterns, utilities, data flow), and what is NOT in scope. Vague descriptions like "Add authentication" must be rewritten with specific file paths, implementation approach, and boundaries.
 
-## CRITICAL: Task Isolation & Overlap Detection
+## CRITICAL: Task Ordering & Dependencies
 
-Tasks are executed by INDEPENDENT agents on SEPARATE git branches that get merged together. Each agent has NO knowledge of what other agents are doing. You MUST enforce these rules:
+Tasks are executed SEQUENTIALLY by a single agent on ONE branch. The agent works through tasks in array order. Each completed task's changes are available to subsequent tasks. You MUST enforce these rules:
 
-1. **Detect overlapping file modifications.** For each task, mentally list the files it will touch. If two tasks modify the same file (especially config files like app.module.ts, configuration.ts, package.json, or shared modules), they WILL cause merge conflicts. You must either:
-   - **Merge them** into a single task, OR
-   - **Move the shared file changes** into one foundational task that runs and merges first
-
-2. **Detect duplicated work.** If two tasks both introduce the same environment variable, config field, dependency, helper function, or module registration — that is duplicated work. Consolidate it into ONE task.
-
-3. **Do NOT split tasks that share code changes.** Even if a task is large, do NOT split it if the subtasks would both need to modify the same files. A single larger self-contained task is far better than two smaller conflicting tasks. Only split tasks when the parts are truly independent (touch completely different files and modules).
-
-4. **Validate self-containment.** Each task must include ALL changes it needs to function: config, schema, module registration, implementation, and tests. A task must NOT assume another concurrent task will provide something it needs.
-
-5. **Flag high-conflict zones.** In your risk assessment, specifically call out any remaining cases where tasks might touch the same files, and explain why it's unavoidable and how merge conflicts can be minimized.
+1. **Order tasks by dependency.** Foundation tasks (schemas, config, shared code) must come first. Tasks that build on earlier work must appear later in the list.
+2. **Each task must be self-contained for its scope.** A task can depend on earlier tasks (they run sequentially), but must include all changes needed for its own goal.
+3. **Split tasks at logical boundaries.** Since tasks run sequentially on the same branch, splitting is safe — later tasks see earlier changes. Split when it improves clarity and reviewability.
+4. **Flag risks.** In your risk assessment, call out tasks that are complex or have unknowns.
 
 ## Output Format
 
@@ -5771,20 +5064,20 @@ Your entire response must be a single JSON object — no text before it, no text
 function buildCrossTaskReviewerPrompt(input) {
   let prompt = `# Role: Cross-Task Reviewer (Architect + Engineer + Planner)
 
-You are a combined Architect, Senior Engineer, and Sprint Planner performing a FINAL review of a sprint plan. Your sole focus is ensuring that tasks are fully isolated and will not conflict when executed by independent agents on separate git branches.
+You are a combined Architect, Senior Engineer, and Sprint Planner performing a FINAL review of a sprint plan. Your focus is ensuring that tasks are correctly ordered, well-scoped, and will execute successfully in sequence.
 
 ## Context
 
-In this system, tasks are organized into execution **tiers** (0, 1, 2, ...):
-- All tasks within the same tier run IN PARALLEL on separate git branches (worktrees)
-- Agents within a tier have NO knowledge of what other agents in that tier are doing
-- After ALL tasks in tier N complete and merge, tier N+1 starts
-- Tier N+1 branches are created FROM the merged tier N result, so they can see tier N's work
+In this system, tasks are executed SEQUENTIALLY by a single agent on ONE branch:
+- Tasks run one at a time, in the order they appear in the array
+- Each task's changes are committed before the next task starts
+- Later tasks can see and build on earlier tasks' work
+- The final result is a single branch with all changes, which becomes a pull request
 
 This means:
-- Two tasks in the SAME tier that modify the same file WILL cause merge conflicts
-- Two tasks in DIFFERENT tiers are safe — the later tier sees the earlier tier's merged output
-- Tier assignment is critical: foundational work must be in tier 0, dependent work in higher tiers
+- Task ordering is critical — a task must NOT depend on a later task's output
+- Foundation work (config, schemas, shared code) must come first
+- Each task should be a focused, logical unit of work
 
 ## CEO Directive
 > ${input.directive}
@@ -5806,41 +5099,21 @@ ${input.sprintOrganizerOutput}
 
 ## Your Review Checklist
 
-Go through EACH pair of tasks and check for:
-
-### 1. File Overlap Analysis (WITHIN the same tier)
-For each task, list the files it will likely modify. Then check:
-- Do any two tasks **in the same tier** modify the same file? (e.g., app.module.ts, configuration.ts, package.json, shared DTOs)
-- If yes: MERGE those tasks, move them to different tiers, or move shared changes to a foundational task in a lower tier
-- Note: tasks in different tiers are safe because higher tiers branch from merged lower-tier results
+Go through EACH task and check for:
 
-### 2. Duplicated Work Detection (WITHIN the same tier)
-Check if multiple tasks **in the same tier**:
-- Add the same environment variable or config field
-- Install or configure the same dependency
-- Register the same module or provider
-- Create the same helper function, guard, interceptor, or middleware
-- Add the same import to a shared file
-If yes: consolidate into ONE task or move the shared work to a lower tier
+### 1. Ordering & Dependency Analysis
+For each task, verify:
+- Does it depend on any task that appears LATER in the list? If so, reorder.
+- Are foundational tasks (config, schemas, shared code) at the beginning?
+- Is the overall execution order logical?
 
-### 3. Self-Containment Validation
+### 2. Scope & Completeness
 For each task, verify:
-- Does it include ALL config/env changes it needs?
-- Does it include ALL module registrations it needs?
-- Does it include ALL dependency installations it needs?
-- Can it be completed without ANY output from tasks in the SAME tier? (It CAN depend on lower-tier tasks that are already merged)
-
-### 4. Tier Assignment Validation
-Verify tier assignments are correct:
-- Foundational tasks (schemas, config, shared code) MUST be in tier 0
-- Tasks that depend on another task's output must be in a HIGHER tier
-- Tasks in the same tier must be truly independent of each other
-- No circular dependencies between tiers
-
-### 5. Merge Conflict Risk Zones
-Identify the highest-risk files (files that multiple same-tier tasks might touch) and ensure only ONE task per tier modifies each.
-
-### 6. Description Quality Validation
+- Is the task well-scoped? Not too large, not too trivial?
+- Does it include ALL changes needed for its goal (given earlier tasks are done)?
+- Are there any missing tasks that should be added?
+
+### 3. Description Quality Validation
 For each task, verify the description is a clear, actionable implementation guide. Each description must specify:
 - **What to do** — the specific goal and expected behavior/outcome
 - **Where to do it** — specific files, modules, or directories to modify or create
@@ -5849,6 +5122,10 @@ For each task, verify the description is a clear, actionable implementation guid
 
 If any description is vague (e.g., "Add authentication", "Update the API", "Fix the frontend"), rewrite it with concrete implementation details. The executing agent receives ONLY the task title, description, and acceptance criteria as its instructions.
 
+### 4. Risk Assessment
+- Are there tasks that might fail or have unknowns?
+- Is the sprint scope realistic for sequential execution?
+
 ## Output Format
 
 Your entire response must be a single JSON object — no text before it, no text after it, no markdown code blocks, no explanation. Start your response with the "{" character:
@@ -5857,10 +5134,10 @@ Your entire response must be a single JSON object — no text before it, no text
   "hasIssues": true | false,
   "issues": [
     {
-      "type": "file_overlap" | "duplicated_work" | "not_self_contained" | "merge_conflict_risk" | "wrong_tier" | "vague_description",
+      "type": "wrong_order" | "missing_task" | "scope_issue" | "vague_description",
       "description": "string describing the specific issue",
       "affectedTasks": ["Task Title 1", "Task Title 2"],
-      "resolution": "string describing how to fix it (merge, move to different tier, consolidate)"
+      "resolution": "string describing how to fix it"
     }
   ],
   "revisedPlan": {
@@ -5875,8 +5152,7 @@ Your entire response must be a single JSON object — no text before it, no text
         "priority": "CRITICAL | HIGH | MEDIUM | LOW",
         "labels": ["string"],
         "acceptanceCriteria": ["string"],
-        "complexity": 3,
-        "tier": 0
+        "complexity": 3
       }
     ],
     "risks": [
@@ -5890,15 +5166,11 @@ Your entire response must be a single JSON object — no text before it, no text
 }
 
 IMPORTANT:
-- If hasIssues is true, the revisedPlan MUST contain the corrected task list with issues resolved (tasks merged, duplicated work consolidated, tier assignments fixed, etc.)
+- If hasIssues is true, the revisedPlan MUST contain the corrected task list with issues resolved (reordered, descriptions rewritten, missing tasks added, etc.)
 - If hasIssues is false, the revisedPlan should be identical to the input plan (no changes needed)
 - The revisedPlan is ALWAYS required — it becomes the final plan
-- When merging tasks, combine their acceptance criteria and update descriptions to cover all consolidated work
 - Ensure every task description is a detailed implementation guide (what, where, how, boundaries) — rewrite vague descriptions
-- Prefer fewer, larger, self-contained tasks over many small conflicting ones
-- Every task MUST have a "tier" field (integer >= 0)
-- tier 0 = foundational (runs first), tier 1 = depends on tier 0, tier 2 = depends on tier 1, etc.
-- Tasks within the same tier run in parallel — they MUST NOT conflict with each other`;
+- Tasks execute sequentially — the array order IS the execution order`;
   return prompt;
 }
 
@@ -5929,30 +5201,27 @@ Produce the final sprint plan:
 
 1. **Sprint Name** — A concise, memorable name for this sprint (e.g., "User Authentication", "Payment Integration")
 2. **Sprint Goal** — One paragraph describing what this sprint delivers
-3. **Task Ordering** — Final ordering so that foundational work comes first. The position in the array IS the execution order — task at index 0 runs first, index 1 runs second, etc.
-4. **Tier Assignment** — Assign each task an execution tier (integer, starting at 0). Tasks within the same tier run IN PARALLEL on separate git branches. Tasks in tier N+1 only start AFTER all tier N tasks are complete and merged. Tier 0 = foundational tasks (config, schemas, shared code). Higher tiers build on lower tier outputs.
-5. **Duration Estimate** — How many days this sprint will take with 2-3 agents working in parallel
-6. **Final Task List** — Each task with all fields filled in, ordered by execution priority
-7. **Description Quality Check** — Ensure every task description is a clear, actionable implementation guide. Each description must specify: what to do, where to do it (specific files/modules/directories), how to do it (implementation approach, patterns to follow, existing utilities to use), and what is NOT in scope. If any description is vague or generic, rewrite it with specifics. Remember: an independent agent will receive ONLY the task title, description, and acceptance criteria — the description is its primary instruction.
+3. **Task Ordering** — Final ordering so that foundational work comes first. The position in the array IS the execution order — task at index 0 runs first, index 1 runs second, etc. Tasks are executed SEQUENTIALLY by a single agent on one branch.
+4. **Duration Estimate** — How many days this sprint will take with a single agent working sequentially
+5. **Final Task List** — Each task with all fields filled in, ordered by execution priority
+6. **Description Quality Check** — Ensure every task description is a clear, actionable implementation guide. Each description must specify: what to do, where to do it (specific files/modules/directories), how to do it (implementation approach, patterns to follow, existing utilities to use), and what is NOT in scope. If any description is vague or generic, rewrite it with specifics. Remember: an independent agent will receive ONLY the task title, description, and acceptance criteria — the description is its primary instruction.
 
 Guidelines:
 - The order of tasks in the array determines execution order. Tasks are dispatched sequentially from first to last.
-- Foundation tasks (schemas, config, shared code) must appear before tasks that build on them AND must be in tier 0
-- Tasks within the same tier MUST be truly independent — no shared file modifications, no dependencies between them
-- Tasks that depend on outputs from other tasks must be in a higher tier than those dependencies
-- Group related independent tasks in the same tier for maximum parallelism
+- Foundation tasks (schemas, config, shared code) must appear before tasks that build on them
+- Since tasks execute sequentially on one branch, later tasks can depend on earlier tasks' outputs
 - Ensure acceptance criteria are specific and testable
 - Keep the sprint focused — if it's too large (>12 tasks), consider reducing scope
 - Ensure every task description reads as a standalone implementation brief — not a summary
 
-## CRITICAL: Task Isolation Validation
+## CRITICAL: Task Ordering Validation
 
-Before finalizing, validate that EVERY task is fully self-contained and conflict-free:
+Before finalizing, validate that tasks are in the correct execution order:
 
-1. **No two tasks should modify the same file.** If they do, merge them or restructure so shared changes live in one foundational task.
-2. **No duplicated work.** Each env var, config field, dependency, module import, or helper function must be introduced by exactly ONE task.
-3. **Each task is independently executable within its tier.** An agent working on a task must be able to complete it without knowing what other tasks in the same tier are doing. Tasks CAN depend on lower-tier tasks since those are merged before the current tier starts.
-4. **Prefer fewer, larger self-contained tasks over many small overlapping ones.** Do not split a task if the parts would conflict with each other.
+1. **No forward dependencies.** A task must NOT depend on a task that appears later in the list.
+2. **Foundation first.** Config, schemas, and shared code must come before implementation tasks.
+3. **Each task is independently executable given prior tasks.** An agent working on task N must be able to complete it assuming tasks 1 through N-1 are already done.
+4. **Prefer focused, well-scoped tasks.** Each task should do one logical unit of work.
 
 ## Output Format
 
@@ -5970,8 +5239,7 @@ Your entire response must be a single JSON object — no text before it, no text
       "priority": "CRITICAL | HIGH | MEDIUM | LOW",
       "labels": ["string"],
       "acceptanceCriteria": ["string"],
-      "complexity": 3,
-      "tier": 0
+      "complexity": 3
     }
   ],
   "risks": [
@@ -5983,12 +5251,7 @@ Your entire response must be a single JSON object — no text before it, no text
   ]
 }
 
-IMPORTANT about tiers:
-- tier 0 = foundational tasks (run first, merged before anything else)
-- tier 1 = tasks that depend on tier 0 outputs (run in parallel after tier 0 merges)
-- tier 2 = tasks that depend on tier 1 outputs (run in parallel after tier 1 merges)
-- Tasks within the same tier run in parallel on separate branches — they MUST NOT conflict
-- Every task MUST have a "tier" field (integer >= 0)`;
+IMPORTANT: Tasks are executed sequentially by a single agent. The array order IS the execution order — ensure foundational work comes first and dependent tasks come after their prerequisites.`;
   return prompt;
 }
 
@@ -6046,15 +5309,14 @@ Each description MUST include:
 Bad example: "Add authentication to the API."
 Good example: "Implement JWT-based authentication middleware in src/middleware/auth.ts. Create a verifyToken middleware that extracts the Bearer token from the Authorization header, validates it using the existing JWT_SECRET from env config, and attaches the decoded user payload to req.user. Apply this middleware to all routes in src/routes/protected/. Add a POST /auth/login endpoint in src/routes/auth.ts that accepts {email, password}, validates credentials against the users table, and returns a signed JWT. This task does NOT include user registration or password reset — those are handled separately."
 
-## CRITICAL: Task Isolation Rules
+## CRITICAL: Task Ordering Rules
 
-Tasks will be executed by INDEPENDENT agents on SEPARATE git branches that get merged together. Each agent has NO knowledge of what other agents are doing. Therefore:
+Tasks are executed SEQUENTIALLY by a single agent on ONE branch. The agent works through tasks in the order they appear in the array. Therefore:
 
-1. **No shared work across tasks.** If two tasks both need the same config variable, helper function, database migration, or module setup, that shared work MUST be consolidated into ONE task (or placed into a dedicated foundational task that runs first and is merged before others start).
-2. **Each task must be fully self-contained.** A task must include ALL the code changes it needs to work — from config to implementation to tests. It should NOT assume that another task in the same sprint will create something it depends on.
-3. **Do NOT split tasks if they share code changes.** If implementing feature A and feature B both require modifying the same file or adding the same dependency/config, they should be ONE task — even if that makes the task larger. A bigger self-contained task is better than two smaller conflicting tasks.
-4. **Think about file-level conflicts.** Two tasks modifying the same file (e.g., app.module.ts, configuration.ts, package.json) will cause git merge conflicts. Minimize this by bundling related changes together.
-5. **Environment variables, configs, and shared modules are high-conflict zones.** If a task introduces a new env var, config schema field, or module import, NO other task should touch that same file unless absolutely necessary.
+1. **Foundation first.** Place foundational tasks (schemas, config, shared code) at the beginning of the list. Later tasks can build on earlier ones since they run in sequence on the same branch.
+2. **Each task must be self-contained.** A task must include ALL the code changes it needs to work — from config to implementation to tests. A task CAN depend on earlier tasks in the list since they will have already been completed.
+3. **Logical ordering matters.** Tasks are dispatched in the order they appear. Ensure dependent tasks come after their prerequisites.
+4. **Keep tasks focused.** Each task should do one logical unit of work. Since there are no parallel execution conflicts, tasks can be more granular — but avoid tasks that are too small or trivial.
 
 ## Output Format
 
@@ -6146,11 +5408,11 @@ class PlanningMeeting {
   }
   getCodebaseIndex() {
     const indexPath = getLocusPath(this.projectPath, "indexFile");
-    if (!import_node_fs11.existsSync(indexPath)) {
+    if (!import_node_fs10.existsSync(indexPath)) {
       return "";
     }
     try {
-      const raw = import_node_fs11.readFileSync(indexPath, "utf-8");
+      const raw = import_node_fs10.readFileSync(indexPath, "utf-8");
       const index = JSON.parse(raw);
       const parts = [];
       if (index.responsibilities) {
@@ -6173,7 +5435,3 @@ class PlanningMeeting {
 // src/index-node.ts
 init_knowledge_base();
 init_colors();
-
-// src/worktree/index.ts
-init_worktree_config();
-init_worktree_manager();