@locusai/cli 0.10.6 → 0.11.0

package/bin/agent/worker.js

@@ -14611,8 +14611,7 @@ var init_task = __esm(() => {
     comments: exports_external.array(CommentSchema).optional(),
     activityLog: exports_external.array(EventSchema).optional(),
     docs: exports_external.array(DocSchema),
-    order: exports_external.number().optional(),
-    tier: exports_external.number().int().min(0).optional()
+    order: exports_external.number().optional()
   });
   CreateTaskSchema = exports_external.object({
     title: exports_external.string().min(1, "Title is required").max(200),
@@ -14627,8 +14626,7 @@ var init_task = __esm(() => {
     sprintId: exports_external.string().nullable().optional(),
     acceptanceChecklist: exports_external.array(AcceptanceItemSchema).optional(),
     docIds: exports_external.array(exports_external.string()).optional(),
-    order: exports_external.number().optional(),
-    tier: exports_external.number().int().min(0).optional()
+    order: exports_external.number().optional()
   });
   UpdateTaskSchema = TaskSchema.partial().omit({
     id: true,
@@ -31378,588 +31376,252 @@ var init_knowledge_base = __esm(() => {
   init_config();
 });
 
-// ../sdk/src/git/pr-service.ts
+// ../sdk/src/agent/git-workflow.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 
-class PrService {
-  projectPath;
+class GitWorkflow {
+  config;
   log;
-  constructor(projectPath, log) {
-    this.projectPath = projectPath;
+  projectPath;
+  branchName = null;
+  baseBranch = null;
+  ghUsername;
+  constructor(config2, log) {
+    this.config = config2;
     this.log = log;
-  }
-  createPr(options) {
-    const {
-      task: task2,
-      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] ${task2.title}`;
-    const body = this.buildPrBody(task2, agentId, summary);
-    const baseBranch = requestedBaseBranch ?? getDefaultBranch(this.projectPath);
-    this.validateCreatePrInputs(baseBranch, branch);
-    this.log(`Creating PR: ${title} (${branch} → ${baseBranch})`, "info");
-    const output = execFileSync2("gh", [
-      "pr",
-      "create",
-      "--title",
-      title,
-      "--body",
-      body,
-      "--base",
-      baseBranch,
-      "--head",
-      branch
-    ], {
-      cwd: this.projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const url3 = output;
-    const prNumber = this.extractPrNumber(url3);
-    this.log(`PR created: ${url3}`, "success");
-    return { url: url3, 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.`);
+    this.projectPath = config2.projectPath || process.cwd();
+    this.ghUsername = getGhUsername();
+    if (this.ghUsername) {
+      this.log(`GitHub user: ${this.ghUsername}`, "info");
     }
   }
-  countCommitsAhead(baseRef, headRef) {
-    const output = execFileSync2("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 {
-      execFileSync2("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(task2) {
+    if (!this.branchName) {
+      this.log("No branch created yet, skipping commit", "warn");
+      return { branch: null, pushed: false, pushFailed: false };
+    }
     try {
-      execFileSync2("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: ${task2.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): ${task2.title}
+
+${trailers.join(`
+`)}`;
+      this.gitExec(["commit", "-m", commitMessage]);
+      const hash2 = this.gitExec(["rev-parse", "HEAD"]).trim();
+      this.log(`Committed: ${hash2.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 {
-      execFileSync2("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 (error48) {
+      const msg = error48 instanceof Error ? error48.message : String(error48);
+      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 execFileSync2("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 {
-      execFileSync2("gh", [
+      const output = execFileSync2("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")) {
-        execFileSync2("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 = execFileSync2("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 = execFileSync2("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(task2, agentId, summary) {
+  buildPrBody(completedTasks, summaries) {
     const sections = [];
-    sections.push(`## Task: ${task2.title}`);
+    sections.push("## Completed Tasks");
     sections.push("");
-    if (task2.description) {
-      sections.push(task2.description);
-      sections.push("");
-    }
-    if (task2.acceptanceChecklist?.length > 0) {
-      sections.push("## Acceptance Criteria");
-      for (const item of task2.acceptanceChecklist) {
-        sections.push(`- [ ] ${item.text}`);
+    for (let i = 0;i < completedTasks.length; i++) {
+      const task2 = completedTasks[i];
+      sections.push(`### ${i + 1}. ${task2.title}`);
+      sections.push(`Task ID: \`${task2.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: \`${task2.id}\``);
+    sections.push(`*Created by Locus Agent \`${this.config.agentId.slice(-8)}\`*`);
     return sections.join(`
 `);
   }
-  extractPrNumber(url3) {
-    const match = url3.match(/\/pull\/(\d+)/);
-    return match ? Number.parseInt(match[1], 10) : 0;
-  }
-}
-var init_pr_service = __esm(() => {
-  init_git_utils();
-});
-
-// ../sdk/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"
-  };
-});
-
-// ../sdk/src/worktree/worktree-manager.ts
-import { execFileSync as execFileSync3, execSync } from "node:child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, rmSync, statSync } from "node:fs";
-import { join as join4, resolve as resolve2, sep } from "node:path";
-
-class WorktreeManager {
-  config;
-  projectPath;
-  log;
-  constructor(projectPath, config2, log) {
-    this.projectPath = resolve2(projectPath);
-    this.config = { ...DEFAULT_WORKTREE_CONFIG, ...config2 };
-    this.log = log ?? ((_msg) => {
-      return;
-    });
-  }
-  get rootPath() {
-    return join4(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 = join4(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 (existsSync4(worktreePath)) {
-      this.log(`Removing stale worktree directory: ${worktreePath}`, "warn");
-      try {
-        this.git(`worktree remove "${worktreePath}" --force`, this.projectPath);
-      } catch {
-        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 = resolve2(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 (error48) {
-      if (!this.isMissingDirectoryError(error48)) {
-        throw error48;
-      }
-      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 (resolve2(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 = resolve2(worktreePath);
-    const worktrees = this.list();
-    const worktree = worktrees.find((wt) => resolve2(wt.path) === absolutePath);
-    const branchToDelete = worktree?.branch;
-    this.log(`Removing worktree: ${absolutePath}`, "info");
-    try {
-      this.git(`worktree remove "${absolutePath}" --force`, this.projectPath);
-    } catch {
-      if (existsSync4(absolutePath)) {
-        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 (existsSync4(this.rootPath)) {
-      try {
-        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 hash3 = this.git("rev-parse HEAD", worktreePath).trim();
-        this.log(`Agent already committed changes (${hash3.slice(0, 8)}); skipping additional commit`, "info");
-        return hash3;
-      }
-      if (baseCommitHash && this.hasCommitsAheadOfHash(worktreePath, baseCommitHash)) {
-        const hash3 = this.git("rev-parse HEAD", worktreePath).trim();
-        this.log(`Agent already committed changes (${hash3.slice(0, 8)}, detected via base commit hash); skipping additional commit`, "info");
-        return hash3;
-      }
-      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 hash2 = this.git("rev-parse HEAD", worktreePath).trim();
-    this.log(`Committed: ${hash2.slice(0, 8)}`, "success");
-    return hash2;
-  }
-  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 (error48) {
-      if (!this.isNonFastForwardPushError(error48)) {
-        throw error48;
-      }
-      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 = resolve2(this.rootPath);
-    const candidate = resolve2(worktreePath);
-    const rootWithSep = rootPath.endsWith(sep) ? rootPath : `${rootPath}${sep}`;
-    return candidate.startsWith(rootWithSep);
-  }
-  ensureDirectory(dirPath, label) {
-    if (existsSync4(dirPath)) {
-      if (!statSync(dirPath).isDirectory()) {
-        throw new Error(`${label} exists but is not a directory: ${dirPath}`);
-      }
-      return;
-    }
-    mkdirSync2(dirPath, { recursive: true });
-  }
-  isMissingDirectoryError(error48) {
-    const message = error48 instanceof Error ? error48.message : String(error48);
-    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 (existsSync4(worktreePath)) {
-      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(error48) {
-    const message = error48 instanceof Error ? error48.message : String(error48);
-    return message.includes("non-fast-forward") || message.includes("[rejected]") || message.includes("fetch first");
-  }
-  git(args, cwd) {
-    return execSync(`git ${args}`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  }
-  gitExec(args, cwd) {
-    return execFileSync3("git", args, {
-      cwd,
+  gitExec(args) {
+    return execFileSync2("git", args, {
+      cwd: this.projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
   }
 }
-var init_worktree_manager = __esm(() => {
-  init_worktree_config();
+var init_git_workflow = __esm(() => {
+  init_git_utils();
 });
 
 // ../sdk/src/core/prompt-builder.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "node:fs";
+import { join as join4 } from "node:path";
 
 class PromptBuilder {
   projectPath;
@@ -32001,7 +31663,7 @@ ${task2.description || "No description provided."}
     }
     const contextPath = getLocusPath(this.projectPath, "contextFile");
     let hasLocalContext = false;
-    if (existsSync5(contextPath)) {
+    if (existsSync4(contextPath)) {
       try {
         const context = readFileSync4(contextPath, "utf-8");
         if (context.trim().length > 20) {
@@ -32057,7 +31719,7 @@ ${serverContext.context}
 
 `;
     const indexPath = getLocusPath(this.projectPath, "indexFile");
-    if (existsSync5(indexPath)) {
+    if (existsSync4(indexPath)) {
       prompt += `## Codebase Overview
 There is an index file in the .locus/codebase-index.json and if you need you can check it.
 
@@ -32134,7 +31796,7 @@ ${query}
     }
     const contextPath = getLocusPath(this.projectPath, "contextFile");
     let hasLocalContext = false;
-    if (existsSync5(contextPath)) {
+    if (existsSync4(contextPath)) {
       try {
         const context = readFileSync4(contextPath, "utf-8");
         if (context.trim().length > 20) {
@@ -32170,7 +31832,7 @@ ${fallback}
 
 `;
     const indexPath = getLocusPath(this.projectPath, "indexFile");
-    if (existsSync5(indexPath)) {
+    if (existsSync4(indexPath)) {
       prompt += `## Codebase Overview
 There is an index file in the .locus/codebase-index.json and if you need you can check it.
 
@@ -32185,7 +31847,7 @@ 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 (existsSync5(configPath)) {
+    if (existsSync4(configPath)) {
       try {
         return JSON.parse(readFileSync4(configPath, "utf-8"));
       } catch {
@@ -32195,8 +31857,8 @@ There is an index file in the .locus/codebase-index.json and if you need you can
     return null;
   }
   getFallbackContext() {
-    const readmePath = join5(this.projectPath, "README.md");
-    if (existsSync5(readmePath)) {
+    const readmePath = join4(this.projectPath, "README.md");
+    if (existsSync4(readmePath)) {
       try {
         const content = readFileSync4(readmePath, "utf-8");
         const limit = 1000;
@@ -32215,7 +31877,7 @@ There is an index file in the .locus/codebase-index.json and if you need you can
         if (e.startsWith(".") || e === "node_modules")
           return false;
         try {
-          return statSync2(join5(this.projectPath, e)).isDirectory();
+          return statSync(join4(this.projectPath, e)).isDirectory();
         } catch {
           return false;
         }
@@ -32300,162 +31962,6 @@ var init_task_executor = __esm(() => {
   init_prompt_builder();
 });
 
-// ../sdk/src/agent/git-workflow.ts
-class GitWorkflow {
-  config;
-  log;
-  ghUsername;
-  worktreeManager;
-  prService;
-  constructor(config2, log, ghUsername) {
-    this.config = config2;
-    this.log = log;
-    this.ghUsername = ghUsername;
-    const projectPath = config2.projectPath || process.cwd();
-    this.worktreeManager = config2.useWorktrees ? new WorktreeManager(projectPath, { cleanupPolicy: "auto" }, log) : null;
-    this.prService = config2.autoPush ? new PrService(projectPath, log) : null;
-  }
-  createTaskWorktree(task2, defaultExecutor) {
-    if (!this.worktreeManager) {
-      return {
-        worktreePath: null,
-        baseBranch: null,
-        baseCommitHash: null,
-        executor: defaultExecutor
-      };
-    }
-    const slug = task2.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-    const result = this.worktreeManager.create({
-      taskId: task2.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, task2, baseBranch, baseCommitHash) {
-    if (!this.worktreeManager) {
-      return { branch: null, pushed: false, pushFailed: false };
-    }
-    try {
-      const trailers = [
-        `Task-ID: ${task2.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): ${task2.title}
-
-${trailers.join(`
-`)}`;
-      const hash2 = this.worktreeManager.commitChanges(worktreePath, commitMessage, baseBranch, baseCommitHash);
-      if (!hash2) {
-        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(task2, 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: task2,
-        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();
-});
-
 // ../sdk/src/agent/worker-cli.ts
 var exports_worker_cli = {};
 __export(exports_worker_cli, {
@@ -32488,16 +31994,8 @@ function parseWorkerArgs(argv) {
       config2.apiKey = args[++i];
     else if (arg === "--project-path")
       config2.projectPath = args[++i];
-    else if (arg === "--main-project-path")
-      config2.mainProjectPath = args[++i];
     else if (arg === "--model")
       config2.model = args[++i];
-    else if (arg === "--use-worktrees")
-      config2.useWorktrees = true;
-    else if (arg === "--auto-push")
-      config2.autoPush = true;
-    else if (arg === "--base-branch")
-      config2.baseBranch = args[++i];
     else if (arg === "--provider") {
       const value = args[i + 1];
       if (value && !value.startsWith("--"))
@@ -32539,8 +32037,8 @@ class AgentWorker {
   tasksCompleted = 0;
   heartbeatInterval = null;
   currentTaskId = null;
-  currentWorktreePath = null;
-  postCleanupDelayMs = 5000;
+  completedTaskList = [];
+  taskSummaries = [];
   constructor(config2) {
     this.config = config2;
     const projectPath = config2.projectPath || process.cwd();
@@ -32555,17 +32053,12 @@ class AgentWorker {
       }
     });
     const log = this.log.bind(this);
-    if (config2.useWorktrees && !isGitAvailable()) {
-      this.log("git is not installed — worktree isolation will not work", "error");
-      config2.useWorktrees = false;
+    if (!isGitAvailable()) {
+      this.log("git is not installed — branch management will not work", "error");
     }
-    if (config2.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 = config2.autoPush ? getGhUsername() : null;
-    if (ghUsername) {
-      this.log(`GitHub user: ${ghUsername}`, "info");
-    }
     const provider = config2.provider ?? PROVIDER.CLAUDE;
     this.aiRunner = createAiRunner(provider, {
       projectPath,
@@ -32578,18 +32071,9 @@ class AgentWorker {
       log
     });
     this.knowledgeBase = new KnowledgeBase(projectPath);
-    this.gitWorkflow = new GitWorkflow(config2, log, ghUsername);
+    this.gitWorkflow = new GitWorkflow(config2, log);
     const providerLabel = provider === "codex" ? "Codex" : "Claude";
     this.log(`Using ${providerLabel} CLI for all phases`, "info");
-    if (config2.useWorktrees) {
-      this.log("Per-task worktree isolation enabled", "info");
-      if (config2.baseBranch) {
-        this.log(`Base branch for worktrees: ${config2.baseBranch}`, "info");
-      }
-      if (config2.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) ?? "";
@@ -32638,56 +32122,26 @@ class AgentWorker {
   }
   async executeTask(task2) {
     const fullTask = await this.client.tasks.getById(task2.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(task2, summary) {
@@ -32720,19 +32174,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);
@@ -32744,10 +32192,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 task2 = await this.getNextTask();
       if (!task2) {
-        this.log("No more tasks to process. Exiting.", "info");
+        this.log("No more tasks to process.", "info");
         break;
       }
       this.log(`Claimed: ${task2.title}`, "success");
@@ -32763,7 +32213,7 @@ class AgentWorker {
           });
           await this.client.tasks.addComment(task2.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}`
           });
@@ -32772,22 +32222,17 @@ ${result.summary}`
           const updatePayload = {
             status: "IN_REVIEW" /* IN_REVIEW */
           };
-          if (result.prUrl) {
-            updatePayload.prUrl = result.prUrl;
-          }
           await this.client.tasks.update(task2.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(task2.id, this.config.workspaceId, {
             author: this.config.agentId,
-            text: `✅ ${result.summary}${branchInfo}${prInfo}${prErrorInfo}`
+            text: `✅ ${result.summary}${branchInfo}`
           });
           this.tasksCompleted++;
+          this.completedTaskList.push({ title: task2.title, id: task2.id });
+          this.taskSummaries.push(result.summary);
           this.updateProgress(task2, result.summary);
         }
       } else {
@@ -32803,8 +32248,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 task2 of this.completedTaskList) {
+          try {
+            await this.client.tasks.update(task2.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(() => {});