@locusai/cli 0.24.6 → 0.24.9

package/bin/locus.js

@@ -39,8 +39,7 @@ var init_dist = __esm(() => {
       rebaseBeforeTask: true
     },
     sprint: {
-      active: null,
-      stopOnFailure: true
+      stopOnFailure: false
     },
     logging: {
       level: "normal",
@@ -3278,7 +3277,6 @@ ${bold2("Locus Configuration")}
     {
       title: "Sprint",
       entries: [
-        ["Active", config.sprint.active ?? dim2("(none)")],
         ["Stop on Failure", String(config.sprint.stopOnFailure)]
       ]
     },
@@ -7013,9 +7011,6 @@ async function sprintCommand(projectRoot, args) {
     case "show":
       await sprintShow(projectRoot, parsed);
       break;
-    case "active":
-      await sprintActive(projectRoot, parsed);
-      break;
     case "order":
       await sprintOrder(projectRoot, parsed);
       break;
@@ -7056,8 +7051,6 @@ async function sprintCreate(projectRoot, parsed) {
       process.stderr.write(`  Due: ${parsed.flags.due}
 `);
     }
-    process.stderr.write(`  Set as active sprint: ${bold2(`locus sprint active "${title}"`)}
-`);
   } catch (e) {
     process.stderr.write(`\r${red2("✗")} Failed to create sprint: ${e.message}
 `);
@@ -7067,8 +7060,6 @@ async function sprintCreate(projectRoot, parsed) {
 async function sprintList(projectRoot, parsed) {
   const config = loadConfig(projectRoot);
   const { owner, repo } = config.github;
-  const activeSprint = config.sprint.active;
-  const normalizedActiveSprint = activeSprint ? normalizeMilestoneTitle(activeSprint) : null;
   const state = parsed.flags.all ? "all" : "open";
   process.stderr.write(`${cyan2("●")} Fetching sprints...`);
   let milestones;
@@ -7094,16 +7085,10 @@ async function sprintList(projectRoot, parsed) {
 
 `);
   const columns = [
-    {
-      key: "active",
-      header: " ",
-      minWidth: 2,
-      format: (_, row) => normalizedActiveSprint !== null && normalizeMilestoneTitle(String(row.title)) === normalizedActiveSprint ? green("●") : " "
-    },
     {
       key: "title",
       header: "Sprint",
-      format: (v, row) => normalizedActiveSprint !== null && normalizeMilestoneTitle(String(row.title)) === normalizedActiveSprint ? bold2(green(String(v))) : bold2(String(v))
+      format: (v) => bold2(String(v))
     },
     {
       key: "progress",
@@ -7148,7 +7133,6 @@ async function sprintList(projectRoot, parsed) {
     }
   ];
   const rows = milestones.map((m) => ({
-    active: null,
     title: m.title,
     openIssues: m.openIssues,
     closedIssues: m.closedIssues,
@@ -7159,21 +7143,15 @@ async function sprintList(projectRoot, parsed) {
   process.stderr.write(`${renderTable(columns, rows)}
 
 `);
-  if (activeSprint) {
-    process.stderr.write(`  ${green("●")} = active sprint
-`);
-  }
 }
 async function sprintShow(projectRoot, parsed) {
   const config = loadConfig(projectRoot);
   const { owner, repo } = config.github;
-  const sprintName = parsed.positional[0] ?? config.sprint.active;
+  const sprintName = parsed.positional[0];
   if (!sprintName) {
-    process.stderr.write(`${red2("✗")} No sprint specified and no active sprint set.
+    process.stderr.write(`${red2("✗")} Missing sprint name.
 `);
     process.stderr.write(`  Usage: ${bold2('locus sprint show "Sprint 1"')}
-`);
-    process.stderr.write(`  Or set active: ${bold2('locus sprint active "Sprint 1"')}
 `);
     process.exit(1);
   }
@@ -7226,10 +7204,6 @@ ${bold2(`Sprint: ${milestone.title}`)} ${dim2(`(${milestone.state})`)}
     {
       label: "State",
       value: milestone.state === "open" ? green("open") : dim2("closed")
-    },
-    {
-      label: "Active",
-      value: config.sprint.active && normalizeMilestoneTitle(config.sprint.active) === normalizeMilestoneTitle(milestone.title) ? green("yes") : dim2("no")
     }
   ]);
   process.stderr.write(`${details}
@@ -7298,49 +7272,12 @@ ${bold2("Tasks")} ${dim2(`(by execution order)`)}
   process.stderr.write(`
 `);
 }
-async function sprintActive(projectRoot, parsed) {
+async function sprintOrder(projectRoot, parsed) {
   const sprintName = parsed.positional[0];
   if (!sprintName) {
-    const config2 = loadConfig(projectRoot);
-    if (config2.sprint.active) {
-      process.stderr.write(`Active sprint: ${bold2(green(config2.sprint.active))}
-`);
-    } else {
-      process.stderr.write(`${dim2("No active sprint set.")}
-`);
-      process.stderr.write(`  Set one: ${bold2('locus sprint active "Sprint 1"')}
-`);
-    }
-    return;
-  }
-  const config = loadConfig(projectRoot);
-  const { owner, repo } = config.github;
-  process.stderr.write(`${cyan2("●")} Verifying sprint...`);
-  let milestones;
-  try {
-    milestones = listMilestones(owner, repo, "open", { cwd: projectRoot });
-  } catch (e) {
-    process.stderr.write(`\r${red2("✗")} ${e.message}
-`);
-    process.exit(1);
-    return;
-  }
-  const found = findMilestoneByTitle(milestones, sprintName);
-  if (!found) {
-    process.stderr.write(`\r${red2("✗")} Sprint "${sprintName}" not found (or is closed).
-`);
-    process.exit(1);
-    return;
-  }
-  updateConfigValue(projectRoot, "sprint.active", found.title);
-  process.stderr.write(`\r${green("✓")} Active sprint set to "${bold2(found.title)}"
+    process.stderr.write(`${red2("✗")} Missing sprint name.
 `);
-}
-async function sprintOrder(projectRoot, parsed) {
-  const config = loadConfig(projectRoot);
-  const sprintName = parsed.positional[0] ?? config.sprint.active;
-  if (!sprintName) {
-    process.stderr.write(`${red2("✗")} No sprint specified and no active sprint set.
+    process.stderr.write(`  Usage: ${bold2('locus sprint order "Sprint 1" 17 15 16')}
 `);
     process.exit(1);
   }
@@ -7475,15 +7412,15 @@ ${green("✓")} Sprint order updated.
 `);
 }
 async function sprintClose(projectRoot, parsed) {
-  const config = loadConfig(projectRoot);
-  const sprintName = parsed.positional[0] ?? config.sprint.active;
+  const sprintName = parsed.positional[0];
   if (!sprintName) {
-    process.stderr.write(`${red2("✗")} No sprint specified.
+    process.stderr.write(`${red2("✗")} Missing sprint name.
 `);
     process.stderr.write(`  Usage: ${bold2('locus sprint close "Sprint 1"')}
 `);
     process.exit(1);
   }
+  const config = loadConfig(projectRoot);
   const { owner, repo } = config.github;
   process.stderr.write(`${cyan2("●")} Closing sprint "${sprintName}"...`);
   let milestones;
@@ -7512,11 +7449,6 @@ async function sprintClose(projectRoot, parsed) {
   }
   process.stderr.write(`\r${green("✓")} Closed sprint "${bold2(milestone.title)}"
 `);
-  if (config.sprint.active && normalizeMilestoneTitle(config.sprint.active) === normalizeMilestoneTitle(milestone.title)) {
-    updateConfigValue(projectRoot, "sprint.active", null);
-    process.stderr.write(`  ${dim2(`Cleared active sprint (was ${milestone.title})`)}
-`);
-  }
 }
 function getOrder(labels) {
   for (const label of labels) {
@@ -7567,7 +7499,6 @@ ${bold2("Subcommands:")}
   ${cyan2("create")} ${dim2("(c)")}    Create a new sprint
   ${cyan2("list")} ${dim2("(ls)")}     List sprints (default)
   ${cyan2("show")}           Show sprint details and task order
-  ${cyan2("active")}         Set or show the active sprint
   ${cyan2("order")}          Reorder sprint tasks
   ${cyan2("close")}          Close a sprint
 
@@ -7585,7 +7516,6 @@ ${bold2("Examples:")}
   locus sprint create "Sprint 1" --due 2026-03-07
   locus sprint list
   locus sprint show "Sprint 1"
-  locus sprint active "Sprint 1"
   locus sprint order "Sprint 1" 17 15 16
   locus sprint order "Sprint 1" --show
   locus sprint close "Sprint 1"
@@ -10425,6 +10355,21 @@ var init_shutdown = __esm(() => {
 });
 
 // src/core/worktree.ts
+var exports_worktree = {};
+__export(exports_worktree, {
+  sprintSlug: () => sprintSlug2,
+  removeWorktree: () => removeWorktree,
+  removeSprintWorktree: () => removeSprintWorktree,
+  pushWorktreeBranch: () => pushWorktreeBranch,
+  listWorktrees: () => listWorktrees,
+  hasWorktreeChanges: () => hasWorktreeChanges,
+  getWorktreePath: () => getWorktreePath,
+  getWorktreeAge: () => getWorktreeAge,
+  getSprintWorktreePath: () => getSprintWorktreePath,
+  createWorktree: () => createWorktree,
+  createSprintWorktree: () => createSprintWorktree,
+  cleanupStaleWorktrees: () => cleanupStaleWorktrees
+});
 import { execSync as execSync16 } from "node:child_process";
 import { existsSync as existsSync21, readdirSync as readdirSync7, realpathSync, statSync as statSync4 } from "node:fs";
 import { join as join21 } from "node:path";
@@ -10448,10 +10393,56 @@ function getWorktreeDir(projectRoot) {
 function getWorktreePath(projectRoot, issueNumber) {
   return join21(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
 }
+function getSprintWorktreePath(projectRoot, sprintSlug2) {
+  return join21(getWorktreeDir(projectRoot), `sprint-${sprintSlug2}`);
+}
 function generateBranchName(issueNumber) {
   const randomSuffix = Math.random().toString(36).slice(2, 8);
   return `locus/issue-${issueNumber}-${randomSuffix}`;
 }
+function sprintSlug2(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function createSprintWorktree(projectRoot, sprintName, baseBranch) {
+  const log = getLogger();
+  const slug = sprintSlug2(sprintName);
+  const worktreePath = getSprintWorktreePath(projectRoot, slug);
+  if (existsSync21(worktreePath)) {
+    log.verbose(`Sprint worktree already exists for "${sprintName}"`);
+    const existingBranch = getWorktreeBranch(worktreePath) ?? `locus/sprint-${slug}`;
+    return { path: worktreePath, branch: existingBranch };
+  }
+  const randomSuffix = Math.random().toString(36).slice(2, 8);
+  const branch = `locus/sprint-${slug}-${randomSuffix}`;
+  git4(`worktree add ${JSON.stringify(worktreePath)} -b ${branch} ${baseBranch}`, projectRoot);
+  initSubmodules(worktreePath);
+  log.info(`Created sprint worktree for "${sprintName}"`, {
+    path: worktreePath,
+    branch,
+    baseBranch
+  });
+  return { path: worktreePath, branch };
+}
+function removeSprintWorktree(projectRoot, sprintName) {
+  const log = getLogger();
+  const slug = sprintSlug2(sprintName);
+  const worktreePath = getSprintWorktreePath(projectRoot, slug);
+  if (!existsSync21(worktreePath)) {
+    log.verbose(`Sprint worktree for "${sprintName}" does not exist`);
+    return;
+  }
+  const branch = getWorktreeBranch(worktreePath);
+  try {
+    git4(`worktree remove ${JSON.stringify(worktreePath)} --force`, projectRoot);
+    log.info(`Removed sprint worktree for "${sprintName}"`);
+  } catch (e) {
+    log.warn(`Failed to remove sprint worktree: ${e}`);
+    gitSafe3(`worktree remove ${JSON.stringify(worktreePath)} --force`, projectRoot);
+  }
+  if (branch) {
+    gitSafe3(`branch -D ${branch}`, projectRoot);
+  }
+}
 function getWorktreeBranch(worktreePath) {
   try {
     return execSync16("git branch --show-current", {
@@ -10571,6 +10562,36 @@ function cleanupStaleWorktrees(projectRoot) {
   }
   return cleaned;
 }
+function pushWorktreeBranch(projectRoot, issueNumber) {
+  const worktreePath = getWorktreePath(projectRoot, issueNumber);
+  if (!existsSync21(worktreePath)) {
+    throw new Error(`Worktree for issue #${issueNumber} does not exist`);
+  }
+  const branch = getWorktreeBranch(worktreePath);
+  if (!branch) {
+    throw new Error(`Could not determine branch for worktree #${issueNumber}`);
+  }
+  git4(`push -u origin ${branch}`, worktreePath);
+  return branch;
+}
+function hasWorktreeChanges(projectRoot, issueNumber) {
+  const worktreePath = getWorktreePath(projectRoot, issueNumber);
+  if (!existsSync21(worktreePath))
+    return false;
+  const status = gitSafe3("status --porcelain", worktreePath);
+  return status !== null && status.trim().length > 0;
+}
+function getWorktreeAge(projectRoot, issueNumber) {
+  const worktreePath = getWorktreePath(projectRoot, issueNumber);
+  if (!existsSync21(worktreePath))
+    return 0;
+  try {
+    const stat = statSync4(worktreePath);
+    return Date.now() - stat.ctimeMs;
+  } catch {
+    return 0;
+  }
+}
 var init_worktree = __esm(() => {
   init_logger();
   init_submodule();
@@ -10582,6 +10603,8 @@ __export(exports_run, {
   runCommand: () => runCommand
 });
 import { execSync as execSync17 } from "node:child_process";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join22 } from "node:path";
 function resolveExecutionContext(config, modelOverride) {
   const model = modelOverride ?? config.ai.model;
   const provider = inferProviderFromModel(model) ?? config.ai.provider;
@@ -10598,12 +10621,14 @@ function printRunHelp() {
 ${bold2("locus run")} — Execute issues using AI agents
 
 ${bold2("Usage:")}
-  locus run                           ${dim2("# Run active sprint (sequential)")}
+  locus run                           ${dim2("# Run all open sprints (parallel)")}
+  locus run --sprint <name>           ${dim2("# Run a specific sprint")}
   locus run <issue>                   ${dim2("# Run single issue (worktree)")}
   locus run <issue> <issue> ...       ${dim2("# Run multiple issues (parallel)")}
   locus run --resume                  ${dim2("# Resume interrupted run")}
 
 ${bold2("Options:")}
+  --sprint <name>       Run a specific sprint (instead of all active)
   --resume              Resume a previously interrupted run
   --dry-run             Show what would happen without executing
   --model <name>        Override the AI model for this run
@@ -10616,7 +10641,8 @@ ${bold2("Sandbox:")}
   unsandboxed with a warning.
 
 ${bold2("Examples:")}
-  locus run                           ${dim2("# Execute active sprint")}
+  locus run                           ${dim2("# Execute all open sprints")}
+  locus run --sprint "Sprint 1"       ${dim2("# Run a specific sprint")}
   locus run 42                        ${dim2("# Run single issue")}
   locus run 42 43 44                  ${dim2("# Run issues in parallel")}
   locus run --resume                  ${dim2("# Resume after failure")}
@@ -10669,11 +10695,11 @@ async function runCommand(projectRoot, args, flags = {}) {
       }
     }
     if (flags.resume) {
-      return handleResume(projectRoot, config, sandboxed, runRef);
+      return handleResume(projectRoot, config, sandboxed, flags);
     }
     const issueNumbers = args.filter((a) => /^\d+$/.test(a)).map(Number);
     if (issueNumbers.length === 0) {
-      return handleSprintRun(projectRoot, config, flags, sandboxed, runRef);
+      return handleSprintRun(projectRoot, config, flags, sandboxed);
     }
     if (issueNumbers.length === 1) {
       return handleSingleIssue(projectRoot, config, issueNumbers[0], flags, sandboxed);
@@ -10683,18 +10709,56 @@ async function runCommand(projectRoot, args, flags = {}) {
     cleanupShutdown();
   }
 }
-async function handleSprintRun(projectRoot, config, flags, sandboxed, runRef) {
-  const log = getLogger();
-  const execution = resolveExecutionContext(config, flags.model);
-  if (!config.sprint.active) {
-    process.stderr.write(`${red2("✗")} No active sprint. Set one with: ${bold2("locus sprint active <name>")}
+async function handleSprintRun(projectRoot, config, flags, sandboxed) {
+  let sprintNames;
+  if (flags.sprint) {
+    sprintNames = [flags.sprint];
+  } else {
+    process.stderr.write(`${cyan2("●")} Detecting open sprints...`);
+    try {
+      const milestones = listMilestones(config.github.owner, config.github.repo, "open", { cwd: projectRoot });
+      sprintNames = milestones.map((m) => m.title);
+    } catch (e) {
+      process.stderr.write(`\r${red2("✗")} Failed to fetch sprints: ${e.message}
+`);
+      return;
+    }
+    process.stderr.write("\r\x1B[2K");
+  }
+  if (sprintNames.length === 0) {
+    process.stderr.write(`${red2("✗")} No open sprints found.
+`);
+    process.stderr.write(`  Create one: ${bold2('locus sprint create "Sprint 1"')}
 `);
     process.stderr.write(`  Or specify issue numbers: ${bold2("locus run 42 43 44")}
 `);
     return;
   }
-  const sprintName = config.sprint.active;
-  runRef.sprintName = sprintName;
+  const cleaned = cleanupStaleWorktrees(projectRoot);
+  if (cleaned > 0) {
+    process.stderr.write(`  ${dim2(`Cleaned up ${cleaned} stale worktree${cleaned === 1 ? "" : "s"}.`)}
+`);
+  }
+  if (sprintNames.length === 1) {
+    await executeSingleSprint(projectRoot, config, sprintNames[0], flags, sandboxed);
+  } else {
+    process.stderr.write(`
+${bold2("Running")} ${cyan2(`${sprintNames.length} sprints`)} ${dim2("(parallel, worktrees)")}
+
+`);
+    const timer = createTimer();
+    const promises = sprintNames.map((name) => executeSingleSprint(projectRoot, config, name, flags, sandboxed).catch((e) => {
+      getLogger().warn(`Sprint "${name}" threw: ${e}`);
+    }));
+    await Promise.allSettled(promises);
+    process.stderr.write(`
+${bold2("All sprints complete")} ${dim2(`(${timer.formatted()})`)}
+
+`);
+  }
+}
+async function executeSingleSprint(projectRoot, config, sprintName, flags, sandboxed) {
+  const execution = resolveExecutionContext(config, flags.model);
   process.stderr.write(`
 ${bold2("Sprint:")} ${cyan2(sprintName)}
 `);
@@ -10703,7 +10767,7 @@ ${bold2("Sprint:")} ${cyan2(sprintName)}
     const stats2 = getRunStats(existingState);
     if (stats2.inProgress > 0 || stats2.pending > 0) {
       process.stderr.write(`
-${yellow2("⚠")} A run for this sprint is already in progress.
+${yellow2("⚠")} A run for sprint "${sprintName}" is already in progress.
 `);
       process.stderr.write(`  Use ${bold2("locus run --resume")} to continue.
 `);
@@ -10724,14 +10788,33 @@ ${yellow2("⚠")} A run for this sprint is already in progress.
     return;
   }
   issues = sortByOrder2(issues);
-  const randomSuffix = Math.random().toString(36).slice(2, 8);
-  const branchName = `locus/sprint-${sprintName.toLowerCase().replace(/\s+/g, "-")}-${randomSuffix}`;
+  let worktreePath;
+  let branchName;
+  if (!flags.dryRun) {
+    try {
+      const wt = createSprintWorktree(projectRoot, sprintName, config.agent.baseBranch);
+      worktreePath = wt.path;
+      branchName = wt.branch;
+      process.stderr.write(`  ${dim2(`Worktree: ${wt.path}`)}
+`);
+      process.stderr.write(`  ${dim2(`Branch: ${wt.branch}`)}
+`);
+    } catch (e) {
+      process.stderr.write(`${red2("✗")} Failed to create worktree: ${e}
+`);
+      return;
+    }
+  } else {
+    const randomSuffix = Math.random().toString(36).slice(2, 8);
+    branchName = `locus/sprint-${sprintName.toLowerCase().replace(/\s+/g, "-")}-${randomSuffix}`;
+  }
+  const workDir = worktreePath ?? projectRoot;
   const state = createSprintRunState(sprintName, branchName, issues.map((issue, i) => ({
     number: issue.number,
     order: getOrder2(issue) ?? i + 1
   })));
   saveRunState(projectRoot, state);
-  process.stderr.write(`  ${dim2(`${issues.length} tasks, branch: ${branchName}`)}
+  process.stderr.write(`  ${dim2(`${issues.length} tasks`)}
 
 `);
   for (const task of state.tasks) {
@@ -10746,20 +10829,6 @@ ${yellow2("⚠")} A run for this sprint is already in progress.
 
 `);
   }
-  if (!flags.dryRun) {
-    try {
-      execSync17(`git checkout -B ${branchName}`, {
-        cwd: projectRoot,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      log.info(`Checked out branch ${branchName}`);
-    } catch (e) {
-      process.stderr.write(`${red2("✗")} Failed to create branch: ${e}
-`);
-      return;
-    }
-  }
   const timer = createTimer();
   for (let i = 0;i < state.tasks.length; i++) {
     const task = state.tasks[i];
@@ -10771,27 +10840,37 @@ ${yellow2("⚠")} A run for this sprint is already in progress.
     }
     await getRateLimiter().checkBeforeRequest();
     if (config.agent.rebaseBeforeTask && !flags.dryRun && i > 0) {
-      const conflictResult = checkForConflicts(projectRoot, config.agent.baseBranch);
+      const conflictResult = checkForConflicts(workDir, config.agent.baseBranch);
       if (conflictResult.baseAdvanced) {
         printConflictReport(conflictResult, config.agent.baseBranch);
         if (conflictResult.hasConflict) {
           markTaskFailed(state, task.issue, "Merge conflict with base branch");
           saveRunState(projectRoot, state);
-          process.stderr.write(`
+          process.stderr.write(`  ${red2("✗")} Task #${task.issue} skipped due to conflicts.
+`);
+          if (config.sprint.stopOnFailure) {
+            process.stderr.write(`
 ${red2("✗")} Sprint stopped due to conflicts.
 `);
-          process.stderr.write(`  Resolve conflicts and run: ${bold2("locus run --resume")}
+            process.stderr.write(`  Resolve conflicts and run: ${bold2("locus run --resume")}
 `);
-          return;
+            break;
+          }
+          continue;
         }
-        const rebaseResult = attemptRebase(projectRoot, config.agent.baseBranch);
+        const rebaseResult = attemptRebase(workDir, config.agent.baseBranch);
         if (!rebaseResult.success) {
           markTaskFailed(state, task.issue, "Rebase failed");
           saveRunState(projectRoot, state);
-          process.stderr.write(`
-${red2("✗")} Auto-rebase failed. Resolve manually.
+          process.stderr.write(`  ${red2("✗")} Auto-rebase failed for task #${task.issue}.
 `);
-          return;
+          if (config.sprint.stopOnFailure) {
+            process.stderr.write(`
+${red2("✗")} Sprint stopped. Resolve manually.
+`);
+            break;
+          }
+          continue;
         }
       }
     }
@@ -10799,19 +10878,19 @@ ${red2("✗")} Auto-rebase failed. Resolve manually.
     if (i > 0 && !flags.dryRun) {
       try {
         sprintContext = execSync17(`git diff origin/${config.agent.baseBranch}..HEAD`, {
-          cwd: projectRoot,
+          cwd: workDir,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         }).trim();
       } catch {}
     }
     process.stderr.write(`
-${progressBar(i, state.tasks.length, { label: "Sprint Progress" })}
+${progressBar(i, state.tasks.length, { label: `Sprint: ${sprintName}` })}
 
 `);
     markTaskInProgress(state, task.issue);
     saveRunState(projectRoot, state);
-    const result = await executeIssue(projectRoot, {
+    const result = await executeIssue(workDir, {
       issueNumber: task.issue,
       provider: execution.provider,
       model: execution.model,
@@ -10825,7 +10904,7 @@ ${progressBar(i, state.tasks.length, { label: "Sprint Progress" })}
     if (result.success) {
       if (!flags.dryRun) {
         const issueTitle = issue?.title ?? "";
-        ensureTaskCommit(projectRoot, task.issue, issueTitle);
+        ensureTaskCommit(workDir, task.issue, issueTitle);
         if (sandboxed && i < state.tasks.length - 1) {
           process.stderr.write(`  ${dim2("↻ Sandbox will resync on next task")}
 `);
@@ -10837,18 +10916,20 @@ ${progressBar(i, state.tasks.length, { label: "Sprint Progress" })}
       saveRunState(projectRoot, state);
       if (config.sprint.stopOnFailure) {
         process.stderr.write(`
-${red2("✗")} Sprint stopped: task #${task.issue} failed.
+${red2("✗")} Sprint "${sprintName}" stopped: task #${task.issue} failed.
 `);
         process.stderr.write(`  Resume with: ${bold2("locus run --resume")}
 `);
-        return;
+        break;
       }
+      process.stderr.write(`  ${yellow2("⚠")} Task #${task.issue} failed, continuing to next task.
+`);
     }
     saveRunState(projectRoot, state);
   }
   const stats = getRunStats(state);
   process.stderr.write(`
-${progressBar(stats.done, stats.total, { label: "Sprint Complete" })}
+${progressBar(stats.done, stats.total, { label: `Sprint Complete: ${sprintName}` })}
 `);
   process.stderr.write(`
 ${bold2("Summary:")}
@@ -10861,21 +10942,18 @@ ${bold2("Summary:")}
       issue: t.issue,
       title: issues.find((i) => i.number === t.issue)?.title
     }));
-    const prNumber = await createSprintPR(projectRoot, config, sprintName, branchName, completedTasks);
-    if (prNumber !== undefined) {
-      try {
-        execSync17(`git checkout ${config.agent.baseBranch}`, {
-          cwd: projectRoot,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        process.stderr.write(`  ${dim2(`Checked out ${config.agent.baseBranch}`)}
-`);
-      } catch {}
-    }
+    await createSprintPR(workDir, config, sprintName, branchName, completedTasks);
   }
   if (stats.failed === 0) {
     clearRunState(projectRoot, sprintName);
+    if (worktreePath) {
+      removeSprintWorktree(projectRoot, sprintName);
+    }
+  } else {
+    if (worktreePath) {
+      process.stderr.write(`  ${yellow2("⚠")} Sprint worktree preserved: ${dim2(worktreePath)}
+`);
+    }
   }
 }
 async function handleSingleIssue(projectRoot, config, issueNumber, flags, sandboxed) {
@@ -11056,43 +11134,87 @@ ${yellow2("⚠")} Failed worktrees preserved for debugging:
     clearRunState(projectRoot);
   }
 }
-async function handleResume(projectRoot, config, sandboxed, runRef) {
-  const execution = resolveExecutionContext(config);
-  const sprintName = config.sprint.active ?? undefined;
-  let state = sprintName ? loadRunState(projectRoot, sprintName) : null;
-  if (!state) {
-    state = loadRunState(projectRoot);
+async function handleResume(projectRoot, config, sandboxed, flags) {
+  if (flags.sprint) {
+    const state = loadRunState(projectRoot, flags.sprint);
+    if (!state) {
+      process.stderr.write(`${red2("✗")} No run state found for sprint "${flags.sprint}".
+`);
+      return;
+    }
+    await resumeSingleRun(projectRoot, config, state, sandboxed);
+    return;
   }
-  if (!state) {
+  const sprintsToResume = [];
+  try {
+    const { readdirSync: readdirSync8 } = await import("node:fs");
+    const runStateDir = join22(projectRoot, ".locus", "run-state");
+    if (existsSync22(runStateDir)) {
+      const files = readdirSync8(runStateDir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        const sprintName = file === "_parallel.json" ? undefined : file.replace(/\.json$/, "");
+        const state = loadRunState(projectRoot, sprintName);
+        if (state) {
+          const stats = getRunStats(state);
+          if (stats.failed > 0 || stats.pending > 0 || stats.inProgress > 0) {
+            sprintsToResume.push(state);
+          }
+        }
+      }
+    }
+  } catch {}
+  if (sprintsToResume.length === 0) {
     process.stderr.write(`${red2("✗")} No run state found. Nothing to resume.
 `);
     return;
   }
-  runRef.sprintName = state.sprint;
+  if (sprintsToResume.length === 1) {
+    await resumeSingleRun(projectRoot, config, sprintsToResume[0], sandboxed);
+  } else {
+    process.stderr.write(`
+${bold2("Resuming")} ${cyan2(`${sprintsToResume.length} runs`)} ${dim2("(parallel)")}
+
+`);
+    const promises = sprintsToResume.map((state) => resumeSingleRun(projectRoot, config, state, sandboxed).catch((e) => {
+      getLogger().warn(`Resume for "${state.sprint}" threw: ${e}`);
+    }));
+    await Promise.allSettled(promises);
+  }
+}
+async function resumeSingleRun(projectRoot, config, state, sandboxed) {
+  const execution = resolveExecutionContext(config);
   const stats = getRunStats(state);
   process.stderr.write(`
-${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
+${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}${state.sprint ? ` (${cyan2(state.sprint)})` : ""}
 `);
   process.stderr.write(`  Done: ${stats.done}, Failed: ${stats.failed}, Pending: ${stats.pending}
 
 `);
-  if (state.type === "sprint" && state.branch) {
-    try {
-      const currentBranch = execSync17("git rev-parse --abbrev-ref HEAD", {
-        cwd: projectRoot,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      if (currentBranch !== state.branch) {
-        execSync17(`git checkout ${state.branch}`, {
+  let workDir = projectRoot;
+  if (state.type === "sprint" && state.sprint) {
+    const { getSprintWorktreePath: getSprintWorktreePath2, sprintSlug: sprintSlug3 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
+    const { existsSync: existsSync23 } = await import("node:fs");
+    const wtPath = getSprintWorktreePath2(projectRoot, sprintSlug3(state.sprint));
+    if (existsSync23(wtPath)) {
+      workDir = wtPath;
+    } else if (state.branch) {
+      try {
+        const currentBranch = execSync17("git rev-parse --abbrev-ref HEAD", {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
-        });
-      }
-    } catch {
-      process.stderr.write(`${yellow2("⚠")} Could not checkout branch ${state.branch}
+        }).trim();
+        if (currentBranch !== state.branch) {
+          execSync17(`git checkout ${state.branch}`, {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        }
+      } catch {
+        process.stderr.write(`${yellow2("⚠")} Could not checkout branch ${state.branch}
 `);
+      }
     }
   }
   const isSprintRun = state.type === "sprint";
@@ -11106,7 +11228,7 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
     }
     markTaskInProgress(state, task.issue);
     saveRunState(projectRoot, state);
-    const result = await executeIssue(projectRoot, {
+    const result = await executeIssue(workDir, {
       issueNumber: task.issue,
       provider: execution.provider,
       model: execution.model,
@@ -11122,7 +11244,7 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
           const iss = getIssue(task.issue, { cwd: projectRoot });
           issueTitle = iss.title;
         } catch {}
-        ensureTaskCommit(projectRoot, task.issue, issueTitle);
+        ensureTaskCommit(workDir, task.issue, issueTitle);
         if (sandboxed) {
           process.stderr.write(`  ${dim2("↻ Sandbox will resync on next task")}
 `);
@@ -11138,6 +11260,8 @@ ${red2("✗")} Sprint stopped: task #${task.issue} failed.
 `);
         return;
       }
+      process.stderr.write(`  ${yellow2("⚠")} Task #${task.issue} failed, continuing to next task.
+`);
     }
     saveRunState(projectRoot, state);
     task = getNextTask(state);
@@ -11149,21 +11273,13 @@ ${bold2("Resume complete:")} ${green(`✓ ${finalStats.done}`)} ${finalStats.fai
 `);
   if (isSprintRun && state.branch && state.sprint && finalStats.done > 0) {
     const completedTasks = state.tasks.filter((t) => t.status === "done").map((t) => ({ issue: t.issue }));
-    const prNumber = await createSprintPR(projectRoot, config, state.sprint, state.branch, completedTasks);
-    if (prNumber !== undefined) {
-      try {
-        execSync17(`git checkout ${config.agent.baseBranch}`, {
-          cwd: projectRoot,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        process.stderr.write(`  ${dim2(`Checked out ${config.agent.baseBranch}`)}
-`);
-      } catch {}
-    }
+    await createSprintPR(workDir, config, state.sprint, state.branch, completedTasks);
   }
   if (finalStats.failed === 0) {
     clearRunState(projectRoot, state.sprint);
+    if (isSprintRun && state.sprint) {
+      removeSprintWorktree(projectRoot, state.sprint);
+    }
   }
 }
 function sortByOrder2(issues) {
@@ -11181,22 +11297,22 @@ function getOrder2(issue) {
   }
   return null;
 }
-function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
+function ensureTaskCommit(workDir, issueNumber, issueTitle) {
   try {
-    const committedSubmodules = commitDirtySubmodules(projectRoot, issueNumber, issueTitle);
+    const committedSubmodules = commitDirtySubmodules(workDir, issueNumber, issueTitle);
     if (committedSubmodules.length > 0) {
       process.stderr.write(`  ${dim2(`Committed submodule changes: ${committedSubmodules.join(", ")}`)}
 `);
     }
     const status = execSync17("git status --porcelain", {
-      cwd: projectRoot,
+      cwd: workDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!status)
       return;
     execSync17("git add -A", {
-      cwd: projectRoot,
+      cwd: workDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -11205,7 +11321,7 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
     execSync17(`git commit -F -`, {
       input: message,
-      cwd: projectRoot,
+      cwd: workDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -11213,12 +11329,12 @@ Co-Authored-By: LocusAgent <agent@locusai.team>`;
 `);
   } catch {}
 }
-async function createSprintPR(projectRoot, config, sprintName, branchName, tasks) {
+async function createSprintPR(workDir, config, sprintName, branchName, tasks) {
   if (!config.agent.autoPR)
     return;
   try {
     const diff = execSync17(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
-      cwd: projectRoot,
+      cwd: workDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -11227,15 +11343,15 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
 `);
       return;
     }
-    pushSubmoduleBranches(projectRoot);
+    pushSubmoduleBranches(workDir);
     execSync17(`git push -u origin ${branchName}`, {
-      cwd: projectRoot,
+      cwd: workDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
     const taskLines = tasks.map((t) => `- Closes #${t.issue}${t.title ? `: ${t.title}` : ""}`).join(`
 `);
-    const submoduleSummary = getSubmoduleChangeSummary(projectRoot, config.agent.baseBranch);
+    const submoduleSummary = getSubmoduleChangeSummary(workDir, config.agent.baseBranch);
     let prBody = `## Sprint: ${sprintName}
 
 ${taskLines}`;
@@ -11249,7 +11365,7 @@ ${submoduleSummary}`;
 ---
 
 \uD83E\uDD16 Automated by [Locus](https://github.com/asgarovf/locusai)`;
-    const prNumber = createPR(`Sprint: ${sprintName}`, prBody, branchName, config.agent.baseBranch, { cwd: projectRoot });
+    const prNumber = createPR(`Sprint: ${sprintName}`, prBody, branchName, config.agent.baseBranch, { cwd: workDir });
     process.stderr.write(`  ${green("✓")} Created sprint PR #${prNumber}
 `);
     return prNumber;
@@ -11283,8 +11399,8 @@ __export(exports_status, {
   statusCommand: () => statusCommand
 });
 import { execSync as execSync18 } from "node:child_process";
-import { existsSync as existsSync22 } from "node:fs";
-import { dirname as dirname7, join as join22 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { dirname as dirname7, join as join23 } from "node:path";
 async function statusCommand(projectRoot) {
   const config = loadConfig(projectRoot);
   const spinner = new Spinner;
@@ -11293,21 +11409,19 @@ async function statusCommand(projectRoot) {
   lines.push(`  ${dim2("Repo:")}     ${cyan2(`${config.github.owner}/${config.github.repo}`)}`);
   lines.push(`  ${dim2("Provider:")} ${config.ai.provider} / ${config.ai.model}`);
   lines.push(`  ${dim2("Branch:")}   ${config.agent.baseBranch}`);
-  if (config.sprint.active) {
-    const sprintName = config.sprint.active;
-    try {
-      const milestones = listMilestones(config.github.owner, config.github.repo, "open", { cwd: projectRoot });
-      const milestone = milestones.find((m) => m.title.toLowerCase() === sprintName.toLowerCase());
-      if (milestone) {
+  try {
+    const milestones = listMilestones(config.github.owner, config.github.repo, "open", { cwd: projectRoot });
+    if (milestones.length > 0) {
+      for (const milestone of milestones) {
         const total = milestone.openIssues + milestone.closedIssues;
         const done = milestone.closedIssues;
         const dueStr = milestone.dueOn ? ` due ${new Date(milestone.dueOn).toLocaleDateString("en-US", { month: "short", day: "numeric" })}` : "";
         lines.push("");
-        lines.push(`  ${bold2("Sprint:")}  ${cyan2(sprintName)} (${done} of ${total} done${dueStr})`);
+        lines.push(`  ${bold2("Sprint:")}  ${cyan2(milestone.title)} (${done} of ${total} done${dueStr})`);
         if (total > 0) {
           lines.push(`  ${progressBar(done, total, { width: 30 })}`);
         }
-        const issues = listIssues({ milestone: sprintName, state: "all" }, { cwd: projectRoot });
+        const issues = listIssues({ milestone: milestone.title, state: "all" }, { cwd: projectRoot });
         const queued = issues.filter((i) => i.labels.some((l) => l === "locus:queued")).length;
         const inProgress = issues.filter((i) => i.labels.some((l) => l === "locus:in-progress")).length;
         const failed = issues.filter((i) => i.labels.some((l) => l === "locus:failed")).length;
@@ -11323,17 +11437,14 @@ async function statusCommand(projectRoot) {
         if (parts.length > 0) {
           lines.push(`  ${parts.join("  ")}`);
         }
-      } else {
-        lines.push("");
-        lines.push(`  ${bold2("Sprint:")}  ${cyan2(sprintName)} ${dim2("(not found)")}`);
       }
-    } catch {
+    } else {
       lines.push("");
-      lines.push(`  ${bold2("Sprint:")}  ${cyan2(sprintName)} ${dim2("(could not fetch)")}`);
+      lines.push(`  ${dim2("Sprint:")}  ${dim2("no open sprints")}`);
     }
-  } else {
+  } catch {
     lines.push("");
-    lines.push(`  ${dim2("Sprint:")}  ${dim2("none active")}`);
+    lines.push(`  ${dim2("Sprint:")}  ${dim2("(could not fetch)")}`);
   }
   const runState = loadRunState(projectRoot);
   if (runState) {
@@ -11421,13 +11532,13 @@ ${drawBox(lines, { title: "Locus Status" })}
 `);
 }
 function getPm2Bin() {
-  const pkgsBin = join22(getPackagesDir(), "node_modules", ".bin", "pm2");
-  if (existsSync22(pkgsBin))
+  const pkgsBin = join23(getPackagesDir(), "node_modules", ".bin", "pm2");
+  if (existsSync23(pkgsBin))
     return pkgsBin;
   let dir = process.cwd();
   while (dir !== dirname7(dir)) {
-    const candidate = join22(dir, "node_modules", ".bin", "pm2");
-    if (existsSync22(candidate))
+    const candidate = join23(dir, "node_modules", ".bin", "pm2");
+    if (existsSync23(candidate))
       return candidate;
     dir = dirname7(dir);
   }
@@ -11623,13 +11734,13 @@ __export(exports_plan, {
   parsePlanArgs: () => parsePlanArgs
 });
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync15,
   readdirSync as readdirSync8,
   readFileSync as readFileSync13,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function printHelp2() {
   process.stderr.write(`
 ${bold2("locus plan")} — AI-powered sprint planning
@@ -11661,11 +11772,11 @@ function normalizeSprintName(name) {
   return name.trim().toLowerCase();
 }
 function getPlansDir(projectRoot) {
-  return join23(projectRoot, ".locus", "plans");
+  return join24(projectRoot, ".locus", "plans");
 }
 function ensurePlansDir(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     mkdirSync15(dir, { recursive: true });
   }
   return dir;
@@ -11675,14 +11786,14 @@ function generateId() {
 }
 function loadPlanFile(projectRoot, id) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync23(dir))
+  if (!existsSync24(dir))
     return null;
   const files = readdirSync8(dir).filter((f) => f.endsWith(".json"));
   const match = files.find((f) => f.startsWith(id));
   if (!match)
     return null;
   try {
-    const content = readFileSync13(join23(dir, match), "utf-8");
+    const content = readFileSync13(join24(dir, match), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11749,7 +11860,7 @@ async function planCommand(projectRoot, args, flags = {}) {
 }
 function handleListPlans(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${dim2("No saved plans yet.")}
 `);
     return;
@@ -11767,7 +11878,7 @@ ${bold2("Saved Plans:")}
   for (const file of files) {
     const id = file.replace(".json", "");
     try {
-      const content = readFileSync13(join23(dir, file), "utf-8");
+      const content = readFileSync13(join24(dir, file), "utf-8");
       const plan = JSON.parse(content);
       const date = plan.createdAt ? plan.createdAt.slice(0, 10) : "";
       const issueCount = Array.isArray(plan.issues) ? plan.issues.length : 0;
@@ -11835,7 +11946,7 @@ async function handleRefinePlan(projectRoot, id, feedback, flags) {
     return;
   }
   const config = loadConfig(projectRoot);
-  const planPath = join23(getPlansDir(projectRoot), `${plan.id}.json`);
+  const planPath = join24(getPlansDir(projectRoot), `${plan.id}.json`);
   const planPathRelative = `.locus/plans/${plan.id}.json`;
   process.stderr.write(`
 ${bold2("Refining plan:")} ${cyan2(plan.directive)}
@@ -11874,7 +11985,7 @@ ${red2("✗")} Refinement failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync23(planPath)) {
+  if (!existsSync24(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not found at ${bold2(planPathRelative)}.
 `);
@@ -11972,7 +12083,7 @@ ${bold2("Approving plan:")}
 async function handleAIPlan(projectRoot, config, directive, sprintName, flags) {
   const id = generateId();
   const plansDir = ensurePlansDir(projectRoot);
-  const planPath = join23(plansDir, `${id}.json`);
+  const planPath = join24(plansDir, `${id}.json`);
   const planPathRelative = `.locus/plans/${id}.json`;
   const displayDirective = directive;
   process.stderr.write(`
@@ -12015,7 +12126,7 @@ ${red2("✗")} Planning failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync23(planPath)) {
+  if (!existsSync24(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
 `);
@@ -12197,15 +12308,15 @@ ${directive}${sprintName ? `
 
 **Sprint:** ${sprintName}` : ""}
 </directive>`);
-  const locusPath = join23(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync23(locusPath)) {
+  const locusPath = join24(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync24(locusPath)) {
     const content = readFileSync13(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join23(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync23(learningsPath)) {
+  const learningsPath = join24(projectRoot, ".locus", "LEARNINGS.md");
+  if (existsSync24(learningsPath)) {
     const content = readFileSync13(learningsPath, "utf-8");
     parts.push(`<past-learnings>
 ${content.slice(0, 2000)}
@@ -12258,8 +12369,8 @@ ${JSON.stringify(plan, null, 2)}
   parts.push(`<feedback>
 ${feedback}
 </feedback>`);
-  const locusPath = join23(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync23(locusPath)) {
+  const locusPath = join24(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync24(locusPath)) {
     const content = readFileSync13(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
@@ -12442,8 +12553,8 @@ __export(exports_review, {
   reviewCommand: () => reviewCommand
 });
 import { execFileSync as execFileSync2, execSync as execSync19 } from "node:child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync14 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync14 } from "node:fs";
+import { join as join25 } from "node:path";
 function printHelp3() {
   process.stderr.write(`
 ${bold2("locus review")} — AI-powered code review
@@ -12612,8 +12723,8 @@ function buildReviewPrompt(projectRoot, config, pr, diff, focus) {
   parts.push(`<role>
 You are an expert code reviewer for the ${config.github.owner}/${config.github.repo} repository.
 </role>`);
-  const locusPath = join24(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync24(locusPath)) {
+  const locusPath = join25(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync25(locusPath)) {
     const content = readFileSync14(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 2000)}
@@ -12789,13 +12900,8 @@ ${bold2("Finding PR for issue")} ${cyan2(`#${issueNumber}`)}...
   return handleSinglePR(projectRoot, config, prNumber, flags);
 }
 async function handleSprint(projectRoot, config, flags) {
-  if (!config.sprint.active) {
-    process.stderr.write(`${red2("✗")} No active sprint set.
-`);
-    return;
-  }
   process.stderr.write(`
-${bold2("Iterating on sprint:")} ${cyan2(config.sprint.active)}
+${bold2("Iterating on sprint PRs...")}
 
 `);
   const prs = listPRs({ label: "agent:managed", state: "open" }, { cwd: projectRoot });
@@ -12934,14 +13040,14 @@ __export(exports_discuss, {
   discussCommand: () => discussCommand
 });
 import {
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   mkdirSync as mkdirSync16,
   readdirSync as readdirSync9,
   readFileSync as readFileSync15,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function printHelp5() {
   process.stderr.write(`
 ${bold2("locus discuss")} — AI-powered architectural discussions
@@ -12963,11 +13069,11 @@ ${bold2("Examples:")}
 `);
 }
 function getDiscussionsDir(projectRoot) {
-  return join25(projectRoot, ".locus", "discussions");
+  return join26(projectRoot, ".locus", "discussions");
 }
 function ensureDiscussionsDir(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     mkdirSync16(dir, { recursive: true });
   }
   return dir;
@@ -13002,7 +13108,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
 }
 function listDiscussions(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     process.stderr.write(`${dim2("No discussions yet.")}
 `);
     return;
@@ -13019,7 +13125,7 @@ ${bold2("Discussions:")}
 `);
   for (const file of files) {
     const id = file.replace(".md", "");
-    const content = readFileSync15(join25(dir, file), "utf-8");
+    const content = readFileSync15(join26(dir, file), "utf-8");
     const titleMatch = content.match(/^#\s+(.+)/m);
     const title = titleMatch ? titleMatch[1] : id;
     const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/);
@@ -13037,7 +13143,7 @@ function showDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13049,7 +13155,7 @@ function showDiscussion(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join25(dir, match), "utf-8");
+  const content = readFileSync15(join26(dir, match), "utf-8");
   process.stdout.write(`${content}
 `);
 }
@@ -13060,7 +13166,7 @@ function deleteDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13072,7 +13178,7 @@ function deleteDiscussion(projectRoot, id) {
 `);
     return;
   }
-  unlinkSync6(join25(dir, match));
+  unlinkSync6(join26(dir, match));
   process.stderr.write(`${green("✓")} Deleted discussion: ${match.replace(".md", "")}
 `);
 }
@@ -13085,7 +13191,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13097,7 +13203,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join25(dir, match), "utf-8");
+  const content = readFileSync15(join26(dir, match), "utf-8");
   const titleMatch = content.match(/^#\s+(.+)/m);
   const discussionTitle = titleMatch ? titleMatch[1].trim() : id;
   await planCommand(projectRoot, [
@@ -13223,7 +13329,7 @@ ${turn.content}`;
     ...conversation.length > 1 ? [`---`, ``, `## Discussion Transcript`, ``, transcript, ``] : []
   ].join(`
 `);
-  writeFileSync11(join25(dir, `${id}.md`), markdown, "utf-8");
+  writeFileSync11(join26(dir, `${id}.md`), markdown, "utf-8");
   process.stderr.write(`
 ${green("✓")} Discussion saved: ${cyan2(id)} ${dim2(`(${timer.formatted()})`)}
 `);
@@ -13238,15 +13344,15 @@ function buildDiscussionPrompt(projectRoot, config, topic, conversation, forceFi
   parts.push(`<role>
 You are a senior software architect and consultant for the ${config.github.owner}/${config.github.repo} project.
 </role>`);
-  const locusPath = join25(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync25(locusPath)) {
+  const locusPath = join26(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync26(locusPath)) {
     const content = readFileSync15(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join25(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync25(learningsPath)) {
+  const learningsPath = join26(projectRoot, ".locus", "LEARNINGS.md");
+  if (existsSync26(learningsPath)) {
     const content = readFileSync15(learningsPath, "utf-8");
     parts.push(`<past-learnings>
 ${content.slice(0, 2000)}
@@ -13318,8 +13424,8 @@ __export(exports_artifacts, {
   formatDate: () => formatDate2,
   artifactsCommand: () => artifactsCommand
 });
-import { existsSync as existsSync26, readdirSync as readdirSync10, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync27, readdirSync as readdirSync10, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
+import { join as join27 } from "node:path";
 function printHelp6() {
   process.stderr.write(`
 ${bold2("locus artifacts")} — View and manage AI-generated artifacts
@@ -13339,14 +13445,14 @@ ${dim2("Artifact names support partial matching.")}
 `);
 }
 function getArtifactsDir(projectRoot) {
-  return join26(projectRoot, ".locus", "artifacts");
+  return join27(projectRoot, ".locus", "artifacts");
 }
 function listArtifacts(projectRoot) {
   const dir = getArtifactsDir(projectRoot);
-  if (!existsSync26(dir))
+  if (!existsSync27(dir))
     return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".md")).map((fileName) => {
-    const filePath = join26(dir, fileName);
+    const filePath = join27(dir, fileName);
     const stat = statSync5(filePath);
     return {
       name: fileName.replace(/\.md$/, ""),
@@ -13359,8 +13465,8 @@ function listArtifacts(projectRoot) {
 function readArtifact(projectRoot, name) {
   const dir = getArtifactsDir(projectRoot);
   const fileName = name.endsWith(".md") ? name : `${name}.md`;
-  const filePath = join26(dir, fileName);
-  if (!existsSync26(filePath))
+  const filePath = join27(dir, fileName);
+  if (!existsSync27(filePath))
     return null;
   const stat = statSync5(filePath);
   return {
@@ -13721,8 +13827,8 @@ __export(exports_sandbox2, {
 });
 import { execSync as execSync22, spawn as spawn7 } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync as existsSync27, readFileSync as readFileSync17 } from "node:fs";
-import { basename as basename4, join as join27 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync17 } from "node:fs";
+import { basename as basename4, join as join28 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
 function printSandboxHelp() {
   process.stderr.write(`
@@ -14252,7 +14358,7 @@ async function handleLogs(projectRoot, args) {
 }
 function detectPackageManager2(projectRoot) {
   try {
-    const raw = readFileSync17(join27(projectRoot, "package.json"), "utf-8");
+    const raw = readFileSync17(join28(projectRoot, "package.json"), "utf-8");
     const pkgJson = JSON.parse(raw);
     if (typeof pkgJson.packageManager === "string") {
       const name = pkgJson.packageManager.split("@")[0];
@@ -14261,13 +14367,13 @@ function detectPackageManager2(projectRoot) {
       }
     }
   } catch {}
-  if (existsSync27(join27(projectRoot, "bun.lock")) || existsSync27(join27(projectRoot, "bun.lockb"))) {
+  if (existsSync28(join28(projectRoot, "bun.lock")) || existsSync28(join28(projectRoot, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync27(join27(projectRoot, "yarn.lock"))) {
+  if (existsSync28(join28(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync27(join27(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync28(join28(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
   return "npm";
@@ -14370,9 +14476,9 @@ Installing sandbox dependencies (${bold2(installCmd.join(" "))}) to container fi
 ${dim2(`Detected ${ecosystem} project — skipping JS package install.`)}
 `);
   }
-  const setupScript = join27(projectRoot, ".locus", "sandbox-setup.sh");
-  const containerSetupScript = containerWorkdir ? join27(containerWorkdir, ".locus", "sandbox-setup.sh") : setupScript;
-  if (existsSync27(setupScript)) {
+  const setupScript = join28(projectRoot, ".locus", "sandbox-setup.sh");
+  const containerSetupScript = containerWorkdir ? join28(containerWorkdir, ".locus", "sandbox-setup.sh") : setupScript;
+  if (existsSync28(setupScript)) {
     process.stderr.write(`Running ${bold2(".locus/sandbox-setup.sh")} in sandbox ${dim2(sandboxName)}...
 `);
     const hookOk = await runInteractiveCommand("docker", [
@@ -14540,13 +14646,13 @@ init_context();
 init_logger();
 init_rate_limiter();
 init_terminal();
-import { existsSync as existsSync28, readFileSync as readFileSync18 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync18 } from "node:fs";
+import { join as join29 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getCliVersion() {
   const fallbackVersion = "0.0.0";
-  const packageJsonPath = join28(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
-  if (!existsSync28(packageJsonPath)) {
+  const packageJsonPath = join29(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
+  if (!existsSync29(packageJsonPath)) {
     return fallbackVersion;
   }
   try {
@@ -14660,6 +14766,9 @@ function parseArgs(argv) {
       case "--no-sandbox":
         flags.noSandbox = true;
         break;
+      case "--sprint":
+        flags.sprint = rawArgs[++i];
+        break;
       default:
         if (arg.startsWith("--sandbox=")) {
           flags.sandbox = arg.slice("--sandbox=".length);
@@ -14823,7 +14932,7 @@ async function main() {
     try {
       const root = getGitRoot(cwd);
       if (isInitialized(root)) {
-        logDir = join28(root, ".locus", "logs");
+        logDir = join29(root, ".locus", "logs");
         getRateLimiter(root);
       }
     } catch {}
@@ -14963,7 +15072,8 @@ async function main() {
         dryRun: parsed.flags.dryRun,
         model: parsed.flags.model,
         sandbox: parsed.flags.sandbox,
-        noSandbox: parsed.flags.noSandbox
+        noSandbox: parsed.flags.noSandbox,
+        sprint: parsed.flags.sprint
       });
       break;
     }