@locusai/cli 0.24.9 → 0.25.1

package/bin/locus.js

@@ -3213,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, {
@@ -3276,9 +3872,7 @@ ${bold2("Locus Configuration")}
     },
     {
       title: "Sprint",
-      entries: [
-        ["Stop on Failure", String(config.sprint.stopOnFailure)]
-      ]
+      entries: [["Stop on Failure", String(config.sprint.stopOnFailure)]]
     },
     {
       title: "Logging",
@@ -3351,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;
@@ -3380,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(`
@@ -3415,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);
@@ -3435,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);
@@ -3495,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());
@@ -3805,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();
@@ -3818,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",
@@ -3849,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 {}
@@ -3862,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 {}
@@ -3872,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;
@@ -3972,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 {}
@@ -3992,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);
@@ -4005,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);
@@ -4059,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 {
@@ -4082,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;
 });
 
@@ -5091,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(`
 `)) {
@@ -5173,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);
@@ -5207,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;
@@ -5216,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)
@@ -5226,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) {
@@ -5239,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", {
@@ -5250,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)", {
@@ -5260,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 });
     }
@@ -5268,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;
@@ -5486,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) {
@@ -5897,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");
@@ -6164,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, {
@@ -7533,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));
@@ -7564,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}
@@ -7593,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}
@@ -7601,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}">
@@ -7759,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;
   }
@@ -8239,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;
@@ -8294,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) => {
@@ -8330,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) {
@@ -8376,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 {}
@@ -8386,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) {
@@ -8417,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) {
@@ -8456,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;
       }
@@ -8471,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;
       }
@@ -8484,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) {
@@ -8496,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,
@@ -8511,7 +9006,7 @@ class SessionManager {
   }
   delete(sessionId) {
     const path = this.getSessionPath(sessionId);
-    if (existsSync17(path)) {
+    if (existsSync18(path)) {
       unlinkSync3(path);
       return true;
     }
@@ -8523,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 };
@@ -8541,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);
@@ -8556,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 [];
     }
@@ -8565,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;
@@ -8576,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 {
@@ -8598,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;
       }
     }
@@ -8622,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;
     }
   }
@@ -8635,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,
@@ -8789,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)...")}
 `);
@@ -8815,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"
         });
@@ -8900,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)...")}
 `);
@@ -8947,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() {
@@ -9015,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 {
@@ -9106,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
@@ -9619,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,
@@ -9636,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))
@@ -9656,7 +10151,7 @@ function listSubmodules(cwd) {
         continue;
       submodules.push({
         path,
-        absolutePath: join19(cwd, path),
+        absolutePath: join21(cwd, path),
         dirty
       });
     }
@@ -9669,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) {
@@ -9756,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")
@@ -10005,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}`);
@@ -10173,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, "");
@@ -10189,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;
@@ -10207,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);
   }
 }
