@locusai/cli 0.24.8 → 0.25.0

package/bin/locus.js

@@ -39,8 +39,7 @@ var init_dist = __esm(() => {
       rebaseBeforeTask: true
     },
     sprint: {
-      active: null,
-      stopOnFailure: true
+      stopOnFailure: false
     },
     logging: {
       level: "normal",
@@ -3214,6 +3213,602 @@ var init_uninstall = __esm(() => {
   init_registry();
 });
 
+// src/display/table.ts
+function renderTable(columns, rows, options = {}) {
+  const {
+    indent = 2,
+    headerSeparator = true,
+    maxRows = 0,
+    emptyMessage = "No results."
+  } = options;
+  if (rows.length === 0) {
+    return `${" ".repeat(indent)}${dim2(emptyMessage)}`;
+  }
+  const termWidth = getCapabilities().columns;
+  const indentStr = " ".repeat(indent);
+  const gap = 2;
+  const formattedRows = rows.map((row) => {
+    const formatted = {};
+    for (const col of columns) {
+      if (col.format) {
+        formatted[col.key] = col.format(row[col.key], row);
+      } else {
+        const val = row[col.key];
+        formatted[col.key] = val === null || val === undefined ? "" : String(val);
+      }
+    }
+    return formatted;
+  });
+  const colWidths = columns.map((col, _i) => {
+    const headerWidth = stripAnsi(col.header).length;
+    const minWidth = col.minWidth ?? headerWidth;
+    let maxContent = headerWidth;
+    for (const row of formattedRows) {
+      const cellWidth = stripAnsi(row[col.key] ?? "").length;
+      if (cellWidth > maxContent)
+        maxContent = cellWidth;
+    }
+    let width = Math.max(minWidth, maxContent);
+    if (col.maxWidth && col.maxWidth > 0) {
+      width = Math.min(width, col.maxWidth);
+    }
+    return width;
+  });
+  const totalWidth = indent + colWidths.reduce((s, w) => s + w, 0) + gap * (columns.length - 1);
+  if (totalWidth > termWidth && columns.length > 1) {
+    const overflow = totalWidth - termWidth;
+    let widestIdx = 0;
+    let widestSize = 0;
+    for (let i = 0;i < columns.length; i++) {
+      if (!columns[i].maxWidth && colWidths[i] > widestSize) {
+        widestSize = colWidths[i];
+        widestIdx = i;
+      }
+    }
+    colWidths[widestIdx] = Math.max(10, colWidths[widestIdx] - overflow);
+  }
+  const lines = [];
+  const headerParts = columns.map((col, i) => alignCell(bold2(col.header), colWidths[i], col.align ?? "left"));
+  lines.push(`${indentStr}${headerParts.join(" ".repeat(gap))}`);
+  if (headerSeparator) {
+    const sep = columns.map((_, i) => gray2("─".repeat(colWidths[i]))).join(" ".repeat(gap));
+    lines.push(`${indentStr}${sep}`);
+  }
+  const displayRows = maxRows > 0 ? formattedRows.slice(0, maxRows) : formattedRows;
+  for (const row of displayRows) {
+    const cellParts = columns.map((col, i) => {
+      const raw = row[col.key] ?? "";
+      return alignCell(raw, colWidths[i], col.align ?? "left");
+    });
+    lines.push(`${indentStr}${cellParts.join(" ".repeat(gap))}`);
+  }
+  if (maxRows > 0 && formattedRows.length > maxRows) {
+    const remaining = formattedRows.length - maxRows;
+    lines.push(`${indentStr}${dim2(`... and ${remaining} more`)}`);
+  }
+  return lines.join(`
+`);
+}
+function alignCell(text, width, align) {
+  const visual = stripAnsi(text).length;
+  if (visual > width) {
+    const stripped = stripAnsi(text);
+    return `${stripped.slice(0, width - 1)}…`;
+  }
+  const padding = width - visual;
+  switch (align) {
+    case "right":
+      return " ".repeat(padding) + text;
+    case "center": {
+      const left = Math.floor(padding / 2);
+      const right = padding - left;
+      return " ".repeat(left) + text + " ".repeat(right);
+    }
+    default:
+      return text + " ".repeat(padding);
+  }
+}
+function renderDetails(entries, options = {}) {
+  const { indent = 2, labelWidth: fixedWidth } = options;
+  const indentStr = " ".repeat(indent);
+  const labelWidth = fixedWidth ?? Math.max(...entries.map((e) => stripAnsi(e.label).length)) + 1;
+  return entries.map((entry) => {
+    const label = padEnd(dim2(`${entry.label}:`), labelWidth + 1);
+    return `${indentStr}${label} ${entry.value}`;
+  }).join(`
+`);
+}
+var init_table = __esm(() => {
+  init_terminal();
+});
+
+// src/skills/types.ts
+var REGISTRY_REPO = "locusai/skills", REGISTRY_BRANCH = "main", SKILLS_LOCK_FILENAME = "skills-lock.json", CLAUDE_SKILLS_DIR = ".claude/skills", AGENTS_SKILLS_DIR = ".agents/skills";
+
+// src/skills/lock.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join10 } from "node:path";
+function readLockFile(projectRoot) {
+  const filePath = join10(projectRoot, SKILLS_LOCK_FILENAME);
+  try {
+    const raw = readFileSync7(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { ...DEFAULT_LOCK_FILE, skills: {} };
+  }
+}
+function writeLockFile(projectRoot, lockFile) {
+  const filePath = join10(projectRoot, SKILLS_LOCK_FILENAME);
+  writeFileSync7(filePath, `${JSON.stringify(lockFile, null, 2)}
+`, "utf-8");
+}
+function computeSkillHash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+var DEFAULT_LOCK_FILE;
+var init_lock = __esm(() => {
+  DEFAULT_LOCK_FILE = { version: 1, skills: {} };
+});
+
+// src/skills/installer.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, rmSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join11 } from "node:path";
+async function installSkill(projectRoot, name, content, source) {
+  const claudeDir = join11(projectRoot, CLAUDE_SKILLS_DIR, name);
+  const agentsDir = join11(projectRoot, AGENTS_SKILLS_DIR, name);
+  mkdirSync8(claudeDir, { recursive: true });
+  mkdirSync8(agentsDir, { recursive: true });
+  writeFileSync8(join11(claudeDir, "SKILL.md"), content, "utf-8");
+  writeFileSync8(join11(agentsDir, "SKILL.md"), content, "utf-8");
+  const lock = readLockFile(projectRoot);
+  lock.skills[name] = {
+    source,
+    sourceType: "github",
+    computedHash: computeSkillHash(content)
+  };
+  writeLockFile(projectRoot, lock);
+}
+async function removeSkill(projectRoot, name) {
+  if (!isSkillInstalled(projectRoot, name)) {
+    console.warn(`Skill "${name}" is not installed.`);
+    return;
+  }
+  const claudeDir = join11(projectRoot, CLAUDE_SKILLS_DIR, name);
+  const agentsDir = join11(projectRoot, AGENTS_SKILLS_DIR, name);
+  if (existsSync11(claudeDir)) {
+    rmSync(claudeDir, { recursive: true, force: true });
+  }
+  if (existsSync11(agentsDir)) {
+    rmSync(agentsDir, { recursive: true, force: true });
+  }
+  const lock = readLockFile(projectRoot);
+  delete lock.skills[name];
+  writeLockFile(projectRoot, lock);
+}
+function isSkillInstalled(projectRoot, name) {
+  const lock = readLockFile(projectRoot);
+  return name in lock.skills;
+}
+var init_installer = __esm(() => {
+  init_lock();
+});
+
+// src/skills/registry.ts
+async function fetchRegistry() {
+  const url = `${RAW_BASE}/registry.json`;
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    throw new Error(`Failed to reach the skill registry at ${url}: ${err.message}`);
+  }
+  if (!res.ok) {
+    throw new Error(`Failed to fetch skill registry (HTTP ${res.status}). Check your network connection and try again.`);
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error("Skill registry returned invalid JSON.");
+  }
+  if (!data || typeof data !== "object" || !Array.isArray(data.skills)) {
+    throw new Error("Skill registry has an unexpected format (missing 'skills' array).");
+  }
+  return data;
+}
+async function fetchSkillContent(path) {
+  const url = `${RAW_BASE}/${path}`;
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    throw new Error(`Failed to fetch skill file at ${url}: ${err.message}`);
+  }
+  if (res.status === 404) {
+    throw new Error(`Skill not found: ${path}`);
+  }
+  if (!res.ok) {
+    throw new Error(`Failed to fetch skill file (HTTP ${res.status}): ${path}`);
+  }
+  return res.text();
+}
+function findSkillInRegistry(registry, name) {
+  return registry.skills.find((s) => s.name === name);
+}
+var RAW_BASE;
+var init_registry2 = __esm(() => {
+  RAW_BASE = `https://raw.githubusercontent.com/${REGISTRY_REPO}/${REGISTRY_BRANCH}`;
+});
+
+// src/commands/skills.ts
+var exports_skills = {};
+__export(exports_skills, {
+  skillsCommand: () => skillsCommand
+});
+async function listRemoteSkills() {
+  let registry;
+  try {
+    registry = await fetchRegistry();
+  } catch (err) {
+    process.stderr.write(`${red2("✗")} Failed to fetch skills registry. Check your internet connection.
+`);
+    process.stderr.write(`  ${dim2(err.message)}
+`);
+    process.exit(1);
+  }
+  if (registry.skills.length === 0) {
+    process.stderr.write(`${dim2("No skills available in the registry.")}
+`);
+    return;
+  }
+  process.stderr.write(`
+${bold2("Available Skills")}
+
+`);
+  const columns = [
+    { key: "name", header: "Name", minWidth: 12, maxWidth: 24 },
+    { key: "description", header: "Description", minWidth: 20, maxWidth: 50 },
+    {
+      key: "platforms",
+      header: "Platforms",
+      minWidth: 10,
+      maxWidth: 30,
+      format: (val) => dim2(val.join(", "))
+    }
+  ];
+  const rows = registry.skills.map((s) => ({
+    name: cyan2(s.name),
+    description: s.description,
+    platforms: s.platforms
+  }));
+  process.stderr.write(`${renderTable(columns, rows)}
+
+`);
+  process.stderr.write(`  ${dim2(`${registry.skills.length} skill(s) available.`)} Install with: ${bold2("locus skills install <name>")}
+
+`);
+}
+function listInstalledSkills() {
+  const cwd = process.cwd();
+  const lockFile = readLockFile(cwd);
+  const entries = Object.entries(lockFile.skills);
+  if (entries.length === 0) {
+    process.stderr.write(`${yellow2("⚠")}  No skills installed.
+`);
+    process.stderr.write(`  Browse available skills with: ${bold2("locus skills list")}
+`);
+    return;
+  }
+  process.stderr.write(`
+${bold2("Installed Skills")}
+
+`);
+  const columns = [
+    { key: "name", header: "Name", minWidth: 12, maxWidth: 24 },
+    { key: "source", header: "Source", minWidth: 10, maxWidth: 40 },
+    {
+      key: "hash",
+      header: "Hash",
+      minWidth: 10,
+      maxWidth: 16,
+      format: (val) => dim2(val.slice(0, 12))
+    }
+  ];
+  const rows = entries.map(([name, entry]) => ({
+    name: cyan2(name),
+    source: entry.source,
+    hash: entry.computedHash
+  }));
+  process.stderr.write(`${renderTable(columns, rows)}
+
+`);
+  process.stderr.write(`  ${dim2(`${entries.length} skill(s) installed.`)}
+
+`);
+}
+async function installRemoteSkill(name) {
+  if (!name) {
+    process.stderr.write(`${red2("✗")} Please specify a skill name.
+`);
+    process.stderr.write(`  Usage: ${bold2("locus skills install <name>")}
+`);
+    process.exit(1);
+  }
+  let registry;
+  try {
+    registry = await fetchRegistry();
+  } catch (err) {
+    process.stderr.write(`${red2("✗")} Failed to fetch skills registry. Check your internet connection.
+`);
+    process.stderr.write(`  ${dim2(err.message)}
+`);
+    process.exit(1);
+  }
+  const entry = findSkillInRegistry(registry, name);
+  if (!entry) {
+    process.stderr.write(`${red2("✗")} Skill '${bold2(name)}' not found in the registry.
+`);
+    process.stderr.write(`  Run ${bold2("locus skills list")} to see available skills.
+`);
+    process.exit(1);
+  }
+  let content;
+  try {
+    content = await fetchSkillContent(entry.path);
+  } catch (err) {
+    process.stderr.write(`${red2("✗")} Failed to download skill '${name}'.
+`);
+    process.stderr.write(`  ${dim2(err.message)}
+`);
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const source = `${REGISTRY_REPO}/${entry.path}`;
+  await installSkill(cwd, name, content, source);
+  process.stderr.write(`
+${green("✓")} Installed skill '${bold2(name)}' from ${REGISTRY_REPO}
+`);
+  process.stderr.write(`  → ${CLAUDE_SKILLS_DIR}/${name}/SKILL.md
+`);
+  process.stderr.write(`  → ${AGENTS_SKILLS_DIR}/${name}/SKILL.md
+
+`);
+}
+async function removeInstalledSkill(name) {
+  if (!name) {
+    process.stderr.write(`${red2("✗")} Please specify a skill name.
+`);
+    process.stderr.write(`  Usage: ${bold2("locus skills remove <name>")}
+`);
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  if (!isSkillInstalled(cwd, name)) {
+    process.stderr.write(`${red2("✗")} Skill '${bold2(name)}' is not installed.
+`);
+    process.stderr.write(`  Run ${bold2("locus skills list --installed")} to see installed skills.
+`);
+    process.exit(1);
+  }
+  await removeSkill(cwd, name);
+  process.stderr.write(`${green("✓")} Removed skill '${bold2(name)}'
+`);
+}
+async function updateSkills(name) {
+  const cwd = process.cwd();
+  const lockFile = readLockFile(cwd);
+  const installed = Object.entries(lockFile.skills);
+  if (installed.length === 0) {
+    process.stderr.write(`${yellow2("⚠")}  No skills installed.
+`);
+    process.stderr.write(`  Install skills with: ${bold2("locus skills install <name>")}
+`);
+    return;
+  }
+  const targets = name ? installed.filter(([n]) => n === name) : installed;
+  if (name && targets.length === 0) {
+    process.stderr.write(`${red2("✗")} Skill '${bold2(name)}' is not installed.
+`);
+    process.stderr.write(`  Run ${bold2("locus skills list --installed")} to see installed skills.
+`);
+    process.exit(1);
+  }
+  let registry;
+  try {
+    registry = await fetchRegistry();
+  } catch (err) {
+    process.stderr.write(`${red2("✗")} Failed to fetch skills registry. Check your internet connection.
+`);
+    process.stderr.write(`  ${dim2(err.message)}
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`
+`);
+  let updatedCount = 0;
+  for (const [skillName, lockEntry] of targets) {
+    const entry = findSkillInRegistry(registry, skillName);
+    if (!entry) {
+      process.stderr.write(`${yellow2("⚠")}  '${bold2(skillName)}' is no longer in the registry (skipped)
+`);
+      continue;
+    }
+    let content;
+    try {
+      content = await fetchSkillContent(entry.path);
+    } catch (err) {
+      process.stderr.write(`${red2("✗")} Failed to download skill '${skillName}': ${dim2(err.message)}
+`);
+      continue;
+    }
+    const newHash = computeSkillHash(content);
+    if (newHash === lockEntry.computedHash) {
+      process.stderr.write(`  '${cyan2(skillName)}' is already up to date
+`);
+      continue;
+    }
+    const source = `${REGISTRY_REPO}/${entry.path}`;
+    await installSkill(cwd, skillName, content, source);
+    updatedCount++;
+    process.stderr.write(`${green("✓")} Updated '${bold2(skillName)}' (hash changed)
+`);
+  }
+  process.stderr.write(`
+`);
+  if (updatedCount === 0) {
+    process.stderr.write(`  ${dim2("All skills are up to date.")}
+
+`);
+  } else {
+    process.stderr.write(`  ${dim2(`${updatedCount} skill(s) updated.`)}
+
+`);
+  }
+}
+async function infoSkill(name) {
+  if (!name) {
+    process.stderr.write(`${red2("✗")} Please specify a skill name.
+`);
+    process.stderr.write(`  Usage: ${bold2("locus skills info <name>")}
+`);
+    process.exit(1);
+  }
+  let registry;
+  try {
+    registry = await fetchRegistry();
+  } catch (err) {
+    process.stderr.write(`${red2("✗")} Failed to fetch skills registry. Check your internet connection.
+`);
+    process.stderr.write(`  ${dim2(err.message)}
+`);
+    process.exit(1);
+  }
+  const entry = findSkillInRegistry(registry, name);
+  const cwd = process.cwd();
+  const lockFile = readLockFile(cwd);
+  const lockEntry = lockFile.skills[name];
+  if (!entry && !lockEntry) {
+    process.stderr.write(`${red2("✗")} Skill '${bold2(name)}' not found in the registry or locally.
+`);
+    process.stderr.write(`  Run ${bold2("locus skills list")} to see available skills.
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`
+${bold2("Skill Information")}
+
+`);
+  if (entry) {
+    process.stderr.write(`  ${bold2("Name:")}         ${cyan2(entry.name)}
+`);
+    process.stderr.write(`  ${bold2("Description:")}  ${entry.description}
+`);
+    process.stderr.write(`  ${bold2("Platforms:")}    ${entry.platforms.join(", ")}
+`);
+    process.stderr.write(`  ${bold2("Tags:")}         ${entry.tags.join(", ")}
+`);
+    process.stderr.write(`  ${bold2("Author:")}       ${entry.author}
+`);
+    process.stderr.write(`  ${bold2("Source:")}       ${REGISTRY_REPO}/${entry.path}
+`);
+  } else {
+    process.stderr.write(`  ${bold2("Name:")}         ${cyan2(name)}
+`);
+    process.stderr.write(`  ${dim2("(not found in remote registry)")}
+`);
+  }
+  process.stderr.write(`
+`);
+  if (lockEntry) {
+    process.stderr.write(`  ${bold2("Installed:")}    ${green("yes")}
+`);
+    process.stderr.write(`  ${bold2("Hash:")}         ${dim2(lockEntry.computedHash.slice(0, 10))}
+`);
+    process.stderr.write(`  ${bold2("Source:")}       ${lockEntry.source}
+`);
+  } else {
+    process.stderr.write(`  ${bold2("Installed:")}    ${dim2("no")}
+`);
+  }
+  process.stderr.write(`
+`);
+}
+function printSkillsHelp() {
+  process.stderr.write(`
+${bold2("Usage:")}
+  locus skills <subcommand> [options]
+
+${bold2("Subcommands:")}
+  ${cyan2("list")}              List available skills from the registry
+  ${cyan2("list")} ${dim2("--installed")}   List locally installed skills
+  ${cyan2("install")} ${dim2("<name>")}    Install a skill from the registry
+  ${cyan2("remove")} ${dim2("<name>")}     Remove an installed skill
+  ${cyan2("update")} ${dim2("[name]")}     Update installed skill(s) from registry
+  ${cyan2("info")} ${dim2("<name>")}       Show skill metadata and install status
+
+${bold2("Examples:")}
+  locus skills list                   ${dim2("# Browse available skills")}
+  locus skills list --installed       ${dim2("# Show installed skills")}
+  locus skills install code-review    ${dim2("# Install a skill")}
+  locus skills remove code-review     ${dim2("# Remove a skill")}
+  locus skills update                 ${dim2("# Update all installed skills")}
+  locus skills info code-review       ${dim2("# Show skill details")}
+
+`);
+}
+async function skillsCommand(args, flags) {
+  const subcommand = args[0] ?? "list";
+  switch (subcommand) {
+    case "help": {
+      printSkillsHelp();
+      break;
+    }
+    case "list": {
+      const isInstalled = flags.installed !== undefined || args.includes("--installed");
+      if (isInstalled) {
+        listInstalledSkills();
+      } else {
+        await listRemoteSkills();
+      }
+      break;
+    }
+    case "install": {
+      const skillName = args[1];
+      await installRemoteSkill(skillName);
+      break;
+    }
+    case "remove": {
+      const skillName = args[1];
+      await removeInstalledSkill(skillName);
+      break;
+    }
+    case "update": {
+      const skillName = args[1];
+      await updateSkills(skillName);
+      break;
+    }
+    case "info": {
+      const skillName = args[1];
+      await infoSkill(skillName);
+      break;
+    }
+    default:
+      process.stderr.write(`${red2("✗")} Unknown subcommand: ${bold2(subcommand)}
+`);
+      process.stderr.write(`  Available: ${bold2("list")}, ${bold2("install")}, ${bold2("remove")}, ${bold2("update")}, ${bold2("info")}
+`);
+      process.exit(1);
+  }
+}
+var init_skills = __esm(() => {
+  init_table();
+  init_terminal();
+  init_installer();
+  init_lock();
+  init_registry2();
+});
+
 // src/commands/config.ts
 var exports_config = {};
 __export(exports_config, {
@@ -3277,10 +3872,7 @@ ${bold2("Locus Configuration")}
     },
     {
       title: "Sprint",
-      entries: [
-        ["Active", config.sprint.active ?? dim2("(none)")],
-        ["Stop on Failure", String(config.sprint.stopOnFailure)]
-      ]
+      entries: [["Stop on Failure", String(config.sprint.stopOnFailure)]]
     },
     {
       title: "Logging",
@@ -3353,16 +3945,16 @@ __export(exports_logs, {
   logsCommand: () => logsCommand
 });
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   statSync as statSync2,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join12 } from "node:path";
 async function logsCommand(cwd, options) {
-  const logsDir = join10(cwd, ".locus", "logs");
-  if (!existsSync11(logsDir)) {
+  const logsDir = join12(cwd, ".locus", "logs");
+  if (!existsSync12(logsDir)) {
     process.stderr.write(`${dim2("No logs found.")}
 `);
     return;
@@ -3382,7 +3974,7 @@ async function logsCommand(cwd, options) {
   return viewLog(logFiles[0], options.level, options.lines ?? 50);
 }
 function viewLog(logFile, levelFilter, maxLines) {
-  const content = readFileSync7(logFile, "utf-8");
+  const content = readFileSync8(logFile, "utf-8");
   const lines = content.trim().split(`
 `).filter(Boolean);
   process.stderr.write(`
@@ -3417,9 +4009,9 @@ async function tailLog(logFile, levelFilter) {
   process.stderr.write(`${bold2("Tailing:")} ${dim2(logFile)} ${dim2("(Ctrl+C to stop)")}
 
 `);
-  let lastSize = existsSync11(logFile) ? statSync2(logFile).size : 0;
-  if (existsSync11(logFile)) {
-    const content = readFileSync7(logFile, "utf-8");
+  let lastSize = existsSync12(logFile) ? statSync2(logFile).size : 0;
+  if (existsSync12(logFile)) {
+    const content = readFileSync8(logFile, "utf-8");
     const lines = content.trim().split(`
 `).filter(Boolean);
     const recent = lines.slice(-10);
@@ -3437,12 +4029,12 @@ async function tailLog(logFile, levelFilter) {
   }
   return new Promise((resolve) => {
     const interval = setInterval(() => {
-      if (!existsSync11(logFile))
+      if (!existsSync12(logFile))
         return;
       const currentSize = statSync2(logFile).size;
       if (currentSize <= lastSize)
         return;
-      const content = readFileSync7(logFile, "utf-8");
+      const content = readFileSync8(logFile, "utf-8");
       const allLines = content.trim().split(`
 `).filter(Boolean);
       const oldContent = content.slice(0, lastSize);
@@ -3497,7 +4089,7 @@ function cleanLogs(logsDir) {
 `);
 }
 function getLogFiles(logsDir) {
-  return readdirSync2(logsDir).filter((f) => f.startsWith("locus-") && f.endsWith(".log")).map((f) => join10(logsDir, f)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
+  return readdirSync2(logsDir).filter((f) => f.startsWith("locus-") && f.endsWith(".log")).map((f) => join12(logsDir, f)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
 }
 function formatEntry(entry) {
   const time = dim2(new Date(entry.ts).toLocaleTimeString());
@@ -3807,9 +4399,9 @@ var init_stream_renderer = __esm(() => {
 
 // src/repl/clipboard.ts
 import { execSync as execSync6 } from "node:child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync8 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 function readClipboardImage() {
   if (process.platform === "darwin") {
     return readMacOSClipboardImage();
@@ -3820,14 +4412,14 @@ function readClipboardImage() {
   return null;
 }
 function ensureStableDir() {
-  if (!existsSync12(STABLE_DIR)) {
-    mkdirSync8(STABLE_DIR, { recursive: true });
+  if (!existsSync13(STABLE_DIR)) {
+    mkdirSync9(STABLE_DIR, { recursive: true });
   }
 }
 function readMacOSClipboardImage() {
   try {
     ensureStableDir();
-    const destPath = join11(STABLE_DIR, `clipboard-${Date.now()}.png`);
+    const destPath = join13(STABLE_DIR, `clipboard-${Date.now()}.png`);
     const script = [
       `set destPath to POSIX file "${destPath}"`,
       "try",
@@ -3851,7 +4443,7 @@ function readMacOSClipboardImage() {
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    if (result === "ok" && existsSync12(destPath)) {
+    if (result === "ok" && existsSync13(destPath)) {
       return destPath;
     }
   } catch {}
@@ -3864,9 +4456,9 @@ function readLinuxClipboardImage() {
       return null;
     }
     ensureStableDir();
-    const destPath = join11(STABLE_DIR, `clipboard-${Date.now()}.png`);
+    const destPath = join13(STABLE_DIR, `clipboard-${Date.now()}.png`);
     execSync6(`xclip -selection clipboard -t image/png -o > "${destPath}" 2>/dev/null`, { timeout: 5000 });
-    if (existsSync12(destPath)) {
+    if (existsSync13(destPath)) {
       return destPath;
     }
   } catch {}
@@ -3874,13 +4466,13 @@ function readLinuxClipboardImage() {
 }
 var STABLE_DIR;
 var init_clipboard = __esm(() => {
-  STABLE_DIR = join11(tmpdir(), "locus-images");
+  STABLE_DIR = join13(tmpdir(), "locus-images");
 });
 
 // src/repl/image-detect.ts
-import { copyFileSync, existsSync as existsSync13, mkdirSync as mkdirSync9 } from "node:fs";
+import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync10 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { basename, extname, join as join12, resolve } from "node:path";
+import { basename, extname, join as join14, resolve } from "node:path";
 function detectImages(input) {
   const detected = [];
   const byResolved = new Map;
@@ -3974,15 +4566,15 @@ function collectReferencedAttachments(input, attachments) {
   return dedupeByResolvedPath(selected);
 }
 function relocateImages(images, projectRoot) {
-  const targetDir = join12(projectRoot, ".locus", "tmp", "images");
+  const targetDir = join14(projectRoot, ".locus", "tmp", "images");
   for (const img of images) {
     if (!img.exists)
       continue;
     try {
-      if (!existsSync13(targetDir)) {
-        mkdirSync9(targetDir, { recursive: true });
+      if (!existsSync14(targetDir)) {
+        mkdirSync10(targetDir, { recursive: true });
       }
-      const dest = join12(targetDir, basename(img.stablePath));
+      const dest = join14(targetDir, basename(img.stablePath));
       copyFileSync(img.stablePath, dest);
       img.stablePath = dest;
     } catch {}
@@ -3994,7 +4586,7 @@ function addIfImage(rawPath, rawMatch, detected, byResolved) {
     return;
   let resolved = stripQuotes(rawPath).replace(/\\ /g, " ");
   if (resolved.startsWith("~/")) {
-    resolved = join12(homedir3(), resolved.slice(2));
+    resolved = join14(homedir3(), resolved.slice(2));
   }
   resolved = resolve(resolved);
   const existing = byResolved.get(resolved);
@@ -4007,7 +4599,7 @@ function addIfImage(rawPath, rawMatch, detected, byResolved) {
     ]);
     return;
   }
-  const exists = existsSync13(resolved);
+  const exists = existsSync14(resolved);
   let stablePath = resolved;
   if (exists) {
     stablePath = copyToStable(resolved);
@@ -4061,10 +4653,10 @@ function dedupeByResolvedPath(images) {
 }
 function copyToStable(sourcePath) {
   try {
-    if (!existsSync13(STABLE_DIR2)) {
-      mkdirSync9(STABLE_DIR2, { recursive: true });
+    if (!existsSync14(STABLE_DIR2)) {
+      mkdirSync10(STABLE_DIR2, { recursive: true });
     }
-    const dest = join12(STABLE_DIR2, `${Date.now()}-${basename(sourcePath)}`);
+    const dest = join14(STABLE_DIR2, `${Date.now()}-${basename(sourcePath)}`);
     copyFileSync(sourcePath, dest);
     return dest;
   } catch {
@@ -4084,7 +4676,7 @@ var init_image_detect = __esm(() => {
     ".tif",
     ".tiff"
   ]);
-  STABLE_DIR2 = join12(tmpdir2(), "locus-images");
+  STABLE_DIR2 = join14(tmpdir2(), "locus-images");
   PLACEHOLDER_ID_PATTERN = /\(locus:\/\/screenshot-(\d+)\)/g;
 });
 
@@ -5093,21 +5685,21 @@ var init_claude = __esm(() => {
 import { exec } from "node:child_process";
 import {
   cpSync,
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync10,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync11,
   mkdtempSync,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync8,
-  rmSync,
+  readFileSync as readFileSync9,
+  rmSync as rmSync2,
   statSync as statSync3
 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname3, join as join13, relative } from "node:path";
+import { dirname as dirname3, join as join15, relative } from "node:path";
 import { promisify } from "node:util";
 function parseIgnoreFile(filePath) {
-  if (!existsSync14(filePath))
+  if (!existsSync15(filePath))
     return [];
-  const content = readFileSync8(filePath, "utf-8");
+  const content = readFileSync9(filePath, "utf-8");
   const rules = [];
   for (const rawLine of content.split(`
 `)) {
@@ -5175,7 +5767,7 @@ function findIgnoredPaths(projectRoot, rules) {
     for (const name of entries) {
       if (SKIP_DIRS.has(name))
         continue;
-      const fullPath = join13(dir, name);
+      const fullPath = join15(dir, name);
       let stat = null;
       try {
         stat = statSync3(fullPath);
@@ -5209,7 +5801,7 @@ function findIgnoredPaths(projectRoot, rules) {
 }
 function backupIgnoredFiles(projectRoot) {
   const log = getLogger();
-  const ignorePath = join13(projectRoot, ".sandboxignore");
+  const ignorePath = join15(projectRoot, ".sandboxignore");
   const rules = parseIgnoreFile(ignorePath);
   if (rules.length === 0)
     return NOOP_BACKUP;
@@ -5218,7 +5810,7 @@ function backupIgnoredFiles(projectRoot) {
     return NOOP_BACKUP;
   let backupDir;
   try {
-    backupDir = mkdtempSync(join13(tmpdir3(), "locus-sandbox-backup-"));
+    backupDir = mkdtempSync(join15(tmpdir3(), "locus-sandbox-backup-"));
   } catch (err) {
     log.debug("Failed to create sandbox backup dir", {
       error: err instanceof Error ? err.message : String(err)
@@ -5228,9 +5820,9 @@ function backupIgnoredFiles(projectRoot) {
   const backed = [];
   for (const src of paths) {
     const rel = relative(projectRoot, src);
-    const dest = join13(backupDir, rel);
+    const dest = join15(backupDir, rel);
     try {
-      mkdirSync10(dirname3(dest), { recursive: true });
+      mkdirSync11(dirname3(dest), { recursive: true });
       cpSync(src, dest, { recursive: true, preserveTimestamps: true });
       backed.push({ src, dest });
     } catch (err) {
@@ -5241,7 +5833,7 @@ function backupIgnoredFiles(projectRoot) {
     }
   }
   if (backed.length === 0) {
-    rmSync(backupDir, { recursive: true, force: true });
+    rmSync2(backupDir, { recursive: true, force: true });
     return NOOP_BACKUP;
   }
   log.debug("Backed up sandbox-ignored files", {
@@ -5252,7 +5844,7 @@ function backupIgnoredFiles(projectRoot) {
     restore() {
       for (const { src, dest } of backed) {
         try {
-          mkdirSync10(dirname3(src), { recursive: true });
+          mkdirSync11(dirname3(src), { recursive: true });
           cpSync(dest, src, { recursive: true, preserveTimestamps: true });
         } catch (err) {
           log.debug("Failed to restore ignored file (potential data loss)", {
@@ -5262,7 +5854,7 @@ function backupIgnoredFiles(projectRoot) {
         }
       }
       try {
-        rmSync(backupDir, { recursive: true, force: true });
+        rmSync2(backupDir, { recursive: true, force: true });
       } catch {}
       log.debug("Restored sandbox-ignored files", { count: backed.length });
     }
@@ -5270,7 +5862,7 @@ function backupIgnoredFiles(projectRoot) {
 }
 async function enforceSandboxIgnore(sandboxName, projectRoot, containerWorkdir) {
   const log = getLogger();
-  const ignorePath = join13(projectRoot, ".sandboxignore");
+  const ignorePath = join15(projectRoot, ".sandboxignore");
   const rules = parseIgnoreFile(ignorePath);
   if (rules.length === 0)
     return;
@@ -5488,17 +6080,22 @@ class SandboxedClaudeRunner {
       timer.unref();
   }
   async isSandboxRunning() {
-    try {
-      const { promisify: promisify2 } = await import("node:util");
-      const { exec: exec2 } = await import("node:child_process");
-      const execAsync2 = promisify2(exec2);
-      const { stdout } = await execAsync2("docker sandbox ls", {
-        timeout: 5000
-      });
-      return stdout.includes(this.sandboxName);
-    } catch {
-      return false;
+    const { promisify: promisify2 } = await import("node:util");
+    const { exec: exec2 } = await import("node:child_process");
+    const execAsync2 = promisify2(exec2);
+    for (let attempt = 0;attempt < 3; attempt++) {
+      try {
+        const { stdout } = await execAsync2("docker sandbox ls", {
+          timeout: 15000
+        });
+        return stdout.includes(this.sandboxName);
+      } catch {
+        if (attempt < 2) {
+          await new Promise((r) => setTimeout(r, 2000));
+        }
+      }
     }
+    return false;
   }
 }
 function formatToolCall2(name, input) {
@@ -5899,17 +6496,22 @@ class SandboxedCodexRunner {
       timer.unref();
   }
   async isSandboxRunning() {
-    try {
-      const { promisify: promisify2 } = await import("node:util");
-      const { exec: exec2 } = await import("node:child_process");
-      const execAsync2 = promisify2(exec2);
-      const { stdout } = await execAsync2("docker sandbox ls", {
-        timeout: 5000
-      });
-      return stdout.includes(this.sandboxName);
-    } catch {
-      return false;
+    const { promisify: promisify2 } = await import("node:util");
+    const { exec: exec2 } = await import("node:child_process");
+    const execAsync2 = promisify2(exec2);
+    for (let attempt = 0;attempt < 3; attempt++) {
+      try {
+        const { stdout } = await execAsync2("docker sandbox ls", {
+          timeout: 15000
+        });
+        return stdout.includes(this.sandboxName);
+      } catch {
+        if (attempt < 2) {
+          await new Promise((r) => setTimeout(r, 2000));
+        }
+      }
     }
+    return false;
   }
   async ensureCodexInstalled(name) {
     const { promisify: promisify2 } = await import("node:util");
@@ -6166,115 +6768,6 @@ var init_run_ai = __esm(() => {
   init_runner();
 });
 
-// src/display/table.ts
-function renderTable(columns, rows, options = {}) {
-  const {
-    indent = 2,
-    headerSeparator = true,
-    maxRows = 0,
-    emptyMessage = "No results."
-  } = options;
-  if (rows.length === 0) {
-    return `${" ".repeat(indent)}${dim2(emptyMessage)}`;
-  }
-  const termWidth = getCapabilities().columns;
-  const indentStr = " ".repeat(indent);
-  const gap = 2;
-  const formattedRows = rows.map((row) => {
-    const formatted = {};
-    for (const col of columns) {
-      if (col.format) {
-        formatted[col.key] = col.format(row[col.key], row);
-      } else {
-        const val = row[col.key];
-        formatted[col.key] = val === null || val === undefined ? "" : String(val);
-      }
-    }
-    return formatted;
-  });
-  const colWidths = columns.map((col, _i) => {
-    const headerWidth = stripAnsi(col.header).length;
-    const minWidth = col.minWidth ?? headerWidth;
-    let maxContent = headerWidth;
-    for (const row of formattedRows) {
-      const cellWidth = stripAnsi(row[col.key] ?? "").length;
-      if (cellWidth > maxContent)
-        maxContent = cellWidth;
-    }
-    let width = Math.max(minWidth, maxContent);
-    if (col.maxWidth && col.maxWidth > 0) {
-      width = Math.min(width, col.maxWidth);
-    }
-    return width;
-  });
-  const totalWidth = indent + colWidths.reduce((s, w) => s + w, 0) + gap * (columns.length - 1);
-  if (totalWidth > termWidth && columns.length > 1) {
-    const overflow = totalWidth - termWidth;
-    let widestIdx = 0;
-    let widestSize = 0;
-    for (let i = 0;i < columns.length; i++) {
-      if (!columns[i].maxWidth && colWidths[i] > widestSize) {
-        widestSize = colWidths[i];
-        widestIdx = i;
-      }
-    }
-    colWidths[widestIdx] = Math.max(10, colWidths[widestIdx] - overflow);
-  }
-  const lines = [];
-  const headerParts = columns.map((col, i) => alignCell(bold2(col.header), colWidths[i], col.align ?? "left"));
-  lines.push(`${indentStr}${headerParts.join(" ".repeat(gap))}`);
-  if (headerSeparator) {
-    const sep = columns.map((_, i) => gray2("─".repeat(colWidths[i]))).join(" ".repeat(gap));
-    lines.push(`${indentStr}${sep}`);
-  }
-  const displayRows = maxRows > 0 ? formattedRows.slice(0, maxRows) : formattedRows;
-  for (const row of displayRows) {
-    const cellParts = columns.map((col, i) => {
-      const raw = row[col.key] ?? "";
-      return alignCell(raw, colWidths[i], col.align ?? "left");
-    });
-    lines.push(`${indentStr}${cellParts.join(" ".repeat(gap))}`);
-  }
-  if (maxRows > 0 && formattedRows.length > maxRows) {
-    const remaining = formattedRows.length - maxRows;
-    lines.push(`${indentStr}${dim2(`... and ${remaining} more`)}`);
-  }
-  return lines.join(`
-`);
-}
-function alignCell(text, width, align) {
-  const visual = stripAnsi(text).length;
-  if (visual > width) {
-    const stripped = stripAnsi(text);
-    return `${stripped.slice(0, width - 1)}…`;
-  }
-  const padding = width - visual;
-  switch (align) {
-    case "right":
-      return " ".repeat(padding) + text;
-    case "center": {
-      const left = Math.floor(padding / 2);
-      const right = padding - left;
-      return " ".repeat(left) + text + " ".repeat(right);
-    }
-    default:
-      return text + " ".repeat(padding);
-  }
-}
-function renderDetails(entries, options = {}) {
-  const { indent = 2, labelWidth: fixedWidth } = options;
-  const indentStr = " ".repeat(indent);
-  const labelWidth = fixedWidth ?? Math.max(...entries.map((e) => stripAnsi(e.label).length)) + 1;
-  return entries.map((entry) => {
-    const label = padEnd(dim2(`${entry.label}:`), labelWidth + 1);
-    return `${indentStr}${label} ${entry.value}`;
-  }).join(`
-`);
-}
-var init_table = __esm(() => {
-  init_terminal();
-});
-
 // src/commands/issue.ts
 var exports_issue = {};
 __export(exports_issue, {
@@ -7013,9 +7506,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 +7546,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 +7555,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 +7580,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 +7628,6 @@ async function sprintList(projectRoot, parsed) {
     }
   ];
   const rows = milestones.map((m) => ({
-    active: null,
     title: m.title,
     openIssues: m.openIssues,
     closedIssues: m.closedIssues,
@@ -7159,21 +7638,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 +7699,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 +7767,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 +7907,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 +7944,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 +7994,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 +8011,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"
@@ -7603,8 +8028,8 @@ var init_sprint = __esm(() => {
 
 // src/core/prompt-builder.ts
 import { execSync as execSync9 } from "node:child_process";
-import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
+import { join as join16 } from "node:path";
 function buildExecutionPrompt(ctx) {
   const sections = [];
   sections.push(buildSystemContext(ctx.projectRoot));
@@ -7634,7 +8059,7 @@ function buildFeedbackPrompt(ctx) {
 }
 function buildReplPrompt(userMessage, projectRoot, _config, previousMessages) {
   const sections = [];
-  const locusmd = readFileSafe(join14(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join16(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     sections.push(`<project-instructions>
 ${locusmd}
@@ -7663,7 +8088,7 @@ ${userMessage}
 }
 function buildSystemContext(projectRoot) {
   const parts = [];
-  const locusmd = readFileSafe(join14(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join16(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     parts.push(`<project-instructions>
 ${locusmd}
@@ -7671,12 +8096,12 @@ ${locusmd}
   }
   parts.push(`<past-learnings>
 Past learnings are located in \`.locus/LEARNINGS.md\`.</past-learnings>`);
-  const discussionsDir = join14(projectRoot, ".locus", "discussions");
-  if (existsSync15(discussionsDir)) {
+  const discussionsDir = join16(projectRoot, ".locus", "discussions");
+  if (existsSync16(discussionsDir)) {
     try {
       const files = readdirSync4(discussionsDir).filter((f) => f.endsWith(".md")).slice(0, 3);
       for (const file of files) {
-        const content = readFileSafe(join14(discussionsDir, file));
+        const content = readFileSafe(join16(discussionsDir, file));
         if (content) {
           const name = file.replace(".md", "");
           parts.push(`<discussion name="${name}">
@@ -7829,9 +8254,9 @@ function buildFeedbackInstructions() {
 }
 function readFileSafe(path) {
   try {
-    if (!existsSync15(path))
+    if (!existsSync16(path))
       return null;
-    return readFileSync9(path, "utf-8");
+    return readFileSync10(path, "utf-8");
   } catch {
     return null;
   }
@@ -8309,7 +8734,7 @@ var init_commands = __esm(() => {
 
 // src/repl/completions.ts
 import { readdirSync as readdirSync5 } from "node:fs";
-import { basename as basename2, dirname as dirname4, join as join15 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join17 } from "node:path";
 
 class SlashCommandCompletion {
   commands;
@@ -8364,7 +8789,7 @@ class FilePathCompletion {
   }
   findMatches(partial) {
     try {
-      const dir = partial.includes("/") ? join15(this.projectRoot, dirname4(partial)) : this.projectRoot;
+      const dir = partial.includes("/") ? join17(this.projectRoot, dirname4(partial)) : this.projectRoot;
       const prefix = basename2(partial);
       const entries = readdirSync5(dir, { withFileTypes: true });
       return entries.filter((e) => {
@@ -8400,14 +8825,14 @@ class CombinedCompletion {
 var init_completions = () => {};
 
 // src/repl/input-history.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname5, join as join16 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname5, join as join18 } from "node:path";
 
 class InputHistory {
   entries = [];
   filePath;
   constructor(projectRoot) {
-    this.filePath = join16(projectRoot, ".locus", "sessions", ".input-history");
+    this.filePath = join18(projectRoot, ".locus", "sessions", ".input-history");
     this.load();
   }
   add(text) {
@@ -8446,9 +8871,9 @@ class InputHistory {
   }
   load() {
     try {
-      if (!existsSync16(this.filePath))
+      if (!existsSync17(this.filePath))
         return;
-      const content = readFileSync10(this.filePath, "utf-8");
+      const content = readFileSync11(this.filePath, "utf-8");
       this.entries = content.split(`
 `).map((line) => this.unescape(line)).filter(Boolean);
     } catch {}
@@ -8456,12 +8881,12 @@ class InputHistory {
   save() {
     try {
       const dir = dirname5(this.filePath);
-      if (!existsSync16(dir)) {
-        mkdirSync11(dir, { recursive: true });
+      if (!existsSync17(dir)) {
+        mkdirSync12(dir, { recursive: true });
       }
       const content = this.entries.map((e) => this.escape(e)).join(`
 `);
-      writeFileSync7(this.filePath, content, "utf-8");
+      writeFileSync9(this.filePath, content, "utf-8");
     } catch {}
   }
   escape(text) {
@@ -8487,21 +8912,21 @@ var init_model_config = __esm(() => {
 
 // src/repl/session-manager.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync13,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { basename as basename3, join as join17 } from "node:path";
+import { basename as basename3, join as join19 } from "node:path";
 
 class SessionManager {
   sessionsDir;
   constructor(projectRoot) {
-    this.sessionsDir = join17(projectRoot, ".locus", "sessions");
-    if (!existsSync17(this.sessionsDir)) {
-      mkdirSync12(this.sessionsDir, { recursive: true });
+    this.sessionsDir = join19(projectRoot, ".locus", "sessions");
+    if (!existsSync18(this.sessionsDir)) {
+      mkdirSync13(this.sessionsDir, { recursive: true });
     }
   }
   create(options) {
@@ -8526,14 +8951,14 @@ class SessionManager {
   }
   isPersisted(sessionOrId) {
     const sessionId = typeof sessionOrId === "string" ? sessionOrId : sessionOrId.id;
-    return existsSync17(this.getSessionPath(sessionId));
+    return existsSync18(this.getSessionPath(sessionId));
   }
   load(idOrPrefix) {
     const files = this.listSessionFiles();
     const exactPath = this.getSessionPath(idOrPrefix);
-    if (existsSync17(exactPath)) {
+    if (existsSync18(exactPath)) {
       try {
-        return JSON.parse(readFileSync11(exactPath, "utf-8"));
+        return JSON.parse(readFileSync12(exactPath, "utf-8"));
       } catch {
         return null;
       }
@@ -8541,7 +8966,7 @@ class SessionManager {
     const matches = files.filter((f) => basename3(f, ".json").startsWith(idOrPrefix));
     if (matches.length === 1) {
       try {
-        return JSON.parse(readFileSync11(matches[0], "utf-8"));
+        return JSON.parse(readFileSync12(matches[0], "utf-8"));
       } catch {
         return null;
       }
@@ -8554,7 +8979,7 @@ class SessionManager {
   save(session) {
     session.updated = new Date().toISOString();
     const path = this.getSessionPath(session.id);
-    writeFileSync8(path, `${JSON.stringify(session, null, 2)}
+    writeFileSync10(path, `${JSON.stringify(session, null, 2)}
 `, "utf-8");
   }
   addMessage(session, message) {
@@ -8566,7 +8991,7 @@ class SessionManager {
     const sessions = [];
     for (const file of files) {
       try {
-        const session = JSON.parse(readFileSync11(file, "utf-8"));
+        const session = JSON.parse(readFileSync12(file, "utf-8"));
         sessions.push({
           id: session.id,
           created: session.created,
@@ -8581,7 +9006,7 @@ class SessionManager {
   }
   delete(sessionId) {
     const path = this.getSessionPath(sessionId);
-    if (existsSync17(path)) {
+    if (existsSync18(path)) {
       unlinkSync3(path);
       return true;
     }
@@ -8593,7 +9018,7 @@ class SessionManager {
     let pruned = 0;
     const withStats = files.map((f) => {
       try {
-        const session = JSON.parse(readFileSync11(f, "utf-8"));
+        const session = JSON.parse(readFileSync12(f, "utf-8"));
         return { path: f, updated: new Date(session.updated).getTime() };
       } catch {
         return { path: f, updated: 0 };
@@ -8611,7 +9036,7 @@ class SessionManager {
     const remaining = withStats.length - pruned;
     if (remaining > MAX_SESSIONS) {
       const toRemove = remaining - MAX_SESSIONS;
-      const alive = withStats.filter((e) => existsSync17(e.path));
+      const alive = withStats.filter((e) => existsSync18(e.path));
       for (let i = 0;i < toRemove && i < alive.length; i++) {
         try {
           unlinkSync3(alive[i].path);
@@ -8626,7 +9051,7 @@ class SessionManager {
   }
   listSessionFiles() {
     try {
-      return readdirSync6(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join17(this.sessionsDir, f));
+      return readdirSync6(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join19(this.sessionsDir, f));
     } catch {
       return [];
     }
@@ -8635,7 +9060,7 @@ class SessionManager {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
   getSessionPath(sessionId) {
-    return join17(this.sessionsDir, `${sessionId}.json`);
+    return join19(this.sessionsDir, `${sessionId}.json`);
   }
 }
 var MAX_SESSIONS = 50, SESSION_MAX_AGE_MS;
@@ -8646,11 +9071,11 @@ var init_session_manager = __esm(() => {
 
 // src/repl/voice.ts
 import { execSync as execSync11, spawn as spawn6 } from "node:child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync13, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14, unlinkSync as unlinkSync4 } from "node:fs";
 import { cpus, homedir as homedir4, platform, tmpdir as tmpdir4 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 function getWhisperModelPath() {
-  return join18(WHISPER_MODELS_DIR, `ggml-${WHISPER_MODEL}.bin`);
+  return join20(WHISPER_MODELS_DIR, `ggml-${WHISPER_MODEL}.bin`);
 }
 function commandExists(cmd) {
   try {
@@ -8668,16 +9093,16 @@ function findWhisperBinary() {
       return name;
   }
   for (const name of candidates) {
-    const fullPath = join18(LOCUS_BIN_DIR, name);
-    if (existsSync18(fullPath))
+    const fullPath = join20(LOCUS_BIN_DIR, name);
+    if (existsSync19(fullPath))
       return fullPath;
   }
   if (platform() === "darwin") {
     const brewDirs = ["/opt/homebrew/bin", "/usr/local/bin"];
     for (const dir of brewDirs) {
       for (const name of candidates) {
-        const fullPath = join18(dir, name);
-        if (existsSync18(fullPath))
+        const fullPath = join20(dir, name);
+        if (existsSync19(fullPath))
           return fullPath;
       }
     }
@@ -8692,11 +9117,11 @@ function findSoxRecBinary() {
   if (platform() === "darwin") {
     const brewDirs = ["/opt/homebrew/bin", "/usr/local/bin"];
     for (const dir of brewDirs) {
-      const recPath = join18(dir, "rec");
-      if (existsSync18(recPath))
+      const recPath = join20(dir, "rec");
+      if (existsSync19(recPath))
         return recPath;
-      const soxPath = join18(dir, "sox");
-      if (existsSync18(soxPath))
+      const soxPath = join20(dir, "sox");
+      if (existsSync19(soxPath))
         return soxPath;
     }
   }
@@ -8705,7 +9130,7 @@ function findSoxRecBinary() {
 function checkDependencies() {
   const soxBinary = findSoxRecBinary();
   const whisperBinary = findWhisperBinary();
-  const modelDownloaded = existsSync18(getWhisperModelPath());
+  const modelDownloaded = existsSync19(getWhisperModelPath());
   return {
     sox: soxBinary !== null,
     whisper: whisperBinary !== null,
@@ -8859,19 +9284,19 @@ function ensureBuildDeps(pm) {
 }
 function buildWhisperFromSource(pm) {
   const out = process.stderr;
-  const buildDir = join18(tmpdir4(), `locus-whisper-build-${process.pid}`);
+  const buildDir = join20(tmpdir4(), `locus-whisper-build-${process.pid}`);
   if (!ensureBuildDeps(pm)) {
     out.write(`  ${red2("✗")} Could not install build tools (cmake, g++, git).
 `);
     return false;
   }
   try {
-    mkdirSync13(buildDir, { recursive: true });
-    mkdirSync13(LOCUS_BIN_DIR, { recursive: true });
+    mkdirSync14(buildDir, { recursive: true });
+    mkdirSync14(LOCUS_BIN_DIR, { recursive: true });
     out.write(`  ${dim2("Cloning whisper.cpp...")}
 `);
-    execSync11(`git clone --depth 1 https://github.com/ggerganov/whisper.cpp.git "${join18(buildDir, "whisper.cpp")}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
-    const srcDir = join18(buildDir, "whisper.cpp");
+    execSync11(`git clone --depth 1 https://github.com/ggerganov/whisper.cpp.git "${join20(buildDir, "whisper.cpp")}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
+    const srcDir = join20(buildDir, "whisper.cpp");
     const numCpus = cpus().length || 2;
     out.write(`  ${dim2("Building whisper.cpp (this may take a few minutes)...")}
 `);
@@ -8885,13 +9310,13 @@ function buildWhisperFromSource(pm) {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 600000
     });
-    const destPath = join18(LOCUS_BIN_DIR, "whisper-cli");
+    const destPath = join20(LOCUS_BIN_DIR, "whisper-cli");
     const binaryCandidates = [
-      join18(srcDir, "build", "bin", "whisper-cli"),
-      join18(srcDir, "build", "bin", "main")
+      join20(srcDir, "build", "bin", "whisper-cli"),
+      join20(srcDir, "build", "bin", "main")
     ];
     for (const candidate of binaryCandidates) {
-      if (existsSync18(candidate)) {
+      if (existsSync19(candidate)) {
         execSync11(`cp "${candidate}" "${destPath}" && chmod +x "${destPath}"`, {
           stdio: "pipe"
         });
@@ -8970,9 +9395,9 @@ ${bold2("Installing voice dependencies...")}
 }
 function downloadModel() {
   const modelPath = getWhisperModelPath();
-  if (existsSync18(modelPath))
+  if (existsSync19(modelPath))
     return true;
-  mkdirSync13(WHISPER_MODELS_DIR, { recursive: true });
+  mkdirSync14(WHISPER_MODELS_DIR, { recursive: true });
   const url = `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${WHISPER_MODEL === "base.en" ? "ggml-base.en.bin" : `ggml-${WHISPER_MODEL}.bin`}`;
   process.stderr.write(`${dim2("Downloading whisper model")} ${bold2(WHISPER_MODEL)} ${dim2("(~150MB)...")}
 `);
@@ -9017,7 +9442,7 @@ class VoiceController {
   onStateChange;
   constructor(options) {
     this.onStateChange = options.onStateChange;
-    this.tempFile = join18(tmpdir4(), `locus-voice-${process.pid}.wav`);
+    this.tempFile = join20(tmpdir4(), `locus-voice-${process.pid}.wav`);
     this.deps = checkDependencies();
   }
   getState() {
@@ -9085,7 +9510,7 @@ ${red2("✗")} Recording failed: ${err.message}\r
     this.recordProcess = null;
     this.setState("idle");
     await sleep2(200);
-    if (!existsSync18(this.tempFile)) {
+    if (!existsSync19(this.tempFile)) {
       return null;
     }
     try {
@@ -9176,8 +9601,8 @@ function sleep2(ms) {
 var WHISPER_MODEL = "base.en", WHISPER_MODELS_DIR, LOCUS_BIN_DIR;
 var init_voice = __esm(() => {
   init_terminal();
-  WHISPER_MODELS_DIR = join18(homedir4(), ".locus", "whisper-models");
-  LOCUS_BIN_DIR = join18(homedir4(), ".locus", "bin");
+  WHISPER_MODELS_DIR = join20(homedir4(), ".locus", "whisper-models");
+  LOCUS_BIN_DIR = join20(homedir4(), ".locus", "bin");
 });
 
 // src/repl/repl.ts
@@ -9689,8 +10114,8 @@ var init_exec = __esm(() => {
 
 // src/core/submodule.ts
 import { execSync as execSync13 } from "node:child_process";
-import { existsSync as existsSync19 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { join as join21 } from "node:path";
 function git2(args, cwd) {
   return execSync13(`git ${args}`, {
     cwd,
@@ -9706,7 +10131,7 @@ function gitSafe(args, cwd) {
   }
 }
 function hasSubmodules(cwd) {
-  return existsSync19(join19(cwd, ".gitmodules"));
+  return existsSync20(join21(cwd, ".gitmodules"));
 }
 function listSubmodules(cwd) {
   if (!hasSubmodules(cwd))
@@ -9726,7 +10151,7 @@ function listSubmodules(cwd) {
         continue;
       submodules.push({
         path,
-        absolutePath: join19(cwd, path),
+        absolutePath: join21(cwd, path),
         dirty
       });
     }
@@ -9739,7 +10164,7 @@ function getDirtySubmodules(cwd) {
   const submodules = listSubmodules(cwd);
   const dirty = [];
   for (const sub of submodules) {
-    if (!existsSync19(sub.absolutePath))
+    if (!existsSync20(sub.absolutePath))
       continue;
     const status = gitSafe("status --porcelain", sub.absolutePath);
     if (status && status.trim().length > 0) {
@@ -9826,7 +10251,7 @@ function pushSubmoduleBranches(cwd) {
   const log = getLogger();
   const submodules = listSubmodules(cwd);
   for (const sub of submodules) {
-    if (!existsSync19(sub.absolutePath))
+    if (!existsSync20(sub.absolutePath))
       continue;
     const branch = gitSafe("rev-parse --abbrev-ref HEAD", sub.absolutePath)?.trim();
     if (!branch || branch === "HEAD")
@@ -10075,9 +10500,32 @@ ${submoduleSummary}`;
 
 \uD83E\uDD16 Automated by [Locus](https://github.com/asgarovf/locusai)`;
     const prTitle = `${issue.title} (#${issue.number})`;
-    const prNumber = createPR(prTitle, prBody, currentBranch, config.agent.baseBranch, { cwd: projectRoot });
-    process.stderr.write(`  ${green("✓")} Created PR #${prNumber}
+    let prNumber;
+    try {
+      const existing = execSync14(`gh pr list --head ${currentBranch} --base ${config.agent.baseBranch} --json number --limit 1`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const parsed = JSON.parse(existing);
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        prNumber = parsed[0].number;
+      }
+    } catch {}
+    if (prNumber) {
+      try {
+        execSync14(`gh pr edit ${prNumber} --title ${JSON.stringify(prTitle)} --body-file -`, {
+          input: prBody,
+          cwd: projectRoot,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        process.stderr.write(`  ${green("✓")} Updated existing PR #${prNumber}
+`);
+      } catch (editErr) {
+        getLogger().warn(`Failed to update PR #${prNumber}: ${editErr}`);
+      }
+    } else {
+      prNumber = createPR(prTitle, prBody, currentBranch, config.agent.baseBranch, { cwd: projectRoot });
+      process.stderr.write(`  ${green("✓")} Created PR #${prNumber}
 `);
+    }
     return prNumber;
   } catch (e) {
     getLogger().warn(`Failed to create PR: ${e}`);
@@ -10243,15 +10691,15 @@ var init_conflict = __esm(() => {
 
 // src/core/run-state.ts
 import {
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync12,
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync15,
+  readFileSync as readFileSync13,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname6, join as join20 } from "node:path";
+import { dirname as dirname6, join as join22 } from "node:path";
 function getRunStateDir(projectRoot) {
-  return join20(projectRoot, ".locus", "run-state");
+  return join22(projectRoot, ".locus", "run-state");
 }
 function sprintSlug(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -10259,16 +10707,16 @@ function sprintSlug(name) {
 function getRunStatePath(projectRoot, sprintName) {
   const dir = getRunStateDir(projectRoot);
   if (sprintName) {
-    return join20(dir, `${sprintSlug(sprintName)}.json`);
+    return join22(dir, `${sprintSlug(sprintName)}.json`);
   }
-  return join20(dir, "_parallel.json");
+  return join22(dir, "_parallel.json");
 }
 function loadRunState(projectRoot, sprintName) {
   const path = getRunStatePath(projectRoot, sprintName);
-  if (!existsSync20(path))
+  if (!existsSync21(path))
     return null;
   try {
-    return JSON.parse(readFileSync12(path, "utf-8"));
+    return JSON.parse(readFileSync13(path, "utf-8"));
   } catch {
     getLogger().warn("Corrupted run state file, ignoring");
     return null;
@@ -10277,15 +10725,15 @@ function loadRunState(projectRoot, sprintName) {
 function saveRunState(projectRoot, state) {
   const path = getRunStatePath(projectRoot, state.sprint);
   const dir = dirname6(path);
-  if (!existsSync20(dir)) {
-    mkdirSync14(dir, { recursive: true });
+  if (!existsSync21(dir)) {
+    mkdirSync15(dir, { recursive: true });
   }
-  writeFileSync9(path, `${JSON.stringify(state, null, 2)}
+  writeFileSync11(path, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 function clearRunState(projectRoot, sprintName) {
   const path = getRunStatePath(projectRoot, sprintName);
-  if (existsSync20(path)) {
+  if (existsSync21(path)) {
     unlinkSync5(path);
   }
 }
@@ -10425,9 +10873,43 @@ 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";
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync22,
+  mkdirSync as mkdirSync16,
+  readdirSync as readdirSync7,
+  realpathSync,
+  statSync as statSync4
+} from "node:fs";
+import { join as join23 } from "node:path";
+function copyLocusDir(projectRoot, worktreePath) {
+  const srcLocus = join23(projectRoot, ".locus");
+  if (!existsSync22(srcLocus))
+    return;
+  const destLocus = join23(worktreePath, ".locus");
+  mkdirSync16(destLocus, { recursive: true });
+  for (const entry of readdirSync7(srcLocus)) {
+    if (entry === "worktrees")
+      continue;
+    cpSync2(join23(srcLocus, entry), join23(destLocus, entry), { recursive: true });
+  }
+}
 function git4(args, cwd) {
   return execSync16(`git ${args}`, {
     cwd,
@@ -10443,15 +10925,62 @@ function gitSafe3(args, cwd) {
   }
 }
 function getWorktreeDir(projectRoot) {
-  return join21(projectRoot, ".locus", "worktrees");
+  return join23(projectRoot, ".locus", "worktrees");
 }
 function getWorktreePath(projectRoot, issueNumber) {
-  return join21(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
+  return join23(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
+}
+function getSprintWorktreePath(projectRoot, sprintSlug2) {
+  return join23(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 (existsSync22(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);
+  copyLocusDir(projectRoot, 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 (!existsSync22(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", {
@@ -10466,7 +10995,7 @@ function getWorktreeBranch(worktreePath) {
 function createWorktree(projectRoot, issueNumber, baseBranch) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (existsSync21(worktreePath)) {
+  if (existsSync22(worktreePath)) {
     log.verbose(`Worktree already exists for issue #${issueNumber}`);
     const existingBranch = getWorktreeBranch(worktreePath) ?? `locus/issue-${issueNumber}`;
     return {
@@ -10479,6 +11008,7 @@ function createWorktree(projectRoot, issueNumber, baseBranch) {
   const branch = generateBranchName(issueNumber);
   git4(`worktree add ${JSON.stringify(worktreePath)} -b ${branch} ${baseBranch}`, projectRoot);
   initSubmodules(worktreePath);
+  copyLocusDir(projectRoot, worktreePath);
   log.info(`Created worktree for issue #${issueNumber}`, {
     path: worktreePath,
     branch,
@@ -10494,7 +11024,7 @@ function createWorktree(projectRoot, issueNumber, baseBranch) {
 function removeWorktree(projectRoot, issueNumber) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync21(worktreePath)) {
+  if (!existsSync22(worktreePath)) {
     log.verbose(`Worktree for issue #${issueNumber} does not exist`);
     return;
   }
@@ -10513,7 +11043,7 @@ function removeWorktree(projectRoot, issueNumber) {
 function listWorktrees(projectRoot) {
   const log = getLogger();
   const worktreeDir = getWorktreeDir(projectRoot);
-  if (!existsSync21(worktreeDir)) {
+  if (!existsSync22(worktreeDir)) {
     return [];
   }
   const entries = readdirSync7(worktreeDir).filter((entry) => entry.startsWith("issue-"));
@@ -10533,7 +11063,7 @@ function listWorktrees(projectRoot) {
     if (!match)
       continue;
     const issueNumber = Number.parseInt(match[1], 10);
-    const path = join21(worktreeDir, entry);
+    const path = join23(worktreeDir, entry);
     const branch = getWorktreeBranch(path) ?? `locus/issue-${issueNumber}`;
     let resolvedPath;
     try {
@@ -10571,6 +11101,36 @@ function cleanupStaleWorktrees(projectRoot) {
   }
   return cleaned;
 }
+function pushWorktreeBranch(projectRoot, issueNumber) {
+  const worktreePath = getWorktreePath(projectRoot, issueNumber);
+  if (!existsSync22(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 (!existsSync22(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 (!existsSync22(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 +11142,8 @@ __export(exports_run, {
   runCommand: () => runCommand
 });
 import { execSync as execSync17 } from "node:child_process";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join24 } from "node:path";
 function resolveExecutionContext(config, modelOverride) {
   const model = modelOverride ?? config.ai.model;
   const provider = inferProviderFromModel(model) ?? config.ai.provider;
@@ -10598,12 +11160,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 +11180,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 +11234,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 +11248,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 +11306,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 +11327,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 +11368,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 +11379,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 +11417,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 +11443,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 +11455,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 +11481,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 +11673,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 = join24(projectRoot, ".locus", "run-state");
+    if (existsSync23(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: existsSync24 } = await import("node:fs");
+    const wtPath = getSprintWorktreePath2(projectRoot, sprintSlug3(state.sprint));
+    if (existsSync24(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 +11767,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 +11783,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 +11799,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 +11812,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 +11836,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 +11860,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 +11868,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 +11882,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,9 +11904,35 @@ ${submoduleSummary}`;
 ---
 
 \uD83E\uDD16 Automated by [Locus](https://github.com/asgarovf/locusai)`;
-    const prNumber = createPR(`Sprint: ${sprintName}`, prBody, branchName, config.agent.baseBranch, { cwd: projectRoot });
-    process.stderr.write(`  ${green("✓")} Created sprint PR #${prNumber}
+    const prTitle = `Sprint: ${sprintName}`;
+    let prNumber;
+    try {
+      const existing = execSync17(`gh pr list --head ${branchName} --base ${config.agent.baseBranch} --json number --limit 1`, { cwd: workDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const parsed = JSON.parse(existing);
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        prNumber = parsed[0].number;
+      }
+    } catch {}
+    if (prNumber) {
+      try {
+        execSync17(`gh pr edit ${prNumber} --title ${JSON.stringify(prTitle)} --body-file -`, {
+          input: prBody,
+          cwd: workDir,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        process.stderr.write(`  ${green("✓")} Updated existing sprint PR #${prNumber}
+`);
+      } catch (editErr) {
+        getLogger().warn(`Failed to update sprint PR #${prNumber}: ${editErr}`);
+        process.stderr.write(`  ${yellow2("⚠")} PR #${prNumber} exists but could not update: ${editErr}
+`);
+      }
+    } else {
+      prNumber = createPR(prTitle, prBody, branchName, config.agent.baseBranch, { cwd: workDir });
+      process.stderr.write(`  ${green("✓")} Created sprint PR #${prNumber}
 `);
+    }
     return prNumber;
   } catch (e) {
     getLogger().warn(`Failed to create sprint PR: ${e}`);
@@ -11283,8 +11964,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 existsSync24 } from "node:fs";
+import { dirname as dirname7, join as join25 } from "node:path";
 async function statusCommand(projectRoot) {
   const config = loadConfig(projectRoot);
   const spinner = new Spinner;
@@ -11293,21 +11974,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 +12002,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 +12097,13 @@ ${drawBox(lines, { title: "Locus Status" })}
 `);
 }
 function getPm2Bin() {
-  const pkgsBin = join22(getPackagesDir(), "node_modules", ".bin", "pm2");
-  if (existsSync22(pkgsBin))
+  const pkgsBin = join25(getPackagesDir(), "node_modules", ".bin", "pm2");
+  if (existsSync24(pkgsBin))
     return pkgsBin;
   let dir = process.cwd();
   while (dir !== dirname7(dir)) {
-    const candidate = join22(dir, "node_modules", ".bin", "pm2");
-    if (existsSync22(candidate))
+    const candidate = join25(dir, "node_modules", ".bin", "pm2");
+    if (existsSync24(candidate))
       return candidate;
     dir = dirname7(dir);
   }
@@ -11623,13 +12299,13 @@ __export(exports_plan, {
   parsePlanArgs: () => parsePlanArgs
 });
 import {
-  existsSync as existsSync23,
-  mkdirSync as mkdirSync15,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync17,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync13,
-  writeFileSync as writeFileSync10
+  readFileSync as readFileSync14,
+  writeFileSync as writeFileSync12
 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join26 } from "node:path";
 function printHelp2() {
   process.stderr.write(`
 ${bold2("locus plan")} — AI-powered sprint planning
@@ -11661,12 +12337,12 @@ function normalizeSprintName(name) {
   return name.trim().toLowerCase();
 }
 function getPlansDir(projectRoot) {
-  return join23(projectRoot, ".locus", "plans");
+  return join26(projectRoot, ".locus", "plans");
 }
 function ensurePlansDir(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync23(dir)) {
-    mkdirSync15(dir, { recursive: true });
+  if (!existsSync25(dir)) {
+    mkdirSync17(dir, { recursive: true });
   }
   return dir;
 }
@@ -11675,14 +12351,14 @@ function generateId() {
 }
 function loadPlanFile(projectRoot, id) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync23(dir))
+  if (!existsSync25(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 = readFileSync14(join26(dir, match), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11749,7 +12425,7 @@ async function planCommand(projectRoot, args, flags = {}) {
 }
 function handleListPlans(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync23(dir)) {
+  if (!existsSync25(dir)) {
     process.stderr.write(`${dim2("No saved plans yet.")}
 `);
     return;
@@ -11767,7 +12443,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 = readFileSync14(join26(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 +12511,7 @@ async function handleRefinePlan(projectRoot, id, feedback, flags) {
     return;
   }
   const config = loadConfig(projectRoot);
-  const planPath = join23(getPlansDir(projectRoot), `${plan.id}.json`);
+  const planPath = join26(getPlansDir(projectRoot), `${plan.id}.json`);
   const planPathRelative = `.locus/plans/${plan.id}.json`;
   process.stderr.write(`
 ${bold2("Refining plan:")} ${cyan2(plan.directive)}
@@ -11874,7 +12550,7 @@ ${red2("✗")} Refinement failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync23(planPath)) {
+  if (!existsSync25(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not found at ${bold2(planPathRelative)}.
 `);
@@ -11882,7 +12558,7 @@ ${yellow2("⚠")} Plan file was not found at ${bold2(planPathRelative)}.
   }
   let updatedPlan;
   try {
-    const content = readFileSync13(planPath, "utf-8");
+    const content = readFileSync14(planPath, "utf-8");
     updatedPlan = JSON.parse(content);
   } catch {
     process.stderr.write(`
@@ -11900,7 +12576,7 @@ ${yellow2("⚠")} Refined plan has no issues.
   updatedPlan.directive = plan.directive;
   updatedPlan.sprint = updatedPlan.sprint ?? plan.sprint;
   updatedPlan.createdAt = plan.createdAt;
-  writeFileSync10(planPath, JSON.stringify(updatedPlan, null, 2), "utf-8");
+  writeFileSync12(planPath, JSON.stringify(updatedPlan, null, 2), "utf-8");
   process.stderr.write(`
 ${bold2("Plan refined:")} ${cyan2(plan.id)}
 
@@ -11972,7 +12648,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 = join26(plansDir, `${id}.json`);
   const planPathRelative = `.locus/plans/${id}.json`;
   const displayDirective = directive;
   process.stderr.write(`
@@ -12015,7 +12691,7 @@ ${red2("✗")} Planning failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync23(planPath)) {
+  if (!existsSync25(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
 `);
@@ -12025,7 +12701,7 @@ ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
   }
   let plan;
   try {
-    const content = readFileSync13(planPath, "utf-8");
+    const content = readFileSync14(planPath, "utf-8");
     plan = JSON.parse(content);
   } catch {
     process.stderr.write(`
@@ -12047,7 +12723,7 @@ ${yellow2("⚠")} Plan file has no issues.
     plan.sprint = sprintName;
   if (!plan.createdAt)
     plan.createdAt = new Date().toISOString();
-  writeFileSync10(planPath, JSON.stringify(plan, null, 2), "utf-8");
+  writeFileSync12(planPath, JSON.stringify(plan, null, 2), "utf-8");
   process.stderr.write(`
 ${bold2("Plan saved:")} ${cyan2(id)}
 
@@ -12197,16 +12873,16 @@ ${directive}${sprintName ? `
 
 **Sprint:** ${sprintName}` : ""}
 </directive>`);
-  const locusPath = join23(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync23(locusPath)) {
-    const content = readFileSync13(locusPath, "utf-8");
+  const locusPath = join26(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync25(locusPath)) {
+    const content = readFileSync14(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join23(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync23(learningsPath)) {
-    const content = readFileSync13(learningsPath, "utf-8");
+  const learningsPath = join26(projectRoot, ".locus", "LEARNINGS.md");
+  if (existsSync25(learningsPath)) {
+    const content = readFileSync14(learningsPath, "utf-8");
     parts.push(`<past-learnings>
 ${content.slice(0, 2000)}
 </past-learnings>`);
@@ -12258,9 +12934,9 @@ ${JSON.stringify(plan, null, 2)}
   parts.push(`<feedback>
 ${feedback}
 </feedback>`);
-  const locusPath = join23(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync23(locusPath)) {
-    const content = readFileSync13(locusPath, "utf-8");
+  const locusPath = join26(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync25(locusPath)) {
+    const content = readFileSync14(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
@@ -12442,8 +13118,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 existsSync26, readFileSync as readFileSync15 } from "node:fs";
+import { join as join27 } from "node:path";
 function printHelp3() {
   process.stderr.write(`
 ${bold2("locus review")} — AI-powered code review
@@ -12612,9 +13288,9 @@ 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 content = readFileSync14(locusPath, "utf-8");
+  const locusPath = join27(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync26(locusPath)) {
+    const content = readFileSync15(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 2000)}
 </project-context>`);
@@ -12789,13 +13465,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 +13605,14 @@ __export(exports_discuss, {
   discussCommand: () => discussCommand
 });
 import {
-  existsSync as existsSync25,
-  mkdirSync as mkdirSync16,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync18,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join28 } from "node:path";
 function printHelp5() {
   process.stderr.write(`
 ${bold2("locus discuss")} — AI-powered architectural discussions
@@ -12963,12 +13634,12 @@ ${bold2("Examples:")}
 `);
 }
 function getDiscussionsDir(projectRoot) {
-  return join25(projectRoot, ".locus", "discussions");
+  return join28(projectRoot, ".locus", "discussions");
 }
 function ensureDiscussionsDir(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
-    mkdirSync16(dir, { recursive: true });
+  if (!existsSync27(dir)) {
+    mkdirSync18(dir, { recursive: true });
   }
   return dir;
 }
@@ -13002,7 +13673,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
 }
 function listDiscussions(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${dim2("No discussions yet.")}
 `);
     return;
@@ -13019,7 +13690,7 @@ ${bold2("Discussions:")}
 `);
   for (const file of files) {
     const id = file.replace(".md", "");
-    const content = readFileSync15(join25(dir, file), "utf-8");
+    const content = readFileSync16(join28(dir, file), "utf-8");
     const titleMatch = content.match(/^#\s+(.+)/m);
     const title = titleMatch ? titleMatch[1] : id;
     const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/);
@@ -13037,7 +13708,7 @@ function showDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13049,7 +13720,7 @@ function showDiscussion(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join25(dir, match), "utf-8");
+  const content = readFileSync16(join28(dir, match), "utf-8");
   process.stdout.write(`${content}
 `);
 }
@@ -13060,7 +13731,7 @@ function deleteDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13072,7 +13743,7 @@ function deleteDiscussion(projectRoot, id) {
 `);
     return;
   }
-  unlinkSync6(join25(dir, match));
+  unlinkSync6(join28(dir, match));
   process.stderr.write(`${green("✓")} Deleted discussion: ${match.replace(".md", "")}
 `);
 }
@@ -13085,7 +13756,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13097,7 +13768,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join25(dir, match), "utf-8");
+  const content = readFileSync16(join28(dir, match), "utf-8");
   const titleMatch = content.match(/^#\s+(.+)/m);
   const discussionTitle = titleMatch ? titleMatch[1].trim() : id;
   await planCommand(projectRoot, [
@@ -13223,7 +13894,7 @@ ${turn.content}`;
     ...conversation.length > 1 ? [`---`, ``, `## Discussion Transcript`, ``, transcript, ``] : []
   ].join(`
 `);
-  writeFileSync11(join25(dir, `${id}.md`), markdown, "utf-8");
+  writeFileSync13(join28(dir, `${id}.md`), markdown, "utf-8");
   process.stderr.write(`
 ${green("✓")} Discussion saved: ${cyan2(id)} ${dim2(`(${timer.formatted()})`)}
 `);
@@ -13238,16 +13909,16 @@ 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 content = readFileSync15(locusPath, "utf-8");
+  const locusPath = join28(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync27(locusPath)) {
+    const content = readFileSync16(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join25(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync25(learningsPath)) {
-    const content = readFileSync15(learningsPath, "utf-8");
+  const learningsPath = join28(projectRoot, ".locus", "LEARNINGS.md");
+  if (existsSync27(learningsPath)) {
+    const content = readFileSync16(learningsPath, "utf-8");
     parts.push(`<past-learnings>
 ${content.slice(0, 2000)}
 </past-learnings>`);
@@ -13318,8 +13989,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 existsSync28, readdirSync as readdirSync10, readFileSync as readFileSync17, statSync as statSync5 } from "node:fs";
+import { join as join29 } from "node:path";
 function printHelp6() {
   process.stderr.write(`
 ${bold2("locus artifacts")} — View and manage AI-generated artifacts
@@ -13339,14 +14010,14 @@ ${dim2("Artifact names support partial matching.")}
 `);
 }
 function getArtifactsDir(projectRoot) {
-  return join26(projectRoot, ".locus", "artifacts");
+  return join29(projectRoot, ".locus", "artifacts");
 }
 function listArtifacts(projectRoot) {
   const dir = getArtifactsDir(projectRoot);
-  if (!existsSync26(dir))
+  if (!existsSync28(dir))
     return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".md")).map((fileName) => {
-    const filePath = join26(dir, fileName);
+    const filePath = join29(dir, fileName);
     const stat = statSync5(filePath);
     return {
       name: fileName.replace(/\.md$/, ""),
@@ -13359,12 +14030,12 @@ 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 = join29(dir, fileName);
+  if (!existsSync28(filePath))
     return null;
   const stat = statSync5(filePath);
   return {
-    content: readFileSync16(filePath, "utf-8"),
+    content: readFileSync17(filePath, "utf-8"),
     info: {
       name: fileName.replace(/\.md$/, ""),
       fileName,
@@ -13720,9 +14391,9 @@ __export(exports_sandbox2, {
   parseSandboxInstallArgs: () => parseSandboxInstallArgs
 });
 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 { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync29, readFileSync as readFileSync18 } from "node:fs";
+import { basename as basename4, join as join30 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
 function printSandboxHelp() {
   process.stderr.write(`
@@ -14252,7 +14923,7 @@ async function handleLogs(projectRoot, args) {
 }
 function detectPackageManager2(projectRoot) {
   try {
-    const raw = readFileSync17(join27(projectRoot, "package.json"), "utf-8");
+    const raw = readFileSync18(join30(projectRoot, "package.json"), "utf-8");
     const pkgJson = JSON.parse(raw);
     if (typeof pkgJson.packageManager === "string") {
       const name = pkgJson.packageManager.split("@")[0];
@@ -14261,13 +14932,13 @@ function detectPackageManager2(projectRoot) {
       }
     }
   } catch {}
-  if (existsSync27(join27(projectRoot, "bun.lock")) || existsSync27(join27(projectRoot, "bun.lockb"))) {
+  if (existsSync29(join30(projectRoot, "bun.lock")) || existsSync29(join30(projectRoot, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync27(join27(projectRoot, "yarn.lock"))) {
+  if (existsSync29(join30(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync27(join27(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync29(join30(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
   return "npm";
@@ -14370,9 +15041,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 = join30(projectRoot, ".locus", "sandbox-setup.sh");
+  const containerSetupScript = containerWorkdir ? join30(containerWorkdir, ".locus", "sandbox-setup.sh") : setupScript;
+  if (existsSync29(setupScript)) {
     process.stderr.write(`Running ${bold2(".locus/sandbox-setup.sh")} in sandbox ${dim2(sandboxName)}...
 `);
     const hookOk = await runInteractiveCommand("docker", [
@@ -14419,7 +15090,7 @@ async function handleSetup(projectRoot) {
 }
 function buildProviderSandboxNames(projectRoot) {
   const segment = sanitizeSegment(basename4(projectRoot));
-  const hash = createHash("sha1").update(projectRoot).digest("hex").slice(0, 8);
+  const hash = createHash2("sha1").update(projectRoot).digest("hex").slice(0, 8);
   return {
     claude: `locus-${segment}-claude-${hash}`,
     codex: `locus-${segment}-codex-${hash}`
@@ -14513,16 +15184,21 @@ async function ensureCodexInSandbox(sandboxName) {
   }
 }
 function isSandboxAlive(name) {
-  try {
-    const output = execSync22("docker sandbox ls", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5000
-    });
-    return output.includes(name);
-  } catch {
-    return false;
+  for (let attempt = 0;attempt < 3; attempt++) {
+    try {
+      const output = execSync22("docker sandbox ls", {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 15000
+      });
+      return output.includes(name);
+    } catch {
+      if (attempt < 2) {
+        execSync22("sleep 2", { stdio: "ignore" });
+      }
+    }
   }
+  return false;
 }
 var PROVIDERS;
 var init_sandbox2 = __esm(() => {
@@ -14540,17 +15216,17 @@ 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 existsSync30, readFileSync as readFileSync19 } from "node:fs";
+import { join as join31 } 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 = join31(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
+  if (!existsSync30(packageJsonPath)) {
     return fallbackVersion;
   }
   try {
-    const parsed = JSON.parse(readFileSync18(packageJsonPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync19(packageJsonPath, "utf-8"));
     return parsed.version ?? fallbackVersion;
   } catch {
     return fallbackVersion;
@@ -14580,6 +15256,7 @@ function parseArgs(argv) {
     check: false,
     upgrade: false,
     list: false,
+    installed: false,
     noSandbox: false
   };
   const positional = [];
@@ -14657,9 +15334,15 @@ function parseArgs(argv) {
       case "--target-version":
         flags.targetVersion = rawArgs[++i];
         break;
+      case "--installed":
+        flags.installed = true;
+        break;
       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);
@@ -14732,6 +15415,7 @@ ${bold2("Commands:")}
   ${cyan2("uninstall")}         Remove an installed package
   ${cyan2("packages")}          Manage installed packages (list, outdated)
   ${cyan2("pkg")} ${dim2("<name> [cmd]")}   Run a command from an installed package
+  ${cyan2("skills")}            Discover and manage agent skills
   ${cyan2("sandbox")}           Manage Docker sandbox lifecycle
   ${cyan2("upgrade")}           Check for and install updates
 
@@ -14750,6 +15434,8 @@ ${bold2("Examples:")}
   locus run 42 43                     ${dim2("# Run issues in parallel")}
   locus run 42 --no-sandbox           ${dim2("# Run without sandbox")}
   locus run 42 --sandbox=require      ${dim2("# Require Docker sandbox")}
+  locus skills list                   ${dim2("# Browse available skills")}
+  locus skills install code-review    ${dim2("# Install a skill")}
   locus sandbox                       ${dim2("# Create Docker sandbox")}
   locus sandbox claude                ${dim2("# Login to Claude in sandbox")}
 
@@ -14823,7 +15509,7 @@ async function main() {
     try {
       const root = getGitRoot(cwd);
       if (isInitialized(root)) {
-        logDir = join28(root, ".locus", "logs");
+        logDir = join31(root, ".locus", "logs");
         getRateLimiter(root);
       }
     } catch {}
@@ -14891,6 +15577,17 @@ async function main() {
     logger.destroy();
     return;
   }
+  if (command === "skills") {
+    const { skillsCommand: skillsCommand2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
+    const skillsArgs = parsed.flags.help ? ["help"] : parsed.args;
+    const skillsFlags = {};
+    if (parsed.flags.installed) {
+      skillsFlags.installed = "true";
+    }
+    await skillsCommand2(skillsArgs, skillsFlags);
+    logger.destroy();
+    return;
+  }
   if (command === "pkg") {
     const { pkgCommand: pkgCommand2 } = await Promise.resolve().then(() => (init_pkg(), exports_pkg));
     await pkgCommand2(parsed.args, {});
@@ -14963,7 +15660,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;
     }