@locusai/cli 0.21.17 → 0.22.1

package/bin/locus.js

@@ -29,7 +29,7 @@ var init_dist = __esm(() => {
     },
     ai: {
       provider: "claude",
-      model: "claude-sonnet-4-6"
+      model: "opus"
     },
     agent: {
       maxParallel: 3,
@@ -2226,35 +2226,384 @@ var init_init = __esm(() => {
   GITIGNORE_ENTRIES = ["", "# Locus", ".locus/", "!.locus/LEARNINGS.md"];
 });
 
+// src/commands/create.ts
+var exports_create = {};
+__export(exports_create, {
+  createCommand: () => createCommand
+});
+import { execSync as execSync4 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join7 } from "node:path";
+function validateName(name) {
+  if (!name)
+    return "Package name is required.";
+  if (!NAME_PATTERN.test(name))
+    return "Name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens.";
+  if (name.startsWith("locus-"))
+    return `Don't include the "locus-" prefix — it's added automatically.`;
+  if (name.length > 50)
+    return "Name must be 50 characters or fewer.";
+  return null;
+}
+function capitalize(str) {
+  return str.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function checkNpmExists(fullName) {
+  try {
+    execSync4(`npm view ${fullName} version 2>/dev/null`, {
+      stdio: "pipe",
+      timeout: 1e4
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseCreateArgs(args) {
+  let name = "";
+  let description = "";
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--description" || arg === "-D") {
+      description = args[++i] ?? "";
+    } else if (arg === "help" || arg === "--help" || arg === "-h") {
+      return null;
+    } else if (!arg.startsWith("-")) {
+      name = arg;
+    }
+    i++;
+  }
+  return { name, description };
+}
+function generatePackageJson(name, displayName, description, sdkVersion) {
+  const pkg = {
+    name: `@locusai/locus-${name}`,
+    version: "0.1.0",
+    description,
+    type: "module",
+    bin: {
+      [`locus-${name}`]: `./bin/locus-${name}.js`
+    },
+    files: ["bin", "package.json", "README.md"],
+    locus: {
+      displayName,
+      description,
+      commands: [name],
+      version: "0.1.0"
+    },
+    scripts: {
+      build: `bun build src/cli.ts --outfile bin/locus-${name}.js --target node`,
+      typecheck: "tsc --noEmit",
+      lint: "biome lint .",
+      format: "biome format --write ."
+    },
+    dependencies: {
+      "@locusai/sdk": `^${sdkVersion}`
+    },
+    devDependencies: {
+      typescript: "^5.8.3"
+    },
+    keywords: ["locusai-package", "locus", name],
+    engines: {
+      node: ">=18"
+    },
+    license: "MIT"
+  };
+  return `${JSON.stringify(pkg, null, 2)}
+`;
+}
+function generateTsconfig() {
+  const config = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      skipLibCheck: true,
+      esModuleInterop: true,
+      isolatedModules: true,
+      resolveJsonModule: true,
+      noEmit: true,
+      rootDir: "./src"
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist", "bin"]
+  };
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function generateCliTs() {
+  return `#!/usr/bin/env node
+
+import { main } from "./index.js";
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(\`Fatal error: \${error.message}\`);
+  process.exit(1);
+});
+`;
+}
+function generateIndexTs(name) {
+  return `import { createLogger, readLocusConfig } from "@locusai/sdk";
+
+const logger = createLogger("${name}");
+
+export async function main(args: string[]): Promise<void> {
+  const command = args[0] ?? "help";
+
+  switch (command) {
+    case "start":
+      return handleStart();
+    case "help":
+    case "--help":
+    case "-h":
+      return printHelp();
+    default:
+      console.error(\`Unknown command: \${command}\`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+// ─── Commands ────────────────────────────────────────────────────────────────
+
+function handleStart(): void {
+  const config = readLocusConfig();
+  logger.info(\`Hello from locus-${name}! Repo: \${config.github.owner}/\${config.github.repo}\`);
+  // TODO: Implement your package logic here
+}
+
+// ─── Help ────────────────────────────────────────────────────────────────────
+
+function printHelp(): void {
+  console.log(\`
+  locus-${name}
+
+  Usage:
+    locus pkg ${name} <command>
+
+  Commands:
+    start       Start the ${name} integration
+    help        Show this help message
+  \`);
+}
+`;
+}
+function generateReadme(name, displayName, description) {
+  return `# @locusai/locus-${name}
+
+${description}
+
+## Installation
+
+\`\`\`bash
+locus install ${name}
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+locus pkg ${name} start      # Start the integration
+locus pkg ${name} help       # Show help
+\`\`\`
+
+## Configuration
+
+Configure via \`locus config\`:
+
+\`\`\`bash
+locus config set packages.${name}.apiKey "your-api-key"
+\`\`\`
+
+## Development
+
+\`\`\`bash
+# Build
+bun run build
+
+# Type check
+bun run typecheck
+
+# Lint
+bun run lint
+
+# Test locally
+locus pkg ${name}
+\`\`\`
+
+## License
+
+MIT
+`;
+}
+function printHelp() {
+  process.stderr.write(`
+${bold2("locus create")} — Scaffold a new Locus community package
+
+${bold2("Usage:")}
+  locus create <name> [options]
+
+${bold2("Arguments:")}
+  ${cyan2("<name>")}               Package short name (e.g. slack, discord, jira)
+
+${bold2("Options:")}
+  ${dim2("--description, -D")}    Package description (default: auto-generated)
+  ${dim2("--help, -h")}           Show this help
+
+${bold2("Examples:")}
+  locus create slack                                    ${dim2("# Create packages/slack/")}
+  locus create discord -D "Control Locus via Discord"   ${dim2("# With custom description")}
+
+${bold2("What gets created:")}
+  packages/<name>/
+  ├── src/
+  │   ├── cli.ts          ${dim2("# Entry point")}
+  │   └── index.ts        ${dim2("# Main logic with command dispatch")}
+  ├── package.json        ${dim2("# Full config with locus manifest")}
+  ├── tsconfig.json       ${dim2("# TypeScript configuration")}
+  └── README.md           ${dim2("# Package documentation")}
+
+${bold2("Next steps after creation:")}
+  ${gray2("1.")} cd packages/<name>
+  ${gray2("2.")} Implement your logic in src/index.ts
+  ${gray2("3.")} bun install && bun run build
+  ${gray2("4.")} Test locally with: locus pkg <name>
+  ${gray2("5.")} Submit a pull request
+
+`);
+}
+async function createCommand(args) {
+  const parsed = parseCreateArgs(args);
+  if (!parsed || !parsed.name) {
+    printHelp();
+    if (parsed && !parsed.name) {
+      process.stderr.write(`${red2("✗")} Package name is required.
+
+`);
+      process.stderr.write(`  Usage: ${bold2("locus create <name>")}
+
+`);
+      process.exit(1);
+    }
+    return;
+  }
+  const { name } = parsed;
+  const displayName = capitalize(name);
+  const description = parsed.description || `${displayName} integration for Locus`;
+  const fullNpmName = `@locusai/locus-${name}`;
+  process.stderr.write(`
+${bold2("Creating package:")} ${cyan2(fullNpmName)}
+
+`);
+  const nameError = validateName(name);
+  if (nameError) {
+    process.stderr.write(`${red2("✗")} ${nameError}
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`${green("✓")} Name is valid: ${bold2(name)}
+`);
+  const packagesDir = join7(process.cwd(), "packages", name);
+  if (existsSync7(packagesDir)) {
+    process.stderr.write(`${red2("✗")} Directory already exists: ${bold2(`packages/${name}/`)}
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`${cyan2("●")} Checking npm registry...`);
+  const existsOnNpm = checkNpmExists(fullNpmName);
+  if (existsOnNpm) {
+    process.stderr.write(`\r${yellow2("⚠")} Package ${bold2(fullNpmName)} already exists on npm. You may want to choose a different name.
+`);
+  } else {
+    process.stderr.write(`\r${green("✓")} Name is available on npm                
+`);
+  }
+  let sdkVersion = "0.22.0";
+  try {
+    const sdkPkgPath = join7(process.cwd(), "packages", "sdk", "package.json");
+    if (existsSync7(sdkPkgPath)) {
+      const { readFileSync: readFileSync5 } = await import("node:fs");
+      const sdkPkg = JSON.parse(readFileSync5(sdkPkgPath, "utf-8"));
+      if (sdkPkg.version)
+        sdkVersion = sdkPkg.version;
+    }
+  } catch {}
+  mkdirSync6(join7(packagesDir, "src"), { recursive: true });
+  mkdirSync6(join7(packagesDir, "bin"), { recursive: true });
+  process.stderr.write(`${green("✓")} Created directory structure
+`);
+  writeFileSync5(join7(packagesDir, "package.json"), generatePackageJson(name, displayName, description, sdkVersion), "utf-8");
+  process.stderr.write(`${green("✓")} Generated package.json
+`);
+  writeFileSync5(join7(packagesDir, "tsconfig.json"), generateTsconfig(), "utf-8");
+  process.stderr.write(`${green("✓")} Generated tsconfig.json
+`);
+  writeFileSync5(join7(packagesDir, "src", "cli.ts"), generateCliTs(), "utf-8");
+  process.stderr.write(`${green("✓")} Generated src/cli.ts
+`);
+  writeFileSync5(join7(packagesDir, "src", "index.ts"), generateIndexTs(name), "utf-8");
+  process.stderr.write(`${green("✓")} Generated src/index.ts
+`);
+  writeFileSync5(join7(packagesDir, "README.md"), generateReadme(name, displayName, description), "utf-8");
+  process.stderr.write(`${green("✓")} Generated README.md
+`);
+  process.stderr.write(`
+${bold2(green("Package created!"))}
+
+`);
+  process.stderr.write(`${bold2("Next steps:")}
+`);
+  process.stderr.write(`  ${gray2("1.")} Implement your logic in ${bold2(`packages/${name}/src/index.ts`)}
+`);
+  process.stderr.write(`  ${gray2("2.")} Install dependencies: ${bold2("bun install")}
+`);
+  process.stderr.write(`  ${gray2("3.")} Build your package:   ${bold2(`cd packages/${name} && bun run build`)}
+`);
+  process.stderr.write(`  ${gray2("4.")} Test locally:         ${bold2(`locus pkg ${name}`)}
+`);
+  process.stderr.write(`  ${gray2("5.")} Submit a pull request
+`);
+  process.stderr.write(`
+  ${dim2("See the full guide:")} ${cyan2("packages/sdk/PACKAGE_GUIDE.md")}
+
+`);
+}
+var NAME_PATTERN;
+var init_create = __esm(() => {
+  init_terminal();
+  NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+});
+
 // src/packages/registry.ts
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync6,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync7,
   readFileSync as readFileSync5,
   renameSync,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function getPackagesDir() {
   const home = process.env.HOME || homedir2();
-  const dir = join7(home, ".locus", "packages");
-  if (!existsSync7(dir)) {
-    mkdirSync6(dir, { recursive: true });
+  const dir = join8(home, ".locus", "packages");
+  if (!existsSync8(dir)) {
+    mkdirSync7(dir, { recursive: true });
   }
-  const pkgJson = join7(dir, "package.json");
-  if (!existsSync7(pkgJson)) {
-    writeFileSync5(pkgJson, `${JSON.stringify({ private: true }, null, 2)}
+  const pkgJson = join8(dir, "package.json");
+  if (!existsSync8(pkgJson)) {
+    writeFileSync6(pkgJson, `${JSON.stringify({ private: true }, null, 2)}
 `, "utf-8");
   }
   return dir;
 }
 function getRegistryPath() {
-  return join7(getPackagesDir(), "registry.json");
+  return join8(getPackagesDir(), "registry.json");
 }
 function loadRegistry() {
   const registryPath = getRegistryPath();
-  if (!existsSync7(registryPath)) {
+  if (!existsSync8(registryPath)) {
     return { packages: {} };
   }
   try {
@@ -2271,7 +2620,7 @@ function loadRegistry() {
       }
       if (pruned) {
         const tmp = `${registryPath}.tmp`;
-        writeFileSync5(tmp, `${JSON.stringify(registry, null, 2)}
+        writeFileSync6(tmp, `${JSON.stringify(registry, null, 2)}
 `, "utf-8");
         renameSync(tmp, registryPath);
       }
@@ -2285,15 +2634,15 @@ function loadRegistry() {
 function saveRegistry(registry) {
   const registryPath = getRegistryPath();
   const tmp = `${registryPath}.tmp`;
-  writeFileSync5(tmp, `${JSON.stringify(registry, null, 2)}
+  writeFileSync6(tmp, `${JSON.stringify(registry, null, 2)}
 `, "utf-8");
   renameSync(tmp, registryPath);
 }
 function resolvePackageBinary(packageName) {
   const fullName = normalizePackageName(packageName);
   const binName = fullName.includes("/") ? fullName.split("/").pop() : fullName;
-  const binPath = join7(getPackagesDir(), "node_modules", ".bin", binName);
-  return existsSync7(binPath) ? binPath : null;
+  const binPath = join8(getPackagesDir(), "node_modules", ".bin", binName);
+  return existsSync8(binPath) ? binPath : null;
 }
 function normalizePackageName(input) {
   if (input.startsWith(SCOPED_PREFIX)) {
@@ -2319,7 +2668,7 @@ __export(exports_pkg, {
   listInstalledPackages: () => listInstalledPackages
 });
 import { spawn } from "node:child_process";
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 function listInstalledPackages() {
   const registry = loadRegistry();
   const entries = Object.values(registry.packages);
@@ -2398,7 +2747,7 @@ async function pkgCommand(args, _flags) {
     return;
   }
   let binaryPath = entry.binaryPath;
-  if (!binaryPath || !existsSync8(binaryPath)) {
+  if (!binaryPath || !existsSync9(binaryPath)) {
     const resolved = resolvePackageBinary(packageName);
     if (resolved) {
       binaryPath = resolved;
@@ -2531,8 +2880,8 @@ __export(exports_install, {
   installCommand: () => installCommand
 });
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
+import { join as join9 } from "node:path";
 function parsePackageArg(raw) {
   if (raw.startsWith("@")) {
     const slashIdx = raw.indexOf("/");
@@ -2609,8 +2958,8 @@ ${red2("✗")} Failed to install ${bold2(packageSpec)}.
     process.exit(1);
     return;
   }
-  const installedPkgJsonPath = join8(packagesDir, "node_modules", packageName, "package.json");
-  if (!existsSync9(installedPkgJsonPath)) {
+  const installedPkgJsonPath = join9(packagesDir, "node_modules", packageName, "package.json");
+  if (!existsSync10(installedPkgJsonPath)) {
     process.stderr.write(`
 ${red2("✗")} Package installed but package.json not found at:
 `);
@@ -2888,16 +3237,16 @@ __export(exports_logs, {
   logsCommand: () => logsCommand
 });
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   readdirSync as readdirSync2,
   readFileSync as readFileSync7,
   statSync as statSync2,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 async function logsCommand(cwd, options) {
-  const logsDir = join9(cwd, ".locus", "logs");
-  if (!existsSync10(logsDir)) {
+  const logsDir = join10(cwd, ".locus", "logs");
+  if (!existsSync11(logsDir)) {
     process.stderr.write(`${dim2("No logs found.")}
 `);
     return;
@@ -2952,8 +3301,8 @@ async function tailLog(logFile, levelFilter) {
   process.stderr.write(`${bold2("Tailing:")} ${dim2(logFile)} ${dim2("(Ctrl+C to stop)")}
 
 `);
-  let lastSize = existsSync10(logFile) ? statSync2(logFile).size : 0;
-  if (existsSync10(logFile)) {
+  let lastSize = existsSync11(logFile) ? statSync2(logFile).size : 0;
+  if (existsSync11(logFile)) {
     const content = readFileSync7(logFile, "utf-8");
     const lines = content.trim().split(`
 `).filter(Boolean);
@@ -2972,7 +3321,7 @@ async function tailLog(logFile, levelFilter) {
   }
   return new Promise((resolve) => {
     const interval = setInterval(() => {
-      if (!existsSync10(logFile))
+      if (!existsSync11(logFile))
         return;
       const currentSize = statSync2(logFile).size;
       if (currentSize <= lastSize)
@@ -3032,7 +3381,7 @@ function cleanLogs(logsDir) {
 `);
 }
 function getLogFiles(logsDir) {
-  return readdirSync2(logsDir).filter((f) => f.startsWith("locus-") && f.endsWith(".log")).map((f) => join9(logsDir, f)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
+  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);
 }
 function formatEntry(entry) {
   const time = dim2(new Date(entry.ts).toLocaleTimeString());
@@ -3341,10 +3690,10 @@ var init_stream_renderer = __esm(() => {
 });
 
 // src/repl/clipboard.ts
-import { execSync as execSync4 } from "node:child_process";
-import { existsSync as existsSync11, mkdirSync as mkdirSync7 } from "node:fs";
+import { execSync as execSync5 } from "node:child_process";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function readClipboardImage() {
   if (process.platform === "darwin") {
     return readMacOSClipboardImage();
@@ -3355,14 +3704,14 @@ function readClipboardImage() {
   return null;
 }
 function ensureStableDir() {
-  if (!existsSync11(STABLE_DIR)) {
-    mkdirSync7(STABLE_DIR, { recursive: true });
+  if (!existsSync12(STABLE_DIR)) {
+    mkdirSync8(STABLE_DIR, { recursive: true });
   }
 }
 function readMacOSClipboardImage() {
   try {
     ensureStableDir();
-    const destPath = join10(STABLE_DIR, `clipboard-${Date.now()}.png`);
+    const destPath = join11(STABLE_DIR, `clipboard-${Date.now()}.png`);
     const script = [
       `set destPath to POSIX file "${destPath}"`,
       "try",
@@ -3380,13 +3729,13 @@ function readMacOSClipboardImage() {
       `return "ok"`
     ].join(`
 `);
-    const result = execSync4("osascript", {
+    const result = execSync5("osascript", {
       input: script,
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    if (result === "ok" && existsSync11(destPath)) {
+    if (result === "ok" && existsSync12(destPath)) {
       return destPath;
     }
   } catch {}
@@ -3394,14 +3743,14 @@ function readMacOSClipboardImage() {
 }
 function readLinuxClipboardImage() {
   try {
-    const targets = execSync4("xclip -selection clipboard -t TARGETS -o 2>/dev/null", { encoding: "utf-8", timeout: 3000 });
+    const targets = execSync5("xclip -selection clipboard -t TARGETS -o 2>/dev/null", { encoding: "utf-8", timeout: 3000 });
     if (!targets.includes("image/png")) {
       return null;
     }
     ensureStableDir();
-    const destPath = join10(STABLE_DIR, `clipboard-${Date.now()}.png`);
-    execSync4(`xclip -selection clipboard -t image/png -o > "${destPath}" 2>/dev/null`, { timeout: 5000 });
-    if (existsSync11(destPath)) {
+    const destPath = join11(STABLE_DIR, `clipboard-${Date.now()}.png`);
+    execSync5(`xclip -selection clipboard -t image/png -o > "${destPath}" 2>/dev/null`, { timeout: 5000 });
+    if (existsSync12(destPath)) {
       return destPath;
     }
   } catch {}
@@ -3409,13 +3758,13 @@ function readLinuxClipboardImage() {
 }
 var STABLE_DIR;
 var init_clipboard = __esm(() => {
-  STABLE_DIR = join10(tmpdir(), "locus-images");
+  STABLE_DIR = join11(tmpdir(), "locus-images");
 });
 
 // src/repl/image-detect.ts
-import { copyFileSync, existsSync as existsSync12, mkdirSync as mkdirSync8 } from "node:fs";
+import { copyFileSync, existsSync as existsSync13, mkdirSync as mkdirSync9 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { basename, extname, join as join11, resolve } from "node:path";
+import { basename, extname, join as join12, resolve } from "node:path";
 function detectImages(input) {
   const detected = [];
   const byResolved = new Map;
@@ -3509,15 +3858,15 @@ function collectReferencedAttachments(input, attachments) {
   return dedupeByResolvedPath(selected);
 }
 function relocateImages(images, projectRoot) {
-  const targetDir = join11(projectRoot, ".locus", "tmp", "images");
+  const targetDir = join12(projectRoot, ".locus", "tmp", "images");
   for (const img of images) {
     if (!img.exists)
       continue;
     try {
-      if (!existsSync12(targetDir)) {
-        mkdirSync8(targetDir, { recursive: true });
+      if (!existsSync13(targetDir)) {
+        mkdirSync9(targetDir, { recursive: true });
       }
-      const dest = join11(targetDir, basename(img.stablePath));
+      const dest = join12(targetDir, basename(img.stablePath));
       copyFileSync(img.stablePath, dest);
       img.stablePath = dest;
     } catch {}
@@ -3529,7 +3878,7 @@ function addIfImage(rawPath, rawMatch, detected, byResolved) {
     return;
   let resolved = stripQuotes(rawPath).replace(/\\ /g, " ");
   if (resolved.startsWith("~/")) {
-    resolved = join11(homedir3(), resolved.slice(2));
+    resolved = join12(homedir3(), resolved.slice(2));
   }
   resolved = resolve(resolved);
   const existing = byResolved.get(resolved);
@@ -3542,7 +3891,7 @@ function addIfImage(rawPath, rawMatch, detected, byResolved) {
     ]);
     return;
   }
-  const exists = existsSync12(resolved);
+  const exists = existsSync13(resolved);
   let stablePath = resolved;
   if (exists) {
     stablePath = copyToStable(resolved);
@@ -3596,10 +3945,10 @@ function dedupeByResolvedPath(images) {
 }
 function copyToStable(sourcePath) {
   try {
-    if (!existsSync12(STABLE_DIR2)) {
-      mkdirSync8(STABLE_DIR2, { recursive: true });
+    if (!existsSync13(STABLE_DIR2)) {
+      mkdirSync9(STABLE_DIR2, { recursive: true });
     }
-    const dest = join11(STABLE_DIR2, `${Date.now()}-${basename(sourcePath)}`);
+    const dest = join12(STABLE_DIR2, `${Date.now()}-${basename(sourcePath)}`);
     copyFileSync(sourcePath, dest);
     return dest;
   } catch {
@@ -3619,7 +3968,7 @@ var init_image_detect = __esm(() => {
     ".tif",
     ".tiff"
   ]);
-  STABLE_DIR2 = join11(tmpdir2(), "locus-images");
+  STABLE_DIR2 = join12(tmpdir2(), "locus-images");
   PLACEHOLDER_ID_PATTERN = /\(locus:\/\/screenshot-(\d+)\)/g;
 });
 
@@ -3628,13 +3977,25 @@ class InputHandler {
   prompt;
   getHistory;
   onTab;
+  activeInsertText = null;
+  activeRender = null;
   locked = false;
   lastInterruptTime = 0;
+  pendingInsert = null;
   constructor(options) {
     this.prompt = options.prompt;
     this.getHistory = options.getHistory ?? (() => []);
     this.onTab = options.onTab;
   }
+  insertTextFromExternal(text) {
+    if (this.activeInsertText && this.activeRender) {
+      this.activeInsertText(text);
+      this.activeRender();
+    }
+  }
+  setInitialBuffer(text) {
+    this.pendingInsert = text;
+  }
   setPrompt(prompt) {
     this.prompt = prompt;
   }
@@ -3671,6 +4032,8 @@ class InputHandler {
         if (resolved)
           return;
         resolved = true;
+        this.activeInsertText = null;
+        this.activeRender = null;
         stdin.removeListener("data", onData);
         if (stdin.isTTY) {
           out.write(DISABLE_BRACKETED_PASTE + DISABLE_KITTY_KEYBOARD);
@@ -4138,6 +4501,12 @@ ${dim2("Press Ctrl+C again to exit")}\r
       if (stdin.isTTY) {
         out.write(ENABLE_BRACKETED_PASTE + ENABLE_KITTY_KEYBOARD);
       }
+      this.activeInsertText = insertText;
+      this.activeRender = render;
+      if (this.pendingInsert) {
+        insertText(this.pendingInsert);
+        this.pendingInsert = null;
+      }
       render();
     });
   }
@@ -4401,7 +4770,7 @@ __export(exports_claude, {
   buildClaudeArgs: () => buildClaudeArgs,
   ClaudeRunner: () => ClaudeRunner
 });
-import { execSync as execSync5, spawn as spawn2 } from "node:child_process";
+import { execSync as execSync6, spawn as spawn2 } from "node:child_process";
 function buildClaudeArgs(options) {
   const args = ["--dangerously-skip-permissions", "--no-session-persistence"];
   if (options.model) {
@@ -4419,7 +4788,7 @@ class ClaudeRunner {
   aborted = false;
   async isAvailable() {
     try {
-      execSync5("claude --version", {
+      execSync6("claude --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -4430,7 +4799,7 @@ class ClaudeRunner {
   }
   async getVersion() {
     try {
-      const output = execSync5("claude --version", {
+      const output = execSync6("claude --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -4597,8 +4966,8 @@ var init_claude = __esm(() => {
 import { exec } from "node:child_process";
 import {
   cpSync,
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync9,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync10,
   mkdtempSync,
   readdirSync as readdirSync3,
   readFileSync as readFileSync8,
@@ -4606,10 +4975,10 @@ import {
   statSync as statSync3
 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname3, join as join12, relative } from "node:path";
+import { dirname as dirname3, join as join13, relative } from "node:path";
 import { promisify } from "node:util";
 function parseIgnoreFile(filePath) {
-  if (!existsSync13(filePath))
+  if (!existsSync14(filePath))
     return [];
   const content = readFileSync8(filePath, "utf-8");
   const rules = [];
@@ -4679,7 +5048,7 @@ function findIgnoredPaths(projectRoot, rules) {
     for (const name of entries) {
       if (SKIP_DIRS.has(name))
         continue;
-      const fullPath = join12(dir, name);
+      const fullPath = join13(dir, name);
       let stat = null;
       try {
         stat = statSync3(fullPath);
@@ -4713,7 +5082,7 @@ function findIgnoredPaths(projectRoot, rules) {
 }
 function backupIgnoredFiles(projectRoot) {
   const log = getLogger();
-  const ignorePath = join12(projectRoot, ".sandboxignore");
+  const ignorePath = join13(projectRoot, ".sandboxignore");
   const rules = parseIgnoreFile(ignorePath);
   if (rules.length === 0)
     return NOOP_BACKUP;
@@ -4722,7 +5091,7 @@ function backupIgnoredFiles(projectRoot) {
     return NOOP_BACKUP;
   let backupDir;
   try {
-    backupDir = mkdtempSync(join12(tmpdir3(), "locus-sandbox-backup-"));
+    backupDir = mkdtempSync(join13(tmpdir3(), "locus-sandbox-backup-"));
   } catch (err) {
     log.debug("Failed to create sandbox backup dir", {
       error: err instanceof Error ? err.message : String(err)
@@ -4732,9 +5101,9 @@ function backupIgnoredFiles(projectRoot) {
   const backed = [];
   for (const src of paths) {
     const rel = relative(projectRoot, src);
-    const dest = join12(backupDir, rel);
+    const dest = join13(backupDir, rel);
     try {
-      mkdirSync9(dirname3(dest), { recursive: true });
+      mkdirSync10(dirname3(dest), { recursive: true });
       cpSync(src, dest, { recursive: true, preserveTimestamps: true });
       backed.push({ src, dest });
     } catch (err) {
@@ -4756,7 +5125,7 @@ function backupIgnoredFiles(projectRoot) {
     restore() {
       for (const { src, dest } of backed) {
         try {
-          mkdirSync9(dirname3(src), { recursive: true });
+          mkdirSync10(dirname3(src), { recursive: true });
           cpSync(dest, src, { recursive: true, preserveTimestamps: true });
         } catch (err) {
           log.debug("Failed to restore ignored file (potential data loss)", {
@@ -4774,7 +5143,7 @@ function backupIgnoredFiles(projectRoot) {
 }
 async function enforceSandboxIgnore(sandboxName, projectRoot) {
   const log = getLogger();
-  const ignorePath = join12(projectRoot, ".sandboxignore");
+  const ignorePath = join13(projectRoot, ".sandboxignore");
   const rules = parseIgnoreFile(ignorePath);
   if (rules.length === 0)
     return;
@@ -5019,7 +5388,7 @@ var init_claude_sandbox = __esm(() => {
 });
 
 // src/ai/codex.ts
-import { execSync as execSync6, spawn as spawn4 } from "node:child_process";
+import { execSync as execSync7, spawn as spawn4 } from "node:child_process";
 function buildCodexArgs(model) {
   const args = ["exec", "--full-auto", "--skip-git-repo-check", "--json"];
   if (model) {
@@ -5035,7 +5404,7 @@ class CodexRunner {
   aborted = false;
   async isAvailable() {
     try {
-      execSync6("codex --version", {
+      execSync7("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -5046,7 +5415,7 @@ class CodexRunner {
   }
   async getVersion() {
     try {
-      const output = execSync6("codex --version", {
+      const output = execSync7("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -7074,9 +7443,9 @@ var init_sprint = __esm(() => {
 });
 
 // src/core/prompt-builder.ts
-import { execSync as execSync7 } from "node:child_process";
-import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { execSync as execSync8 } from "node:child_process";
+import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
+import { join as join14 } from "node:path";
 function buildExecutionPrompt(ctx) {
   const sections = [];
   sections.push(buildSystemContext(ctx.projectRoot));
@@ -7106,13 +7475,13 @@ function buildFeedbackPrompt(ctx) {
 }
 function buildReplPrompt(userMessage, projectRoot, _config, previousMessages) {
   const sections = [];
-  const locusmd = readFileSafe(join13(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join14(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     sections.push(`<project-instructions>
 ${locusmd}
 </project-instructions>`);
   }
-  const learnings = readFileSafe(join13(projectRoot, ".locus", "LEARNINGS.md"));
+  const learnings = readFileSafe(join14(projectRoot, ".locus", "LEARNINGS.md"));
   if (learnings) {
     sections.push(`<past-learnings>
 ${learnings}
@@ -7139,24 +7508,24 @@ ${userMessage}
 }
 function buildSystemContext(projectRoot) {
   const parts = [];
-  const locusmd = readFileSafe(join13(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join14(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     parts.push(`<project-instructions>
 ${locusmd}
 </project-instructions>`);
   }
-  const learnings = readFileSafe(join13(projectRoot, ".locus", "LEARNINGS.md"));
+  const learnings = readFileSafe(join14(projectRoot, ".locus", "LEARNINGS.md"));
   if (learnings) {
     parts.push(`<past-learnings>
 ${learnings}
 </past-learnings>`);
   }
-  const discussionsDir = join13(projectRoot, ".locus", "discussions");
-  if (existsSync14(discussionsDir)) {
+  const discussionsDir = join14(projectRoot, ".locus", "discussions");
+  if (existsSync15(discussionsDir)) {
     try {
       const files = readdirSync4(discussionsDir).filter((f) => f.endsWith(".md")).slice(0, 3);
       for (const file of files) {
-        const content = readFileSafe(join13(discussionsDir, file));
+        const content = readFileSafe(join14(discussionsDir, file));
         if (content) {
           const name = file.replace(".md", "");
           parts.push(`<discussion name="${name}">
@@ -7223,7 +7592,7 @@ ${parts.join(`
 function buildRepoContext(projectRoot) {
   const parts = [];
   try {
-    const tree = execSync7("find . -maxdepth 2 -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/.locus/*' -not -path '*/dist/*' -not -path '*/build/*' | head -80", { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const tree = execSync8("find . -maxdepth 2 -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/.locus/*' -not -path '*/dist/*' -not -path '*/build/*' | head -80", { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     if (tree) {
       parts.push(`<file-tree>
 \`\`\`
@@ -7233,7 +7602,7 @@ ${tree}
     }
   } catch {}
   try {
-    const gitLog = execSync7("git log --oneline -10", {
+    const gitLog = execSync8("git log --oneline -10", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7247,7 +7616,7 @@ ${gitLog}
     }
   } catch {}
   try {
-    const branch = execSync7("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync8("git rev-parse --abbrev-ref HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7309,7 +7678,7 @@ function buildFeedbackInstructions() {
 }
 function readFileSafe(path) {
   try {
-    if (!existsSync14(path))
+    if (!existsSync15(path))
       return null;
     return readFileSync9(path, "utf-8");
   } catch {
@@ -7503,18 +7872,18 @@ var init_diff_renderer = __esm(() => {
 });
 
 // src/repl/commands.ts
-import { execSync as execSync8 } from "node:child_process";
+import { execSync as execSync9 } from "node:child_process";
 function getSlashCommands() {
   return [
     {
       name: "/help",
-      aliases: ["/h", "/?"],
+      aliases: ["/h"],
       description: "Show available commands",
       handler: cmdHelp
     },
     {
       name: "/clear",
-      aliases: ["/cls"],
+      aliases: [],
       description: "Clear screen",
       handler: cmdClear
     },
@@ -7550,7 +7919,7 @@ function getSlashCommands() {
     },
     {
       name: "/undo",
-      aliases: ["/u"],
+      aliases: [],
       description: "Undo last AI change",
       handler: cmdUndo
     },
@@ -7562,10 +7931,16 @@ function getSlashCommands() {
     },
     {
       name: "/verbose",
-      aliases: ["/v"],
+      aliases: [],
       description: "Toggle verbose mode (show agent stderr streams)",
       handler: cmdVerbose
     },
+    {
+      name: "/voice",
+      aliases: ["/v"],
+      description: "Start voice recording (press Enter to stop)",
+      handler: cmdVoice
+    },
     {
       name: "/exit",
       aliases: ["/quit", "/q"],
@@ -7695,7 +8070,7 @@ function cmdModel(args, ctx) {
 }
 function cmdDiff(_args, ctx) {
   try {
-    const diff = execSync8("git diff", {
+    const diff = execSync9("git diff", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7731,7 +8106,7 @@ function cmdDiff(_args, ctx) {
 }
 function cmdUndo(_args, ctx) {
   try {
-    const status = execSync8("git status --porcelain", {
+    const status = execSync9("git status --porcelain", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7741,7 +8116,7 @@ function cmdUndo(_args, ctx) {
 `);
       return;
     }
-    execSync8("git checkout .", {
+    execSync9("git checkout .", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7764,6 +8139,14 @@ function cmdVerbose(_args, ctx) {
   process.stderr.write(`${isOn ? green("✓") : dim2("○")} Verbose mode ${isOn ? bold2("on") : "off"} — agent streams ${isOn ? "visible" : "hidden"}.
 `);
 }
+function cmdVoice(_args, ctx) {
+  if (ctx.onVoiceToggle) {
+    ctx.onVoiceToggle();
+  } else {
+    process.stderr.write(`${red2("✗")} Voice input not available in this session.
+`);
+  }
+}
 function cmdExit(_args, ctx) {
   ctx.onExit();
 }
@@ -7775,7 +8158,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 join14 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join15 } from "node:path";
 
 class SlashCommandCompletion {
   commands;
@@ -7830,7 +8213,7 @@ class FilePathCompletion {
   }
   findMatches(partial) {
     try {
-      const dir = partial.includes("/") ? join14(this.projectRoot, dirname4(partial)) : this.projectRoot;
+      const dir = partial.includes("/") ? join15(this.projectRoot, dirname4(partial)) : this.projectRoot;
       const prefix = basename2(partial);
       const entries = readdirSync5(dir, { withFileTypes: true });
       return entries.filter((e) => {
@@ -7866,14 +8249,14 @@ class CombinedCompletion {
 var init_completions = () => {};
 
 // src/repl/input-history.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join15 } from "node:path";
+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";
 
 class InputHistory {
   entries = [];
   filePath;
   constructor(projectRoot) {
-    this.filePath = join15(projectRoot, ".locus", "sessions", ".input-history");
+    this.filePath = join16(projectRoot, ".locus", "sessions", ".input-history");
     this.load();
   }
   add(text) {
@@ -7912,7 +8295,7 @@ class InputHistory {
   }
   load() {
     try {
-      if (!existsSync15(this.filePath))
+      if (!existsSync16(this.filePath))
         return;
       const content = readFileSync10(this.filePath, "utf-8");
       this.entries = content.split(`
@@ -7922,12 +8305,12 @@ class InputHistory {
   save() {
     try {
       const dir = dirname5(this.filePath);
-      if (!existsSync15(dir)) {
-        mkdirSync10(dir, { recursive: true });
+      if (!existsSync16(dir)) {
+        mkdirSync11(dir, { recursive: true });
       }
       const content = this.entries.map((e) => this.escape(e)).join(`
 `);
-      writeFileSync6(this.filePath, content, "utf-8");
+      writeFileSync7(this.filePath, content, "utf-8");
     } catch {}
   }
   escape(text) {
@@ -7953,21 +8336,21 @@ var init_model_config = __esm(() => {
 
 // src/repl/session-manager.ts
 import {
-  existsSync as existsSync16,
-  mkdirSync as mkdirSync11,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync12,
   readdirSync as readdirSync6,
   readFileSync as readFileSync11,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "node:fs";
-import { basename as basename3, join as join16 } from "node:path";
+import { basename as basename3, join as join17 } from "node:path";
 
 class SessionManager {
   sessionsDir;
   constructor(projectRoot) {
-    this.sessionsDir = join16(projectRoot, ".locus", "sessions");
-    if (!existsSync16(this.sessionsDir)) {
-      mkdirSync11(this.sessionsDir, { recursive: true });
+    this.sessionsDir = join17(projectRoot, ".locus", "sessions");
+    if (!existsSync17(this.sessionsDir)) {
+      mkdirSync12(this.sessionsDir, { recursive: true });
     }
   }
   create(options) {
@@ -7992,12 +8375,12 @@ class SessionManager {
   }
   isPersisted(sessionOrId) {
     const sessionId = typeof sessionOrId === "string" ? sessionOrId : sessionOrId.id;
-    return existsSync16(this.getSessionPath(sessionId));
+    return existsSync17(this.getSessionPath(sessionId));
   }
   load(idOrPrefix) {
     const files = this.listSessionFiles();
     const exactPath = this.getSessionPath(idOrPrefix);
-    if (existsSync16(exactPath)) {
+    if (existsSync17(exactPath)) {
       try {
         return JSON.parse(readFileSync11(exactPath, "utf-8"));
       } catch {
@@ -8020,7 +8403,7 @@ class SessionManager {
   save(session) {
     session.updated = new Date().toISOString();
     const path = this.getSessionPath(session.id);
-    writeFileSync7(path, `${JSON.stringify(session, null, 2)}
+    writeFileSync8(path, `${JSON.stringify(session, null, 2)}
 `, "utf-8");
   }
   addMessage(session, message) {
@@ -8047,7 +8430,7 @@ class SessionManager {
   }
   delete(sessionId) {
     const path = this.getSessionPath(sessionId);
-    if (existsSync16(path)) {
+    if (existsSync17(path)) {
       unlinkSync3(path);
       return true;
     }
@@ -8077,7 +8460,7 @@ class SessionManager {
     const remaining = withStats.length - pruned;
     if (remaining > MAX_SESSIONS) {
       const toRemove = remaining - MAX_SESSIONS;
-      const alive = withStats.filter((e) => existsSync16(e.path));
+      const alive = withStats.filter((e) => existsSync17(e.path));
       for (let i = 0;i < toRemove && i < alive.length; i++) {
         try {
           unlinkSync3(alive[i].path);
@@ -8092,7 +8475,7 @@ class SessionManager {
   }
   listSessionFiles() {
     try {
-      return readdirSync6(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join16(this.sessionsDir, f));
+      return readdirSync6(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join17(this.sessionsDir, f));
     } catch {
       return [];
     }
@@ -8101,7 +8484,7 @@ class SessionManager {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
   getSessionPath(sessionId) {
-    return join16(this.sessionsDir, `${sessionId}.json`);
+    return join17(this.sessionsDir, `${sessionId}.json`);
   }
 }
 var MAX_SESSIONS = 50, SESSION_MAX_AGE_MS;
@@ -8110,8 +8493,544 @@ var init_session_manager = __esm(() => {
   SESSION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
 });
 
+// src/repl/voice.ts
+import { execSync as execSync10, spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, 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";
+function getWhisperModelPath() {
+  return join18(WHISPER_MODELS_DIR, `ggml-${WHISPER_MODEL}.bin`);
+}
+function commandExists(cmd) {
+  try {
+    const which = platform() === "win32" ? "where" : "which";
+    execSync10(`${which} ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findWhisperBinary() {
+  const candidates = ["whisper-cli", "whisper-cpp", "whisper", "main"];
+  for (const name of candidates) {
+    if (commandExists(name))
+      return name;
+  }
+  for (const name of candidates) {
+    const fullPath = join18(LOCUS_BIN_DIR, name);
+    if (existsSync18(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))
+          return fullPath;
+      }
+    }
+  }
+  return null;
+}
+function findSoxRecBinary() {
+  if (commandExists("rec"))
+    return "rec";
+  if (commandExists("sox"))
+    return "sox";
+  if (platform() === "darwin") {
+    const brewDirs = ["/opt/homebrew/bin", "/usr/local/bin"];
+    for (const dir of brewDirs) {
+      const recPath = join18(dir, "rec");
+      if (existsSync18(recPath))
+        return recPath;
+      const soxPath = join18(dir, "sox");
+      if (existsSync18(soxPath))
+        return soxPath;
+    }
+  }
+  return null;
+}
+function checkDependencies() {
+  const soxBinary = findSoxRecBinary();
+  const whisperBinary = findWhisperBinary();
+  const modelDownloaded = existsSync18(getWhisperModelPath());
+  return {
+    sox: soxBinary !== null,
+    whisper: whisperBinary !== null,
+    whisperBinary,
+    soxBinary,
+    modelDownloaded
+  };
+}
+function printDependencyHelp(deps) {
+  const out = process.stderr;
+  out.write(`
+${bold2("Voice Input Setup")}
+
+`);
+  if (!deps.sox) {
+    out.write(`  ${red2("✗")} ${bold2("sox")} — audio recording
+`);
+    if (platform() === "darwin") {
+      out.write(`    Install: ${cyan2("brew install sox")}
+`);
+    } else {
+      out.write(`    Install: ${cyan2("sudo apt install sox")} or ${cyan2("sudo dnf install sox")}
+`);
+    }
+  } else {
+    out.write(`  ${green("✓")} ${bold2("sox")} — audio recording ${dim2(`(${deps.soxBinary})`)}
+`);
+  }
+  if (!deps.whisper) {
+    out.write(`  ${red2("✗")} ${bold2("whisper.cpp")} — speech-to-text
+`);
+    if (platform() === "darwin") {
+      out.write(`    Install: ${cyan2("brew install whisper-cpp")}
+`);
+    } else {
+      out.write(`    Install: Build from source — ${cyan2("https://github.com/ggerganov/whisper.cpp")}
+`);
+    }
+  } else {
+    out.write(`  ${green("✓")} ${bold2("whisper.cpp")} — speech-to-text ${dim2(`(${deps.whisperBinary})`)}
+`);
+  }
+  if (deps.whisper && !deps.modelDownloaded) {
+    out.write(`  ${yellow2("!")} Model ${bold2(WHISPER_MODEL)} not downloaded yet — will download on first use (~150MB)
+`);
+    out.write(`    Path: ${dim2(getWhisperModelPath())}
+`);
+  } else if (deps.whisper && deps.modelDownloaded) {
+    out.write(`  ${green("✓")} Model ${bold2(WHISPER_MODEL)} ${dim2("ready")}
+`);
+  }
+  out.write(`
+`);
+  if (!deps.sox || !deps.whisper) {
+    out.write(`  ${dim2("Install the missing dependencies above, then try again.")}
+
+`);
+  }
+}
+function detectPackageManager() {
+  if (platform() === "darwin") {
+    return commandExists("brew") ? "brew" : null;
+  }
+  if (commandExists("apt-get"))
+    return "apt";
+  if (commandExists("dnf"))
+    return "dnf";
+  if (commandExists("pacman"))
+    return "pacman";
+  return null;
+}
+function installSox(pm) {
+  try {
+    switch (pm) {
+      case "brew":
+        execSync10("brew install sox", { stdio: "inherit", timeout: 300000 });
+        break;
+      case "apt":
+        execSync10("sudo apt-get install -y sox", {
+          stdio: "inherit",
+          timeout: 300000
+        });
+        break;
+      case "dnf":
+        execSync10("sudo dnf install -y sox", {
+          stdio: "inherit",
+          timeout: 300000
+        });
+        break;
+      case "pacman":
+        execSync10("sudo pacman -S --noconfirm sox", {
+          stdio: "inherit",
+          timeout: 300000
+        });
+        break;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installWhisperCpp(pm) {
+  if (pm === "brew") {
+    try {
+      execSync10("brew install whisper-cpp", {
+        stdio: "inherit",
+        timeout: 300000
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return buildWhisperFromSource(pm);
+}
+function ensureBuildDeps(pm) {
+  const hasCmake = commandExists("cmake");
+  const hasCxx = commandExists("g++") || commandExists("c++");
+  const hasGit = commandExists("git");
+  if (hasCmake && hasCxx && hasGit)
+    return true;
+  process.stderr.write(`  ${dim2("Installing build tools...")}
+`);
+  try {
+    switch (pm) {
+      case "apt":
+        execSync10("sudo apt-get install -y cmake g++ make git", {
+          stdio: "inherit",
+          timeout: 300000
+        });
+        break;
+      case "dnf":
+        execSync10("sudo dnf install -y cmake gcc-c++ make git", {
+          stdio: "inherit",
+          timeout: 300000
+        });
+        break;
+      case "pacman":
+        execSync10("sudo pacman -S --noconfirm cmake gcc make git", {
+          stdio: "inherit",
+          timeout: 300000
+        });
+        break;
+      default:
+        return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildWhisperFromSource(pm) {
+  const out = process.stderr;
+  const buildDir = join18(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 });
+    out.write(`  ${dim2("Cloning whisper.cpp...")}
+`);
+    execSync10(`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");
+    const numCpus = cpus().length || 2;
+    out.write(`  ${dim2("Building whisper.cpp (this may take a few minutes)...")}
+`);
+    execSync10("cmake -B build -DCMAKE_BUILD_TYPE=Release", {
+      cwd: srcDir,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 120000
+    });
+    execSync10(`cmake --build build --config Release -j${numCpus}`, {
+      cwd: srcDir,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 600000
+    });
+    const destPath = join18(LOCUS_BIN_DIR, "whisper-cli");
+    const binaryCandidates = [
+      join18(srcDir, "build", "bin", "whisper-cli"),
+      join18(srcDir, "build", "bin", "main")
+    ];
+    for (const candidate of binaryCandidates) {
+      if (existsSync18(candidate)) {
+        execSync10(`cp "${candidate}" "${destPath}" && chmod +x "${destPath}"`, {
+          stdio: "pipe"
+        });
+        return true;
+      }
+    }
+    out.write(`  ${red2("✗")} Build completed but whisper-cli binary not found.
+`);
+    return false;
+  } catch (e) {
+    out.write(`  ${red2("✗")} Build failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    return false;
+  } finally {
+    try {
+      execSync10(`rm -rf "${buildDir}"`, { stdio: "pipe" });
+    } catch {}
+  }
+}
+function autoInstallDependencies(deps) {
+  if (platform() === "win32") {
+    process.stderr.write(`
+${red2("✗")} Voice input is not supported on Windows.
+
+`);
+    return false;
+  }
+  const pm = detectPackageManager();
+  if (!pm) {
+    process.stderr.write(`
+${red2("✗")} No supported package manager found.
+`);
+    if (platform() === "darwin") {
+      process.stderr.write(`  Install Homebrew first: ${cyan2("https://brew.sh")}
+`);
+    }
+    process.stderr.write(`
+`);
+    return false;
+  }
+  const out = process.stderr;
+  out.write(`
+${bold2("Installing voice dependencies...")}
+
+`);
+  if (!deps.sox) {
+    out.write(`  ${dim2("Installing")} ${bold2("sox")} ${dim2("(audio recording)...")}
+`);
+    if (!installSox(pm)) {
+      out.write(`  ${red2("✗")} Failed to install sox.
+
+`);
+      return false;
+    }
+    out.write(`  ${green("✓")} sox installed
+
+`);
+  }
+  if (!deps.whisper) {
+    out.write(`  ${dim2("Installing")} ${bold2("whisper.cpp")} ${dim2("(speech-to-text)...")}
+`);
+    if (!installWhisperCpp(pm)) {
+      out.write(`  ${red2("✗")} Failed to install whisper.cpp.
+
+`);
+      return false;
+    }
+    out.write(`  ${green("✓")} whisper.cpp installed
+
+`);
+  }
+  out.write(`${green("✓")} Voice dependencies ready.
+
+`);
+  return true;
+}
+function downloadModel() {
+  const modelPath = getWhisperModelPath();
+  if (existsSync18(modelPath))
+    return true;
+  mkdirSync13(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)...")}
+`);
+  try {
+    if (commandExists("curl")) {
+      execSync10(`curl -L -o "${modelPath}" "${url}"`, {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 300000
+      });
+    } else if (commandExists("wget")) {
+      execSync10(`wget -O "${modelPath}" "${url}"`, {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 300000
+      });
+    } else {
+      process.stderr.write(`${red2("✗")} Neither curl nor wget found. Download the model manually:
+`);
+      process.stderr.write(`    ${cyan2(url)}
+`);
+      process.stderr.write(`    Save to: ${dim2(modelPath)}
+`);
+      return false;
+    }
+    process.stderr.write(`${green("✓")} Model downloaded to ${dim2(modelPath)}
+`);
+    return true;
+  } catch (e) {
+    process.stderr.write(`${red2("✗")} Failed to download model: ${e instanceof Error ? e.message : String(e)}
+`);
+    try {
+      unlinkSync4(modelPath);
+    } catch {}
+    return false;
+  }
+}
+
+class VoiceController {
+  state = "idle";
+  recordProcess = null;
+  tempFile;
+  deps;
+  onStateChange;
+  constructor(options) {
+    this.onStateChange = options.onStateChange;
+    this.tempFile = join18(tmpdir4(), `locus-voice-${process.pid}.wav`);
+    this.deps = checkDependencies();
+  }
+  getState() {
+    return this.state;
+  }
+  startRecording() {
+    if (this.state !== "idle")
+      return false;
+    this.deps = checkDependencies();
+    if (!this.deps.sox || !this.deps.whisper) {
+      if (!autoInstallDependencies(this.deps)) {
+        return false;
+      }
+      this.deps = checkDependencies();
+      if (!this.deps.sox || !this.deps.whisper) {
+        printDependencyHelp(this.deps);
+        return false;
+      }
+    }
+    if (!this.deps.modelDownloaded) {
+      if (!downloadModel()) {
+        return false;
+      }
+      this.deps.modelDownloaded = true;
+    }
+    const args = this.buildRecordArgs();
+    if (!args)
+      return false;
+    const binary = this.deps.soxBinary;
+    if (!binary) {
+      process.stderr.write(`${red2("✗")} sox binary not found. Please install sox and try again.
+`);
+      return false;
+    }
+    const spawnArgs = binary === "rec" ? args : ["-d", ...args];
+    this.recordProcess = spawn6(binary, spawnArgs, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.recordProcess.on("error", (err) => {
+      process.stderr.write(`\r
+${red2("✗")} Recording failed: ${err.message}\r
+`);
+      this.setState("idle");
+    });
+    this.setState("recording");
+    return true;
+  }
+  buildRecordArgs() {
+    return [
+      "-r",
+      "16000",
+      "-c",
+      "1",
+      "-b",
+      "16",
+      this.tempFile
+    ];
+  }
+  async stopAndTranscribe() {
+    if (!this.recordProcess) {
+      this.setState("idle");
+      return null;
+    }
+    this.recordProcess.kill("SIGTERM");
+    this.recordProcess = null;
+    this.setState("idle");
+    await sleep2(200);
+    if (!existsSync18(this.tempFile)) {
+      return null;
+    }
+    try {
+      const text = await this.transcribe();
+      return text || null;
+    } catch (e) {
+      process.stderr.write(`${red2("✗")} Transcription failed: ${e instanceof Error ? e.message : String(e)}
+`);
+      return null;
+    } finally {
+      try {
+        unlinkSync4(this.tempFile);
+      } catch {}
+    }
+  }
+  transcribe() {
+    return new Promise((resolve2, reject) => {
+      const binary = this.deps.whisperBinary;
+      if (!binary) {
+        process.stderr.write(`${red2("✗")} whisper.cpp binary not found. Please install whisper.cpp and try again.
+`);
+        reject(new Error("whisper.cpp binary not found. Please install whisper.cpp and try again."));
+        return;
+      }
+      const modelPath = getWhisperModelPath();
+      const args = [
+        "-m",
+        modelPath,
+        "-f",
+        this.tempFile,
+        "--no-timestamps",
+        "--language",
+        WHISPER_MODEL.endsWith(".en") ? "en" : "auto"
+      ];
+      const proc = spawn6(binary, args, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("error", (err) => {
+        reject(new Error(`whisper.cpp failed to start: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`whisper.cpp exited with code ${code}: ${stderr.trim()}`));
+          return;
+        }
+        const text = stdout.split(`
+`).map((line) => line.replace(/^\[.*?\]\s*/, "").trim()).filter((line) => line.length > 0).join(" ").trim();
+        resolve2(text);
+      });
+    });
+  }
+  cancel() {
+    if (this.recordProcess) {
+      this.recordProcess.kill("SIGKILL");
+      this.recordProcess = null;
+    }
+    try {
+      unlinkSync4(this.tempFile);
+    } catch {}
+    this.setState("idle");
+  }
+  setState(state) {
+    this.state = state;
+    this.onStateChange(state);
+  }
+}
+function voiceStatusIndicator(state) {
+  switch (state) {
+    case "recording":
+      return `${red2(bold2("[REC]"))} `;
+    case "transcribing":
+      return ` ${yellow2("[...]")} `;
+    default:
+      return "";
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, 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");
+});
+
 // src/repl/repl.ts
-import { execSync as execSync9 } from "node:child_process";
+import { execSync as execSync11 } from "node:child_process";
 async function startRepl(options) {
   const { projectRoot, config } = options;
   const sessionManager = new SessionManager(projectRoot);
@@ -8129,7 +9048,7 @@ async function startRepl(options) {
   } else {
     let branch = "main";
     try {
-      branch = execSync9("git rev-parse --abbrev-ref HEAD", {
+      branch = execSync11("git rev-parse --abbrev-ref HEAD", {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -8195,8 +9114,15 @@ async function runInteractiveRepl(session, sessionManager, options) {
     new SlashCommandCompletion(getAllCommandNames()),
     new FilePathCompletion(projectRoot)
   ]);
+  const basePrompt = `${cyan2("locus")} ${dim2(">")} `;
+  const voice = new VoiceController({
+    onStateChange: (state) => {
+      const indicator = voiceStatusIndicator(state);
+      input.setPrompt(indicator ? `${indicator}${basePrompt}` : basePrompt);
+    }
+  });
   const input = new InputHandler({
-    prompt: `${cyan2("locus")} ${dim2(">")} `,
+    prompt: basePrompt,
     getHistory: () => history.getEntries(),
     onTab: (text) => completion.complete(text)
   });
@@ -8249,12 +9175,33 @@ async function runInteractiveRepl(session, sessionManager, options) {
     onVerboseToggle: () => {
       verbose = !verbose;
     },
-    getVerbose: () => verbose
+    getVerbose: () => verbose,
+    onVoiceToggle: () => {
+      if (voice.getState() !== "idle")
+        return;
+      const started = voice.startRecording();
+      if (started) {
+        process.stderr.write(`${dim2("Recording... press")} ${bold2("Enter")} ${dim2("to stop")}
+`);
+      }
+    }
   };
   while (!shouldExit) {
     const result = await input.readline();
     switch (result.type) {
       case "submit": {
+        if (voice.getState() === "recording") {
+          process.stderr.write(`${dim2("Transcribing...")}
+`);
+          const transcribed = await voice.stopAndTranscribe();
+          if (transcribed) {
+            input.setInitialBuffer(transcribed);
+          } else {
+            process.stderr.write(`${yellow2("!")} No speech detected.
+`);
+          }
+          continue;
+        }
         const text = result.text.trim();
         if (!text)
           continue;
@@ -8305,6 +9252,7 @@ ${red2("✗")} ${msg}
         break;
     }
   }
+  voice.cancel();
   const shouldPersistOnExit = session.messages.length > 0 || sessionManager.isPersisted(session);
   if (shouldPersistOnExit) {
     sessionManager.save(session);
@@ -8370,7 +9318,7 @@ function printWelcome(session) {
   }
   process.stderr.write(`
 `);
-  process.stderr.write(`  ${dim2("Type /help for commands, Shift+Enter for newline, Ctrl+C twice to exit")}
+  process.stderr.write(`  ${dim2("Type /help for commands, Shift+Enter for newline, /v for voice input")}
 `);
   process.stderr.write(`
 `);
@@ -8390,6 +9338,7 @@ var init_repl = __esm(() => {
   init_input_history();
   init_model_config();
   init_session_manager();
+  init_voice();
   LOCUS_LOGO = [
     "      ▄█                 ",
     "  ▄▄████▄▄▄▄             ",
@@ -8587,11 +9536,11 @@ var init_exec = __esm(() => {
 });
 
 // src/core/submodule.ts
-import { execSync as execSync10 } from "node:child_process";
-import { existsSync as existsSync17 } from "node:fs";
-import { join as join17 } from "node:path";
+import { execSync as execSync12 } from "node:child_process";
+import { existsSync as existsSync19 } from "node:fs";
+import { join as join19 } from "node:path";
 function git2(args, cwd) {
-  return execSync10(`git ${args}`, {
+  return execSync12(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -8605,7 +9554,7 @@ function gitSafe(args, cwd) {
   }
 }
 function hasSubmodules(cwd) {
-  return existsSync17(join17(cwd, ".gitmodules"));
+  return existsSync19(join19(cwd, ".gitmodules"));
 }
 function listSubmodules(cwd) {
   if (!hasSubmodules(cwd))
@@ -8625,7 +9574,7 @@ function listSubmodules(cwd) {
         continue;
       submodules.push({
         path,
-        absolutePath: join17(cwd, path),
+        absolutePath: join19(cwd, path),
         dirty
       });
     }
@@ -8638,7 +9587,7 @@ function getDirtySubmodules(cwd) {
   const submodules = listSubmodules(cwd);
   const dirty = [];
   for (const sub of submodules) {
-    if (!existsSync17(sub.absolutePath))
+    if (!existsSync19(sub.absolutePath))
       continue;
     const status = gitSafe("status --porcelain", sub.absolutePath);
     if (status && status.trim().length > 0) {
@@ -8659,7 +9608,7 @@ function commitDirtySubmodules(cwd, issueNumber, issueTitle) {
       const message = `chore: complete #${issueNumber} - ${issueTitle}
 
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
-      execSync10("git commit -F -", {
+      execSync12("git commit -F -", {
         input: message,
         cwd: sub.absolutePath,
         encoding: "utf-8",
@@ -8725,7 +9674,7 @@ function pushSubmoduleBranches(cwd) {
   const log = getLogger();
   const submodules = listSubmodules(cwd);
   for (const sub of submodules) {
-    if (!existsSync17(sub.absolutePath))
+    if (!existsSync19(sub.absolutePath))
       continue;
     const branch = gitSafe("rev-parse --abbrev-ref HEAD", sub.absolutePath)?.trim();
     if (!branch || branch === "HEAD")
@@ -8746,7 +9695,7 @@ var init_submodule = __esm(() => {
 });
 
 // src/core/agent.ts
-import { execSync as execSync11 } from "node:child_process";
+import { execSync as execSync13 } from "node:child_process";
 async function executeIssue(projectRoot, options) {
   const log = getLogger();
   const timer = createTimer();
@@ -8775,7 +9724,7 @@ ${cyan2("●")} ${bold2(`#${issueNumber}`)} ${issue.title}
   }
   let issueComments = [];
   try {
-    const commentsRaw = execSync11(`gh issue view ${issueNumber} --json comments --jq '.comments[].body'`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const commentsRaw = execSync13(`gh issue view ${issueNumber} --json comments --jq '.comments[].body'`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     if (commentsRaw) {
       issueComments = commentsRaw.split(`
 `).filter(Boolean);
@@ -8939,12 +9888,12 @@ ${aiResult.success ? green("✓") : red2("✗")} Iteration ${aiResult.success ?
 }
 async function createIssuePR(projectRoot, config, issue) {
   try {
-    const currentBranch = execSync11("git rev-parse --abbrev-ref HEAD", {
+    const currentBranch = execSync13("git rev-parse --abbrev-ref HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const diff = execSync11(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
+    const diff = execSync13(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -8954,7 +9903,7 @@ async function createIssuePR(projectRoot, config, issue) {
       return;
     }
     pushSubmoduleBranches(projectRoot);
-    execSync11(`git push -u origin ${currentBranch}`, {
+    execSync13(`git push -u origin ${currentBranch}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9009,9 +9958,9 @@ var init_agent = __esm(() => {
 });
 
 // src/core/conflict.ts
-import { execSync as execSync12 } from "node:child_process";
+import { execSync as execSync14 } from "node:child_process";
 function git3(args, cwd) {
-  return execSync12(`git ${args}`, {
+  return execSync14(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -9140,19 +10089,19 @@ var init_conflict = __esm(() => {
 
 // src/core/run-state.ts
 import {
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync14,
   readFileSync as readFileSync12,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync8
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import { dirname as dirname6, join as join18 } from "node:path";
+import { dirname as dirname6, join as join20 } from "node:path";
 function getRunStatePath(projectRoot) {
-  return join18(projectRoot, ".locus", "run-state.json");
+  return join20(projectRoot, ".locus", "run-state.json");
 }
 function loadRunState(projectRoot) {
   const path = getRunStatePath(projectRoot);
-  if (!existsSync18(path))
+  if (!existsSync20(path))
     return null;
   try {
     return JSON.parse(readFileSync12(path, "utf-8"));
@@ -9164,16 +10113,16 @@ function loadRunState(projectRoot) {
 function saveRunState(projectRoot, state) {
   const path = getRunStatePath(projectRoot);
   const dir = dirname6(path);
-  if (!existsSync18(dir)) {
-    mkdirSync12(dir, { recursive: true });
+  if (!existsSync20(dir)) {
+    mkdirSync14(dir, { recursive: true });
   }
-  writeFileSync8(path, `${JSON.stringify(state, null, 2)}
+  writeFileSync9(path, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 function clearRunState(projectRoot) {
   const path = getRunStatePath(projectRoot);
-  if (existsSync18(path)) {
-    unlinkSync4(path);
+  if (existsSync20(path)) {
+    unlinkSync5(path);
   }
 }
 function createSprintRunState(sprint, branch, issues) {
@@ -9312,11 +10261,11 @@ var init_shutdown = __esm(() => {
 });
 
 // src/core/worktree.ts
-import { execSync as execSync13 } from "node:child_process";
-import { existsSync as existsSync19, readdirSync as readdirSync7, realpathSync, statSync as statSync4 } from "node:fs";
-import { join as join19 } from "node:path";
+import { execSync as execSync15 } 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";
 function git4(args, cwd) {
-  return execSync13(`git ${args}`, {
+  return execSync15(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -9330,10 +10279,10 @@ function gitSafe3(args, cwd) {
   }
 }
 function getWorktreeDir(projectRoot) {
-  return join19(projectRoot, ".locus", "worktrees");
+  return join21(projectRoot, ".locus", "worktrees");
 }
 function getWorktreePath(projectRoot, issueNumber) {
-  return join19(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
+  return join21(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
 }
 function generateBranchName(issueNumber) {
   const randomSuffix = Math.random().toString(36).slice(2, 8);
@@ -9341,7 +10290,7 @@ function generateBranchName(issueNumber) {
 }
 function getWorktreeBranch(worktreePath) {
   try {
-    return execSync13("git branch --show-current", {
+    return execSync15("git branch --show-current", {
       cwd: worktreePath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9353,7 +10302,7 @@ function getWorktreeBranch(worktreePath) {
 function createWorktree(projectRoot, issueNumber, baseBranch) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (existsSync19(worktreePath)) {
+  if (existsSync21(worktreePath)) {
     log.verbose(`Worktree already exists for issue #${issueNumber}`);
     const existingBranch = getWorktreeBranch(worktreePath) ?? `locus/issue-${issueNumber}`;
     return {
@@ -9381,7 +10330,7 @@ function createWorktree(projectRoot, issueNumber, baseBranch) {
 function removeWorktree(projectRoot, issueNumber) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync19(worktreePath)) {
+  if (!existsSync21(worktreePath)) {
     log.verbose(`Worktree for issue #${issueNumber} does not exist`);
     return;
   }
@@ -9400,7 +10349,7 @@ function removeWorktree(projectRoot, issueNumber) {
 function listWorktrees(projectRoot) {
   const log = getLogger();
   const worktreeDir = getWorktreeDir(projectRoot);
-  if (!existsSync19(worktreeDir)) {
+  if (!existsSync21(worktreeDir)) {
     return [];
   }
   const entries = readdirSync7(worktreeDir).filter((entry) => entry.startsWith("issue-"));
@@ -9420,7 +10369,7 @@ function listWorktrees(projectRoot) {
     if (!match)
       continue;
     const issueNumber = Number.parseInt(match[1], 10);
-    const path = join19(worktreeDir, entry);
+    const path = join21(worktreeDir, entry);
     const branch = getWorktreeBranch(path) ?? `locus/issue-${issueNumber}`;
     let resolvedPath;
     try {
@@ -9468,7 +10417,7 @@ var exports_run = {};
 __export(exports_run, {
   runCommand: () => runCommand
 });
-import { execSync as execSync14 } from "node:child_process";
+import { execSync as execSync16 } from "node:child_process";
 function resolveExecutionContext(config, modelOverride) {
   const model = modelOverride ?? config.ai.model;
   const provider = inferProviderFromModel(model) ?? config.ai.provider;
@@ -9628,7 +10577,7 @@ ${yellow2("⚠")} A sprint run is already in progress.
   }
   if (!flags.dryRun) {
     try {
-      execSync14(`git checkout -B ${branchName}`, {
+      execSync16(`git checkout -B ${branchName}`, {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -9678,7 +10627,7 @@ ${red2("✗")} Auto-rebase failed. Resolve manually.
     let sprintContext;
     if (i > 0 && !flags.dryRun) {
       try {
-        sprintContext = execSync14(`git diff origin/${config.agent.baseBranch}..HEAD`, {
+        sprintContext = execSync16(`git diff origin/${config.agent.baseBranch}..HEAD`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -9743,7 +10692,7 @@ ${bold2("Summary:")}
     const prNumber = await createSprintPR(projectRoot, config, sprintName, branchName, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync14(`git checkout ${config.agent.baseBranch}`, {
+        execSync16(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -9788,7 +10737,7 @@ ${bold2("Running issue")} ${cyan2(`#${issueNumber}`)} ${dim2(`(branch: ${branchN
 `);
   if (!flags.dryRun) {
     try {
-      execSync14(`git checkout -B ${branchName} ${config.agent.baseBranch}`, {
+      execSync16(`git checkout -B ${branchName} ${config.agent.baseBranch}`, {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -9813,7 +10762,7 @@ ${bold2("Running issue")} ${cyan2(`#${issueNumber}`)} ${dim2(`(branch: ${branchN
   if (!flags.dryRun) {
     if (result.success) {
       try {
-        execSync14(`git checkout ${config.agent.baseBranch}`, {
+        execSync16(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -9950,13 +10899,13 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
 `);
   if (state.type === "sprint" && state.branch) {
     try {
-      const currentBranch = execSync14("git rev-parse --abbrev-ref HEAD", {
+      const currentBranch = execSync16("git rev-parse --abbrev-ref HEAD", {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
       if (currentBranch !== state.branch) {
-        execSync14(`git checkout ${state.branch}`, {
+        execSync16(`git checkout ${state.branch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10023,7 +10972,7 @@ ${bold2("Resume complete:")} ${green(`✓ ${finalStats.done}`)} ${finalStats.fai
     const prNumber = await createSprintPR(projectRoot, config, state.sprint, state.branch, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync14(`git checkout ${config.agent.baseBranch}`, {
+        execSync16(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10059,14 +11008,14 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
       process.stderr.write(`  ${dim2(`Committed submodule changes: ${committedSubmodules.join(", ")}`)}
 `);
     }
-    const status = execSync14("git status --porcelain", {
+    const status = execSync16("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!status)
       return;
-    execSync14("git add -A", {
+    execSync16("git add -A", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10074,7 +11023,7 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
     const message = `chore: complete #${issueNumber} - ${issueTitle}
 
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
-    execSync14(`git commit -F -`, {
+    execSync16(`git commit -F -`, {
       input: message,
       cwd: projectRoot,
       encoding: "utf-8",
@@ -10088,7 +11037,7 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
   if (!config.agent.autoPR)
     return;
   try {
-    const diff = execSync14(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
+    const diff = execSync16(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10099,7 +11048,7 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
       return;
     }
     pushSubmoduleBranches(projectRoot);
-    execSync14(`git push -u origin ${branchName}`, {
+    execSync16(`git push -u origin ${branchName}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10257,14 +11206,14 @@ __export(exports_plan, {
   parsePlanArgs: () => parsePlanArgs
 });
 import {
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync13,
+  existsSync as existsSync22,
+  mkdirSync as mkdirSync15,
   readdirSync as readdirSync8,
   readFileSync as readFileSync13,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { join as join20 } from "node:path";
-function printHelp() {
+import { join as join22 } from "node:path";
+function printHelp2() {
   process.stderr.write(`
 ${bold2("locus plan")} — AI-powered sprint planning
 
@@ -10294,12 +11243,12 @@ function normalizeSprintName(name) {
   return name.trim().toLowerCase();
 }
 function getPlansDir(projectRoot) {
-  return join20(projectRoot, ".locus", "plans");
+  return join22(projectRoot, ".locus", "plans");
 }
 function ensurePlansDir(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync20(dir)) {
-    mkdirSync13(dir, { recursive: true });
+  if (!existsSync22(dir)) {
+    mkdirSync15(dir, { recursive: true });
   }
   return dir;
 }
@@ -10308,14 +11257,14 @@ function generateId() {
 }
 function loadPlanFile(projectRoot, id) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync20(dir))
+  if (!existsSync22(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(join20(dir, match), "utf-8");
+    const content = readFileSync13(join22(dir, match), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -10323,7 +11272,7 @@ function loadPlanFile(projectRoot, id) {
 }
 async function planCommand(projectRoot, args, flags = {}) {
   if (args[0] === "help" || args.length === 0) {
-    printHelp();
+    printHelp2();
     return;
   }
   if (args[0] === "list") {
@@ -10361,7 +11310,7 @@ async function planCommand(projectRoot, args, flags = {}) {
 }
 function handleListPlans(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync20(dir)) {
+  if (!existsSync22(dir)) {
     process.stderr.write(`${dim2("No saved plans yet.")}
 `);
     return;
@@ -10379,7 +11328,7 @@ ${bold2("Saved Plans:")}
   for (const file of files) {
     const id = file.replace(".json", "");
     try {
-      const content = readFileSync13(join20(dir, file), "utf-8");
+      const content = readFileSync13(join22(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;
@@ -10490,7 +11439,7 @@ ${bold2("Approving plan:")}
 async function handleAIPlan(projectRoot, config, directive, sprintName, flags) {
   const id = generateId();
   const plansDir = ensurePlansDir(projectRoot);
-  const planPath = join20(plansDir, `${id}.json`);
+  const planPath = join22(plansDir, `${id}.json`);
   const planPathRelative = `.locus/plans/${id}.json`;
   const displayDirective = directive;
   process.stderr.write(`
@@ -10532,7 +11481,7 @@ ${red2("✗")} Planning failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync20(planPath)) {
+  if (!existsSync22(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
 `);
@@ -10564,7 +11513,7 @@ ${yellow2("⚠")} Plan file has no issues.
     plan.sprint = sprintName;
   if (!plan.createdAt)
     plan.createdAt = new Date().toISOString();
-  writeFileSync9(planPath, JSON.stringify(plan, null, 2), "utf-8");
+  writeFileSync10(planPath, JSON.stringify(plan, null, 2), "utf-8");
   process.stderr.write(`
 ${bold2("Plan saved:")} ${cyan2(id)}
 
@@ -10713,15 +11662,15 @@ ${directive}${sprintName ? `
 
 **Sprint:** ${sprintName}` : ""}
 </directive>`);
-  const locusPath = join20(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync20(locusPath)) {
+  const locusPath = join22(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync22(locusPath)) {
     const content = readFileSync13(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join20(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync20(learningsPath)) {
+  const learningsPath = join22(projectRoot, ".locus", "LEARNINGS.md");
+  if (existsSync22(learningsPath)) {
     const content = readFileSync13(learningsPath, "utf-8");
     parts.push(`<past-learnings>
 ${content.slice(0, 2000)}
@@ -10901,10 +11850,10 @@ var exports_review = {};
 __export(exports_review, {
   reviewCommand: () => reviewCommand
 });
-import { execFileSync as execFileSync2, execSync as execSync15 } from "node:child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync14 } from "node:fs";
-import { join as join21 } from "node:path";
-function printHelp2() {
+import { execFileSync as execFileSync2, execSync as execSync17 } from "node:child_process";
+import { existsSync as existsSync23, readFileSync as readFileSync14 } from "node:fs";
+import { join as join23 } from "node:path";
+function printHelp3() {
   process.stderr.write(`
 ${bold2("locus review")} — AI-powered code review
 
@@ -10927,7 +11876,7 @@ ${bold2("Examples:")}
 }
 async function reviewCommand(projectRoot, args, flags = {}) {
   if (args[0] === "help") {
-    printHelp2();
+    printHelp3();
     return;
   }
   const config = loadConfig(projectRoot);
@@ -10987,7 +11936,7 @@ ${bold2("Review complete:")} ${green(`✓ ${reviewed}`)}${failed > 0 ? ` ${red2(
 async function reviewSinglePR(projectRoot, config, prNumber, focus, flags) {
   let prInfo;
   try {
-    const result = execSync15(`gh pr view ${prNumber} --json number,title,body,state,headRefName,baseRefName,labels,url,createdAt`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const result = execSync17(`gh pr view ${prNumber} --json number,title,body,state,headRefName,baseRefName,labels,url,createdAt`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const raw = JSON.parse(result);
     prInfo = {
       number: raw.number,
@@ -11071,8 +12020,8 @@ function buildReviewPrompt(projectRoot, config, pr, diff, focus) {
   parts.push(`<role>
 You are an expert code reviewer for the ${config.github.owner}/${config.github.repo} repository.
 </role>`);
-  const locusPath = join21(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync21(locusPath)) {
+  const locusPath = join23(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync23(locusPath)) {
     const content = readFileSync14(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 2000)}
@@ -11134,8 +12083,8 @@ var exports_iterate = {};
 __export(exports_iterate, {
   iterateCommand: () => iterateCommand
 });
-import { execSync as execSync16 } from "node:child_process";
-function printHelp3() {
+import { execSync as execSync18 } from "node:child_process";
+function printHelp4() {
   process.stderr.write(`
 ${bold2("locus iterate")} — Re-execute tasks with PR feedback
 
@@ -11160,7 +12109,7 @@ ${bold2("Examples:")}
 }
 async function iterateCommand(projectRoot, args, flags = {}) {
   if (args[0] === "help") {
-    printHelp3();
+    printHelp4();
     return;
   }
   const config = loadConfig(projectRoot);
@@ -11352,12 +12301,12 @@ ${bold2("Summary:")} ${green(`✓ ${succeeded}`)}${failed > 0 ? ` ${red2(`✗ ${
 }
 function findPRForIssue(projectRoot, issueNumber) {
   try {
-    const result = execSync16(`gh pr list --search "Closes #${issueNumber}" --json number --state open`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const result = execSync18(`gh pr list --search "Closes #${issueNumber}" --json number --state open`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const parsed = JSON.parse(result);
     if (parsed.length > 0) {
       return parsed[0].number;
     }
-    const branchResult = execSync16(`gh pr list --head "locus/issue-${issueNumber}" --json number --state open`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const branchResult = execSync18(`gh pr list --head "locus/issue-${issueNumber}" --json number --state open`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const branchParsed = JSON.parse(branchResult);
     if (branchParsed.length > 0) {
       return branchParsed[0].number;
@@ -11393,15 +12342,15 @@ __export(exports_discuss, {
   discussCommand: () => discussCommand
 });
 import {
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync14,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync16,
   readdirSync as readdirSync9,
   readFileSync as readFileSync15,
-  unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync10
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { join as join22 } from "node:path";
-function printHelp4() {
+import { join as join24 } from "node:path";
+function printHelp5() {
   process.stderr.write(`
 ${bold2("locus discuss")} — AI-powered architectural discussions
 
@@ -11422,12 +12371,12 @@ ${bold2("Examples:")}
 `);
 }
 function getDiscussionsDir(projectRoot) {
-  return join22(projectRoot, ".locus", "discussions");
+  return join24(projectRoot, ".locus", "discussions");
 }
 function ensureDiscussionsDir(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync22(dir)) {
-    mkdirSync14(dir, { recursive: true });
+  if (!existsSync24(dir)) {
+    mkdirSync16(dir, { recursive: true });
   }
   return dir;
 }
@@ -11436,7 +12385,7 @@ function generateId2() {
 }
 async function discussCommand(projectRoot, args, flags = {}) {
   if (args[0] === "help") {
-    printHelp4();
+    printHelp5();
     return;
   }
   const subcommand = args[0];
@@ -11453,7 +12402,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
     return deleteDiscussion(projectRoot, args[1]);
   }
   if (args.length === 0) {
-    printHelp4();
+    printHelp5();
     return;
   }
   const topic = args.join(" ").trim();
@@ -11461,7 +12410,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
 }
 function listDiscussions(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync22(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${dim2("No discussions yet.")}
 `);
     return;
@@ -11478,7 +12427,7 @@ ${bold2("Discussions:")}
 `);
   for (const file of files) {
     const id = file.replace(".md", "");
-    const content = readFileSync15(join22(dir, file), "utf-8");
+    const content = readFileSync15(join24(dir, file), "utf-8");
     const titleMatch = content.match(/^#\s+(.+)/m);
     const title = titleMatch ? titleMatch[1] : id;
     const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/);
@@ -11496,7 +12445,7 @@ function showDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync22(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -11508,7 +12457,7 @@ function showDiscussion(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join22(dir, match), "utf-8");
+  const content = readFileSync15(join24(dir, match), "utf-8");
   process.stdout.write(`${content}
 `);
 }
@@ -11519,7 +12468,7 @@ function deleteDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync22(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -11531,7 +12480,7 @@ function deleteDiscussion(projectRoot, id) {
 `);
     return;
   }
-  unlinkSync5(join22(dir, match));
+  unlinkSync6(join24(dir, match));
   process.stderr.write(`${green("✓")} Deleted discussion: ${match.replace(".md", "")}
 `);
 }
@@ -11544,7 +12493,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync22(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -11556,7 +12505,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join22(dir, match), "utf-8");
+  const content = readFileSync15(join24(dir, match), "utf-8");
   const titleMatch = content.match(/^#\s+(.+)/m);
   const discussionTitle = titleMatch ? titleMatch[1].trim() : id;
   await planCommand(projectRoot, [
@@ -11681,7 +12630,7 @@ ${turn.content}`;
     ...conversation.length > 1 ? [`---`, ``, `## Discussion Transcript`, ``, transcript, ``] : []
   ].join(`
 `);
-  writeFileSync10(join22(dir, `${id}.md`), markdown, "utf-8");
+  writeFileSync11(join24(dir, `${id}.md`), markdown, "utf-8");
   process.stderr.write(`
 ${green("✓")} Discussion saved: ${cyan2(id)} ${dim2(`(${timer.formatted()})`)}
 `);
@@ -11696,15 +12645,15 @@ function buildDiscussionPrompt(projectRoot, config, topic, conversation, forceFi
   parts.push(`<role>
 You are a senior software architect and consultant for the ${config.github.owner}/${config.github.repo} project.
 </role>`);
-  const locusPath = join22(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync22(locusPath)) {
+  const locusPath = join24(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync24(locusPath)) {
     const content = readFileSync15(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join22(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync22(learningsPath)) {
+  const learningsPath = join24(projectRoot, ".locus", "LEARNINGS.md");
+  if (existsSync24(learningsPath)) {
     const content = readFileSync15(learningsPath, "utf-8");
     parts.push(`<past-learnings>
 ${content.slice(0, 2000)}
@@ -11776,9 +12725,9 @@ __export(exports_artifacts, {
   formatDate: () => formatDate2,
   artifactsCommand: () => artifactsCommand
 });
-import { existsSync as existsSync23, readdirSync as readdirSync10, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
-import { join as join23 } from "node:path";
-function printHelp5() {
+import { existsSync as existsSync25, readdirSync as readdirSync10, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
+import { join as join25 } from "node:path";
+function printHelp6() {
   process.stderr.write(`
 ${bold2("locus artifacts")} — View and manage AI-generated artifacts
 
@@ -11797,14 +12746,14 @@ ${dim2("Artifact names support partial matching.")}
 `);
 }
 function getArtifactsDir(projectRoot) {
-  return join23(projectRoot, ".locus", "artifacts");
+  return join25(projectRoot, ".locus", "artifacts");
 }
 function listArtifacts(projectRoot) {
   const dir = getArtifactsDir(projectRoot);
-  if (!existsSync23(dir))
+  if (!existsSync25(dir))
     return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".md")).map((fileName) => {
-    const filePath = join23(dir, fileName);
+    const filePath = join25(dir, fileName);
     const stat = statSync5(filePath);
     return {
       name: fileName.replace(/\.md$/, ""),
@@ -11817,8 +12766,8 @@ function listArtifacts(projectRoot) {
 function readArtifact(projectRoot, name) {
   const dir = getArtifactsDir(projectRoot);
   const fileName = name.endsWith(".md") ? name : `${name}.md`;
-  const filePath = join23(dir, fileName);
-  if (!existsSync23(filePath))
+  const filePath = join25(dir, fileName);
+  if (!existsSync25(filePath))
     return null;
   const stat = statSync5(filePath);
   return {
@@ -11850,7 +12799,7 @@ function formatDate2(date) {
 }
 async function artifactsCommand(projectRoot, args) {
   if (args[0] === "help") {
-    printHelp5();
+    printHelp6();
     return;
   }
   const subcommand = args[0];
@@ -11987,10 +12936,10 @@ __export(exports_sandbox2, {
   parseSandboxLogsArgs: () => parseSandboxLogsArgs,
   parseSandboxInstallArgs: () => parseSandboxInstallArgs
 });
-import { execSync as execSync17, spawn as spawn6 } from "node:child_process";
+import { execSync as execSync19, spawn as spawn7 } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync as existsSync24, readFileSync as readFileSync17 } from "node:fs";
-import { basename as basename4, join as join24 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync17 } from "node:fs";
+import { basename as basename4, join as join26 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
 function printSandboxHelp() {
   process.stderr.write(`
@@ -12155,7 +13104,7 @@ async function handleAgentLogin(projectRoot, agent) {
   process.stderr.write(`${dim2("Login and then exit when ready.")}
 
 `);
-  const child = spawn6("docker", ["sandbox", "exec", "-it", "-w", projectRoot, sandboxName, agent], {
+  const child = spawn7("docker", ["sandbox", "exec", "-it", "-w", projectRoot, sandboxName, agent], {
     stdio: "inherit"
   });
   await new Promise((resolve2) => {
@@ -12199,7 +13148,7 @@ function handleRemove(projectRoot) {
     process.stderr.write(`Removing sandbox ${bold2(sandboxName)}...
 `);
     try {
-      execSync17(`docker sandbox rm ${sandboxName}`, {
+      execSync19(`docker sandbox rm ${sandboxName}`, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 15000
@@ -12446,9 +13395,9 @@ async function handleLogs(projectRoot, args) {
   dockerArgs.push(sandboxName);
   await runInteractiveCommand("docker", dockerArgs);
 }
-function detectPackageManager(projectRoot) {
+function detectPackageManager2(projectRoot) {
   try {
-    const raw = readFileSync17(join24(projectRoot, "package.json"), "utf-8");
+    const raw = readFileSync17(join26(projectRoot, "package.json"), "utf-8");
     const pkgJson = JSON.parse(raw);
     if (typeof pkgJson.packageManager === "string") {
       const name = pkgJson.packageManager.split("@")[0];
@@ -12457,13 +13406,13 @@ function detectPackageManager(projectRoot) {
       }
     }
   } catch {}
-  if (existsSync24(join24(projectRoot, "bun.lock")) || existsSync24(join24(projectRoot, "bun.lockb"))) {
+  if (existsSync26(join26(projectRoot, "bun.lock")) || existsSync26(join26(projectRoot, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync24(join24(projectRoot, "yarn.lock"))) {
+  if (existsSync26(join26(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync24(join24(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync26(join26(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
   return "npm";
@@ -12484,7 +13433,7 @@ async function runSandboxSetup(sandboxName, projectRoot) {
   const ecosystem = detectProjectEcosystem(projectRoot);
   const isJS = isJavaScriptEcosystem(ecosystem);
   if (isJS) {
-    const pm = detectPackageManager(projectRoot);
+    const pm = detectPackageManager2(projectRoot);
     if (pm !== "npm") {
       await ensurePackageManagerInSandbox(sandboxName, pm);
     }
@@ -12512,8 +13461,8 @@ Installing dependencies (${bold2(installCmd.join(" "))}) in sandbox ${dim2(sandb
 ${dim2(`Detected ${ecosystem} project — skipping JS package install.`)}
 `);
   }
-  const setupScript = join24(projectRoot, ".locus", "sandbox-setup.sh");
-  if (existsSync24(setupScript)) {
+  const setupScript = join26(projectRoot, ".locus", "sandbox-setup.sh");
+  if (existsSync26(setupScript)) {
     process.stderr.write(`Running ${bold2(".locus/sandbox-setup.sh")} in sandbox ${dim2(sandboxName)}...
 `);
     const hookOk = await runInteractiveCommand("docker", [
@@ -12594,14 +13543,14 @@ function getActiveProviderSandbox(projectRoot, provider) {
 }
 function runInteractiveCommand(command, args) {
   return new Promise((resolve2) => {
-    const child = spawn6(command, args, { stdio: "inherit" });
+    const child = spawn7(command, args, { stdio: "inherit" });
     child.on("close", (code) => resolve2(code === 0));
     child.on("error", () => resolve2(false));
   });
 }
 async function createProviderSandbox(provider, sandboxName, projectRoot) {
   try {
-    execSync17(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
+    execSync19(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 120000
     });
@@ -12622,7 +13571,7 @@ async function createProviderSandbox(provider, sandboxName, projectRoot) {
 }
 async function ensurePackageManagerInSandbox(sandboxName, pm) {
   try {
-    execSync17(`docker sandbox exec ${sandboxName} which ${pm}`, {
+    execSync19(`docker sandbox exec ${sandboxName} which ${pm}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -12631,7 +13580,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
     process.stderr.write(`Installing ${bold2(pm)} in sandbox...
 `);
     try {
-      execSync17(`docker sandbox exec ${sandboxName} npm install -g ${npmPkg}`, {
+      execSync19(`docker sandbox exec ${sandboxName} npm install -g ${npmPkg}`, {
         stdio: "inherit",
         timeout: 120000
       });
@@ -12643,7 +13592,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
 }
 async function ensureCodexInSandbox(sandboxName) {
   try {
-    execSync17(`docker sandbox exec ${sandboxName} which codex`, {
+    execSync19(`docker sandbox exec ${sandboxName} which codex`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -12651,7 +13600,7 @@ async function ensureCodexInSandbox(sandboxName) {
     process.stderr.write(`Installing codex in sandbox...
 `);
     try {
-      execSync17(`docker sandbox exec ${sandboxName} npm install -g @openai/codex`, { stdio: "inherit", timeout: 120000 });
+      execSync19(`docker sandbox exec ${sandboxName} npm install -g @openai/codex`, { stdio: "inherit", timeout: 120000 });
     } catch {
       process.stderr.write(`${red2("✗")} Failed to install codex in sandbox.
 `);
@@ -12660,7 +13609,7 @@ async function ensureCodexInSandbox(sandboxName) {
 }
 function isSandboxAlive(name) {
   try {
-    const output = execSync17("docker sandbox ls", {
+    const output = execSync19("docker sandbox ls", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -12686,13 +13635,13 @@ init_context();
 init_logger();
 init_rate_limiter();
 init_terminal();
-import { existsSync as existsSync25, readFileSync as readFileSync18 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync18 } from "node:fs";
+import { join as join27 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getCliVersion() {
   const fallbackVersion = "0.0.0";
-  const packageJsonPath = join25(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
-  if (!existsSync25(packageJsonPath)) {
+  const packageJsonPath = join27(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
+  if (!existsSync27(packageJsonPath)) {
     return fallbackVersion;
   }
   try {
@@ -12842,7 +13791,7 @@ function printLogo() {
 `);
   }
 }
-function printHelp6() {
+function printHelp7() {
   printLogo();
   process.stderr.write(`
 
@@ -12863,6 +13812,7 @@ ${bold2("Commands:")}
   ${cyan2("status")}            Dashboard view of current state
   ${cyan2("config")}            View and manage settings
   ${cyan2("logs")}              View, tail, and manage execution logs
+  ${cyan2("create")} ${dim2("<name>")}       Scaffold a new community package
   ${cyan2("install")}           Install a community package
   ${cyan2("uninstall")}         Remove an installed package
   ${cyan2("packages")}          Manage installed packages (list, outdated)
@@ -12946,7 +13896,7 @@ async function main() {
     process.exit(0);
   }
   if (parsed.flags.help && !parsed.command) {
-    printHelp6();
+    printHelp7();
     process.exit(0);
   }
   const command = resolveAlias(parsed.command);
@@ -12957,7 +13907,7 @@ async function main() {
     try {
       const root = getGitRoot(cwd);
       if (isInitialized(root)) {
-        logDir = join25(root, ".locus", "logs");
+        logDir = join27(root, ".locus", "logs");
         getRateLimiter(root);
       }
     } catch {}
@@ -12978,7 +13928,7 @@ async function main() {
     printVersionNotice = startVersionCheck2(VERSION);
   }
   if (!command) {
-    printHelp6();
+    printHelp7();
     process.exit(0);
   }
   if (command === "init") {
@@ -12987,6 +13937,13 @@ async function main() {
     logger.destroy();
     return;
   }
+  if (command === "create") {
+    const { createCommand: createCommand2 } = await Promise.resolve().then(() => (init_create(), exports_create));
+    const createArgs = parsed.flags.help ? ["help"] : parsed.args;
+    await createCommand2(createArgs);
+    logger.destroy();
+    return;
+  }
   if (command === "install") {
     if (parsed.flags.list) {
       const { packagesCommand: packagesCommand2 } = await Promise.resolve().then(() => (init_packages(), exports_packages));