@@ -10371,8 +10889,27 @@ __export(exports_worktree, {
   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,
@@ -10388,13 +10925,13 @@ 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 join21(getWorktreeDir(projectRoot), `sprint-${sprintSlug2}`);
+  return join23(getWorktreeDir(projectRoot), `sprint-${sprintSlug2}`);
 }
 function generateBranchName(issueNumber) {
   const randomSuffix = Math.random().toString(36).slice(2, 8);
@@ -10407,7 +10944,7 @@ function createSprintWorktree(projectRoot, sprintName, baseBranch) {
   const log = getLogger();
   const slug = sprintSlug2(sprintName);
   const worktreePath = getSprintWorktreePath(projectRoot, slug);
-  if (existsSync21(worktreePath)) {
+  if (existsSync22(worktreePath)) {
     log.verbose(`Sprint worktree already exists for "${sprintName}"`);
     const existingBranch = getWorktreeBranch(worktreePath) ?? `locus/sprint-${slug}`;
     return { path: worktreePath, branch: existingBranch };
@@ -10416,6 +10953,7 @@ function createSprintWorktree(projectRoot, sprintName, baseBranch) {
   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,
@@ -10427,7 +10965,7 @@ function removeSprintWorktree(projectRoot, sprintName) {
   const log = getLogger();
   const slug = sprintSlug2(sprintName);
   const worktreePath = getSprintWorktreePath(projectRoot, slug);
-  if (!existsSync21(worktreePath)) {
+  if (!existsSync22(worktreePath)) {
     log.verbose(`Sprint worktree for "${sprintName}" does not exist`);
     return;
   }
@@ -10457,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 {
@@ -10470,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,
@@ -10485,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;
   }
@@ -10504,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-"));
@@ -10524,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 {
@@ -10564,7 +11103,7 @@ function cleanupStaleWorktrees(projectRoot) {
 }
 function pushWorktreeBranch(projectRoot, issueNumber) {
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync21(worktreePath)) {
+  if (!existsSync22(worktreePath)) {
     throw new Error(`Worktree for issue #${issueNumber} does not exist`);
   }
   const branch = getWorktreeBranch(worktreePath);
@@ -10576,14 +11115,14 @@ function pushWorktreeBranch(projectRoot, issueNumber) {
 }
 function hasWorktreeChanges(projectRoot, issueNumber) {
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync21(worktreePath))
+  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 (!existsSync21(worktreePath))
+  if (!existsSync22(worktreePath))
     return 0;
   try {
     const stat = statSync4(worktreePath);
@@ -10603,8 +11142,8 @@ __export(exports_run, {
   runCommand: () => runCommand
 });
 import { execSync as execSync17 } from "node:child_process";
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join22 } from "node:path";
+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;
@@ -11148,8 +11687,8 @@ async function handleResume(projectRoot, config, sandboxed, flags) {
   const sprintsToResume = [];
   try {
     const { readdirSync: readdirSync8 } = await import("node:fs");
-    const runStateDir = join22(projectRoot, ".locus", "run-state");
-    if (existsSync22(runStateDir)) {
+    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$/, "");
@@ -11193,9 +11732,9 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}${state.sprint ? ` ($
   let workDir = projectRoot;
   if (state.type === "sprint" && state.sprint) {
     const { getSprintWorktreePath: getSprintWorktreePath2, sprintSlug: sprintSlug3 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
-    const { existsSync: existsSync23 } = await import("node:fs");
+    const { existsSync: existsSync24 } = await import("node:fs");
     const wtPath = getSprintWorktreePath2(projectRoot, sprintSlug3(state.sprint));
-    if (existsSync23(wtPath)) {
+    if (existsSync24(wtPath)) {
       workDir = wtPath;
     } else if (state.branch) {
       try {
@@ -11365,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: workDir });
-    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}`);
@@ -11399,8 +11964,8 @@ __export(exports_status, {
   statusCommand: () => statusCommand
 });
 import { execSync as execSync18 } from "node:child_process";
-import { existsSync as existsSync23 } from "node:fs";
-import { dirname as dirname7, join as join23 } 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;
@@ -11532,13 +12097,13 @@ ${drawBox(lines, { title: "Locus Status" })}
 `);
 }
 function getPm2Bin() {
-  const pkgsBin = join23(getPackagesDir(), "node_modules", ".bin", "pm2");
-  if (existsSync23(pkgsBin))
+  const pkgsBin = join25(getPackagesDir(), "node_modules", ".bin", "pm2");
+  if (existsSync24(pkgsBin))
     return pkgsBin;
   let dir = process.cwd();
   while (dir !== dirname7(dir)) {
-    const candidate = join23(dir, "node_modules", ".bin", "pm2");
-    if (existsSync23(candidate))
+    const candidate = join25(dir, "node_modules", ".bin", "pm2");
+    if (existsSync24(candidate))
       return candidate;
     dir = dirname7(dir);
   }
@@ -11734,13 +12299,13 @@ __export(exports_plan, {
   parsePlanArgs: () => parsePlanArgs
 });
 import {
-  existsSync as existsSync24,
-  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 join24 } from "node:path";
+import { join as join26 } from "node:path";
 function printHelp2() {
   process.stderr.write(`
 ${bold2("locus plan")} — AI-powered sprint planning
@@ -11772,12 +12337,12 @@ function normalizeSprintName(name) {
   return name.trim().toLowerCase();
 }
 function getPlansDir(projectRoot) {
-  return join24(projectRoot, ".locus", "plans");
+  return join26(projectRoot, ".locus", "plans");
 }
 function ensurePlansDir(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync24(dir)) {
-    mkdirSync15(dir, { recursive: true });
+  if (!existsSync25(dir)) {
+    mkdirSync17(dir, { recursive: true });
   }
   return dir;
 }
@@ -11786,14 +12351,14 @@ function generateId() {
 }
 function loadPlanFile(projectRoot, id) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync24(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(join24(dir, match), "utf-8");
+    const content = readFileSync14(join26(dir, match), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11860,7 +12425,7 @@ async function planCommand(projectRoot, args, flags = {}) {
 }
 function handleListPlans(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync24(dir)) {
+  if (!existsSync25(dir)) {
     process.stderr.write(`${dim2("No saved plans yet.")}
 `);
     return;
@@ -11878,7 +12443,7 @@ ${bold2("Saved Plans:")}
   for (const file of files) {
     const id = file.replace(".json", "");
     try {
-      const content = readFileSync13(join24(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;
@@ -11946,7 +12511,7 @@ async function handleRefinePlan(projectRoot, id, feedback, flags) {
     return;
   }
   const config = loadConfig(projectRoot);
-  const planPath = join24(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)}
@@ -11985,7 +12550,7 @@ ${red2("✗")} Refinement failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync24(planPath)) {
+  if (!existsSync25(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not found at ${bold2(planPathRelative)}.
 `);
@@ -11993,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(`
@@ -12011,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)}
 
@@ -12083,7 +12648,7 @@ ${bold2("Approving plan:")}
 async function handleAIPlan(projectRoot, config, directive, sprintName, flags) {
   const id = generateId();
   const plansDir = ensurePlansDir(projectRoot);
-  const planPath = join24(plansDir, `${id}.json`);
+  const planPath = join26(plansDir, `${id}.json`);
   const planPathRelative = `.locus/plans/${id}.json`;
   const displayDirective = directive;
   process.stderr.write(`
@@ -12126,7 +12691,7 @@ ${red2("✗")} Planning failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync24(planPath)) {
+  if (!existsSync25(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
 `);
@@ -12136,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(`
@@ -12158,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)}
 
@@ -12308,16 +12873,16 @@ ${directive}${sprintName ? `
 
 **Sprint:** ${sprintName}` : ""}
 </directive>`);
-  const locusPath = join24(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync24(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 = join24(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync24(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>`);
@@ -12369,9 +12934,9 @@ ${JSON.stringify(plan, null, 2)}
   parts.push(`<feedback>
 ${feedback}
 </feedback>`);
-  const locusPath = join24(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync24(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>`);
@@ -12553,8 +13118,8 @@ __export(exports_review, {
   reviewCommand: () => reviewCommand
 });
 import { execFileSync as execFileSync2, execSync as execSync19 } from "node:child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync14 } from "node:fs";
-import { join as join25 } 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
@@ -12723,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 = join25(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync25(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>`);
@@ -13040,14 +13605,14 @@ __export(exports_discuss, {
   discussCommand: () => discussCommand
 });
 import {
-  existsSync as existsSync26,
-  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 join26 } from "node:path";
+import { join as join28 } from "node:path";
 function printHelp5() {
   process.stderr.write(`
 ${bold2("locus discuss")} — AI-powered architectural discussions
@@ -13069,12 +13634,12 @@ ${bold2("Examples:")}
 `);
 }
 function getDiscussionsDir(projectRoot) {
-  return join26(projectRoot, ".locus", "discussions");
+  return join28(projectRoot, ".locus", "discussions");
 }
 function ensureDiscussionsDir(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync26(dir)) {
-    mkdirSync16(dir, { recursive: true });
+  if (!existsSync27(dir)) {
+    mkdirSync18(dir, { recursive: true });
   }
   return dir;
 }
@@ -13108,7 +13673,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
 }
 function listDiscussions(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync26(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${dim2("No discussions yet.")}
 `);
     return;
@@ -13125,7 +13690,7 @@ ${bold2("Discussions:")}
 `);
   for (const file of files) {
     const id = file.replace(".md", "");
-    const content = readFileSync15(join26(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*(.+)/);
@@ -13143,7 +13708,7 @@ function showDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync26(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13155,7 +13720,7 @@ function showDiscussion(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join26(dir, match), "utf-8");
+  const content = readFileSync16(join28(dir, match), "utf-8");
   process.stdout.write(`${content}
 `);
 }
@@ -13166,7 +13731,7 @@ function deleteDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync26(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13178,7 +13743,7 @@ function deleteDiscussion(projectRoot, id) {
 `);
     return;
   }
-  unlinkSync6(join26(dir, match));
+  unlinkSync6(join28(dir, match));
   process.stderr.write(`${green("✓")} Deleted discussion: ${match.replace(".md", "")}
 `);
 }
@@ -13191,7 +13756,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync26(dir)) {
+  if (!existsSync27(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13203,7 +13768,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join26(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, [
@@ -13329,7 +13894,7 @@ ${turn.content}`;
     ...conversation.length > 1 ? [`---`, ``, `## Discussion Transcript`, ``, transcript, ``] : []
   ].join(`
 `);
-  writeFileSync11(join26(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()})`)}
 `);
@@ -13344,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 = join26(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync26(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 = join26(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync26(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>`);
@@ -13424,8 +13989,8 @@ __export(exports_artifacts, {
   formatDate: () => formatDate2,
   artifactsCommand: () => artifactsCommand
 });
-import { existsSync as existsSync27, readdirSync as readdirSync10, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
-import { join as join27 } 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
@@ -13445,14 +14010,14 @@ ${dim2("Artifact names support partial matching.")}
 `);
 }
 function getArtifactsDir(projectRoot) {
-  return join27(projectRoot, ".locus", "artifacts");
+  return join29(projectRoot, ".locus", "artifacts");
 }
 function listArtifacts(projectRoot) {
   const dir = getArtifactsDir(projectRoot);
-  if (!existsSync27(dir))
+  if (!existsSync28(dir))
     return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".md")).map((fileName) => {
-    const filePath = join27(dir, fileName);
+    const filePath = join29(dir, fileName);
     const stat = statSync5(filePath);
     return {
       name: fileName.replace(/\.md$/, ""),
@@ -13465,12 +14030,12 @@ function listArtifacts(projectRoot) {
 function readArtifact(projectRoot, name) {
   const dir = getArtifactsDir(projectRoot);
   const fileName = name.endsWith(".md") ? name : `${name}.md`;
-  const filePath = join27(dir, fileName);
-  if (!existsSync27(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,
@@ -13826,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 existsSync28, readFileSync as readFileSync17 } from "node:fs";
-import { basename as basename4, join as join28 } 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(`
@@ -14358,7 +14923,7 @@ async function handleLogs(projectRoot, args) {
 }
 function detectPackageManager2(projectRoot) {
   try {
-    const raw = readFileSync17(join28(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];
@@ -14367,13 +14932,13 @@ function detectPackageManager2(projectRoot) {
       }
     }
   } catch {}
-  if (existsSync28(join28(projectRoot, "bun.lock")) || existsSync28(join28(projectRoot, "bun.lockb"))) {
+  if (existsSync29(join30(projectRoot, "bun.lock")) || existsSync29(join30(projectRoot, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync28(join28(projectRoot, "yarn.lock"))) {
+  if (existsSync29(join30(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync28(join28(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync29(join30(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
   return "npm";
@@ -14476,9 +15041,9 @@ Installing sandbox dependencies (${bold2(installCmd.join(" "))}) to container fi
 ${dim2(`Detected ${ecosystem} project — skipping JS package install.`)}
 `);
   }
-  const setupScript = join28(projectRoot, ".locus", "sandbox-setup.sh");
-  const containerSetupScript = containerWorkdir ? join28(containerWorkdir, ".locus", "sandbox-setup.sh") : setupScript;
-  if (existsSync28(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", [
@@ -14525,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}`
@@ -14619,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(() => {
@@ -14646,17 +15216,17 @@ init_context();
 init_logger();
 init_rate_limiter();
 init_terminal();
-import { existsSync as existsSync29, readFileSync as readFileSync18 } from "node:fs";
-import { join as join29 } 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 = join29(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
-  if (!existsSync29(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;
@@ -14686,6 +15256,7 @@ function parseArgs(argv) {
     check: false,
     upgrade: false,
     list: false,
+    installed: false,
     noSandbox: false
   };
   const positional = [];
@@ -14763,6 +15334,9 @@ function parseArgs(argv) {
       case "--target-version":
         flags.targetVersion = rawArgs[++i];
         break;
+      case "--installed":
+        flags.installed = true;
+        break;
       case "--no-sandbox":
         flags.noSandbox = true;
         break;
@@ -14841,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
 
@@ -14859,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")}
 
@@ -14932,7 +15509,7 @@ async function main() {
     try {
       const root = getGitRoot(cwd);
       if (isInitialized(root)) {
-        logDir = join29(root, ".locus", "logs");
+        logDir = join31(root, ".locus", "logs");
         getRateLimiter(root);
       }
     } catch {}
@@ -15000,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, {});