@locusai/cli 0.22.0 → 0.22.2

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,
@@ -896,9 +896,10 @@ __export(exports_sandbox, {
   getModelSandboxName: () => getModelSandboxName,
   displaySandboxWarning: () => displaySandboxWarning,
   detectSandboxSupport: () => detectSandboxSupport,
+  detectContainerWorkdir: () => detectContainerWorkdir,
   checkProviderSandboxMismatch: () => checkProviderSandboxMismatch
 });
-import { execFile } from "node:child_process";
+import { execFile, execSync as execSync2 } from "node:child_process";
 import { createInterface } from "node:readline";
 function getProviderSandboxName(config, provider) {
   return config.providers[provider];
@@ -1033,6 +1034,34 @@ ${yellow2("⚠")}  Docker sandbox not available. Install Docker Desktop 4.58+ fo
   }
   return true;
 }
+function detectContainerWorkdir(sandboxName, hostProjectRoot) {
+  const log = getLogger();
+  try {
+    execSync2(`docker sandbox exec ${sandboxName} test -d ${JSON.stringify(hostProjectRoot)}`, { stdio: ["pipe", "pipe", "pipe"], timeout: 5000 });
+    log.debug("Container workdir matches host path", { hostProjectRoot });
+    return null;
+  } catch {}
+  try {
+    const result = execSync2(`docker sandbox exec ${sandboxName} find / -maxdepth 5 -path '*/.locus/config.json' -type f 2>/dev/null`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 15000 }).trim();
+    if (result) {
+      const configPath = result.split(`
+`)[0].trim();
+      const workdir = configPath.replace(/\/.locus\/config\.json$/, "");
+      if (workdir) {
+        log.debug("Detected container workdir", {
+          hostProjectRoot,
+          containerWorkdir: workdir
+        });
+        return workdir;
+      }
+    }
+  } catch (err) {
+    log.debug("Container workdir probe failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return null;
+}
 function waitForEnter() {
   return new Promise((resolve) => {
     const rl = createInterface({
@@ -1062,7 +1091,7 @@ __export(exports_upgrade, {
   fetchLatestVersion: () => fetchLatestVersion,
   compareSemver: () => compareSemver
 });
-import { execSync as execSync2 } from "node:child_process";
+import { execSync as execSync3 } from "node:child_process";
 function compareSemver(a, b) {
   const partsA = a.replace(/^v/, "").split(".").map(Number);
   const partsB = b.replace(/^v/, "").split(".").map(Number);
@@ -1078,7 +1107,7 @@ function compareSemver(a, b) {
 }
 function fetchLatestVersion() {
   try {
-    const result = execSync2(`npm view ${PACKAGE_NAME} version`, {
+    const result = execSync3(`npm view ${PACKAGE_NAME} version`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 15000
@@ -1090,14 +1119,14 @@ function fetchLatestVersion() {
 }
 function installVersion(version) {
   try {
-    execSync2("npm cache clean --force", {
+    execSync3("npm cache clean --force", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 30000
     });
   } catch {}
   try {
-    execSync2(`npm install -g ${PACKAGE_NAME}@${version}`, {
+    execSync3(`npm install -g ${PACKAGE_NAME}@${version}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 120000
@@ -1109,7 +1138,7 @@ function installVersion(version) {
 }
 function verifyInstalled(expectedVersion) {
   try {
-    const installed = execSync2(`npm list -g ${PACKAGE_NAME} --depth=0 --json`, {
+    const installed = execSync3(`npm list -g ${PACKAGE_NAME} --depth=0 --json`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 1e4
@@ -1473,7 +1502,7 @@ var init_ecosystem = __esm(() => {
 // src/core/github.ts
 import {
   execFileSync,
-  execSync as execSync3
+  execSync as execSync4
 } from "node:child_process";
 function gh(args, options = {}) {
   const log = getLogger();
@@ -1482,7 +1511,7 @@ function gh(args, options = {}) {
   log.debug(`gh ${args}`, { cwd });
   const startTime = Date.now();
   try {
-    const result = execSync3(`gh ${args}`, {
+    const result = execSync4(`gh ${args}`, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
@@ -2226,35 +2255,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 execSync5 } 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 {
+    execSync5(`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, 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, 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 +2649,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 +2663,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 +2697,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 +2776,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 +2909,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 +2987,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 +3266,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 +3330,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 +3350,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 +3410,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 +3719,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 execSync6 } 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 +3733,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 +3758,13 @@ function readMacOSClipboardImage() {
       `return "ok"`
     ].join(`
 `);
-    const result = execSync4("osascript", {
+    const result = execSync6("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 +3772,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 = execSync6("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`);
+    execSync6(`xclip -selection clipboard -t image/png -o > "${destPath}" 2>/dev/null`, { timeout: 5000 });
+    if (existsSync12(destPath)) {
       return destPath;
     }
   } catch {}
@@ -3409,13 +3787,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 +3887,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 +3907,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 +3920,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 +3974,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 +3997,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;
 });
 
@@ -4421,7 +4799,7 @@ __export(exports_claude, {
   buildClaudeArgs: () => buildClaudeArgs,
   ClaudeRunner: () => ClaudeRunner
 });
-import { execSync as execSync5, spawn as spawn2 } from "node:child_process";
+import { execSync as execSync7, spawn as spawn2 } from "node:child_process";
 function buildClaudeArgs(options) {
   const args = ["--dangerously-skip-permissions", "--no-session-persistence"];
   if (options.model) {
@@ -4439,7 +4817,7 @@ class ClaudeRunner {
   aborted = false;
   async isAvailable() {
     try {
-      execSync5("claude --version", {
+      execSync7("claude --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -4450,7 +4828,7 @@ class ClaudeRunner {
   }
   async getVersion() {
     try {
-      const output = execSync5("claude --version", {
+      const output = execSync7("claude --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -4617,8 +4995,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,
@@ -4626,10 +5004,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 = [];
@@ -4699,7 +5077,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);
@@ -4733,7 +5111,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;
@@ -4742,7 +5120,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)
@@ -4752,9 +5130,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) {
@@ -4776,7 +5154,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)", {
@@ -4792,13 +5170,13 @@ function backupIgnoredFiles(projectRoot) {
     }
   };
 }
-async function enforceSandboxIgnore(sandboxName, projectRoot) {
+async function enforceSandboxIgnore(sandboxName, projectRoot, containerWorkdir) {
   const log = getLogger();
-  const ignorePath = join12(projectRoot, ".sandboxignore");
+  const ignorePath = join13(projectRoot, ".sandboxignore");
   const rules = parseIgnoreFile(ignorePath);
   if (rules.length === 0)
     return;
-  const script = buildCleanupScript(rules, projectRoot);
+  const script = buildCleanupScript(rules, containerWorkdir ?? projectRoot);
   if (!script)
     return;
   log.debug("Enforcing .sandboxignore", {
@@ -4838,11 +5216,13 @@ import { spawn as spawn3 } from "node:child_process";
 
 class SandboxedClaudeRunner {
   sandboxName;
+  containerWorkdir;
   name = "claude-sandboxed";
   process = null;
   aborted = false;
-  constructor(sandboxName) {
+  constructor(sandboxName, containerWorkdir) {
     this.sandboxName = sandboxName;
+    this.containerWorkdir = containerWorkdir;
   }
   async isAvailable() {
     const { ClaudeRunner: ClaudeRunner2 } = await Promise.resolve().then(() => (init_claude(), exports_claude));
@@ -4868,13 +5248,14 @@ class SandboxedClaudeRunner {
     const claudeArgs = ["-p", options.prompt, ...buildClaudeArgs(options)];
     options.onStatusChange?.("Syncing sandbox...");
     const backup = backupIgnoredFiles(options.cwd);
-    await enforceSandboxIgnore(this.sandboxName, options.cwd);
+    await enforceSandboxIgnore(this.sandboxName, options.cwd, this.containerWorkdir);
     options.onStatusChange?.("Thinking...");
+    const workdir = this.containerWorkdir ?? options.cwd;
     const dockerArgs = [
       "sandbox",
       "exec",
       "-w",
-      options.cwd,
+      workdir,
       this.sandboxName,
       "claude",
       ...claudeArgs
@@ -5039,7 +5420,7 @@ var init_claude_sandbox = __esm(() => {
 });
 
 // src/ai/codex.ts
-import { execSync as execSync6, spawn as spawn4 } from "node:child_process";
+import { execSync as execSync8, spawn as spawn4 } from "node:child_process";
 function buildCodexArgs(model) {
   const args = ["exec", "--full-auto", "--skip-git-repo-check", "--json"];
   if (model) {
@@ -5055,7 +5436,7 @@ class CodexRunner {
   aborted = false;
   async isAvailable() {
     try {
-      execSync6("codex --version", {
+      execSync8("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -5066,7 +5447,7 @@ class CodexRunner {
   }
   async getVersion() {
     try {
-      const output = execSync6("codex --version", {
+      const output = execSync8("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -5218,12 +5599,14 @@ import { spawn as spawn5 } from "node:child_process";
 
 class SandboxedCodexRunner {
   sandboxName;
+  containerWorkdir;
   name = "codex-sandboxed";
   process = null;
   aborted = false;
   codexInstalled = false;
-  constructor(sandboxName) {
+  constructor(sandboxName, containerWorkdir) {
     this.sandboxName = sandboxName;
+    this.containerWorkdir = containerWorkdir;
   }
   async isAvailable() {
     const delegate = new CodexRunner;
@@ -5247,19 +5630,20 @@ class SandboxedCodexRunner {
     const codexArgs = buildCodexArgs(options.model);
     options.onStatusChange?.("Syncing sandbox...");
     const backup = backupIgnoredFiles(options.cwd);
-    await enforceSandboxIgnore(this.sandboxName, options.cwd);
+    await enforceSandboxIgnore(this.sandboxName, options.cwd, this.containerWorkdir);
     if (!this.codexInstalled) {
       options.onStatusChange?.("Checking codex...");
       await this.ensureCodexInstalled(this.sandboxName);
       this.codexInstalled = true;
     }
     options.onStatusChange?.("Thinking...");
+    const workdir = this.containerWorkdir ?? options.cwd;
     const dockerArgs = [
       "sandbox",
       "exec",
       "-i",
       "-w",
-      options.cwd,
+      workdir,
       this.sandboxName,
       "codex",
       ...codexArgs
@@ -5440,12 +5824,12 @@ async function createRunnerAsync(provider, sandboxed) {
       throw new Error(`Unknown AI provider: ${provider}`);
   }
 }
-function createUserManagedSandboxRunner(provider, sandboxName) {
+function createUserManagedSandboxRunner(provider, sandboxName, containerWorkdir) {
   switch (provider) {
     case "claude":
-      return new SandboxedClaudeRunner(sandboxName);
+      return new SandboxedClaudeRunner(sandboxName, containerWorkdir);
     case "codex":
-      return new SandboxedCodexRunner(sandboxName);
+      return new SandboxedCodexRunner(sandboxName, containerWorkdir);
     default:
       throw new Error(`Unknown AI provider: ${provider}`);
   }
@@ -5556,7 +5940,7 @@ ${red2("✗")} ${dim2("Force exit.")}\r
           exitCode: 1
         };
       }
-      runner = createUserManagedSandboxRunner(resolvedProvider, options.sandboxName);
+      runner = createUserManagedSandboxRunner(resolvedProvider, options.sandboxName, options.containerWorkdir);
     } else {
       runner = await createRunnerAsync(resolvedProvider, false);
     }
@@ -5891,7 +6275,8 @@ async function issueCreate(projectRoot, parsed) {
     silent: true,
     activity: "generating issue",
     sandboxed: config.sandbox.enabled,
-    sandboxName: getModelSandboxName(config.sandbox, config.ai.model, config.ai.provider)
+    sandboxName: getModelSandboxName(config.sandbox, config.ai.model, config.ai.provider),
+    containerWorkdir: config.sandbox.containerWorkdir
   });
   if (!aiResult.success && !aiResult.interrupted) {
     process.stderr.write(`${red2("✗")} Failed to generate issue: ${aiResult.error}
@@ -7094,9 +7479,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 execSync9 } from "node:child_process";
+import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
+import { join as join14 } from "node:path";
 function buildExecutionPrompt(ctx) {
   const sections = [];
   sections.push(buildSystemContext(ctx.projectRoot));
@@ -7126,13 +7511,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}
@@ -7159,24 +7544,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}">
@@ -7243,7 +7628,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 = execSync9("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>
 \`\`\`
@@ -7253,7 +7638,7 @@ ${tree}
     }
   } catch {}
   try {
-    const gitLog = execSync7("git log --oneline -10", {
+    const gitLog = execSync9("git log --oneline -10", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7267,7 +7652,7 @@ ${gitLog}
     }
   } catch {}
   try {
-    const branch = execSync7("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync9("git rev-parse --abbrev-ref HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7329,7 +7714,7 @@ function buildFeedbackInstructions() {
 }
 function readFileSafe(path) {
   try {
-    if (!existsSync14(path))
+    if (!existsSync15(path))
       return null;
     return readFileSync9(path, "utf-8");
   } catch {
@@ -7523,7 +7908,7 @@ var init_diff_renderer = __esm(() => {
 });
 
 // src/repl/commands.ts
-import { execSync as execSync8 } from "node:child_process";
+import { execSync as execSync10 } from "node:child_process";
 function getSlashCommands() {
   return [
     {
@@ -7721,7 +8106,7 @@ function cmdModel(args, ctx) {
 }
 function cmdDiff(_args, ctx) {
   try {
-    const diff = execSync8("git diff", {
+    const diff = execSync10("git diff", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7757,7 +8142,7 @@ function cmdDiff(_args, ctx) {
 }
 function cmdUndo(_args, ctx) {
   try {
-    const status = execSync8("git status --porcelain", {
+    const status = execSync10("git status --porcelain", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7767,7 +8152,7 @@ function cmdUndo(_args, ctx) {
 `);
       return;
     }
-    execSync8("git checkout .", {
+    execSync10("git checkout .", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7809,7 +8194,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;
@@ -7864,7 +8249,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) => {
@@ -7900,14 +8285,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) {
@@ -7946,7 +8331,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(`
@@ -7956,12 +8341,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) {
@@ -7987,21 +8372,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) {
@@ -8026,12 +8411,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 {
@@ -8054,7 +8439,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) {
@@ -8081,7 +8466,7 @@ class SessionManager {
   }
   delete(sessionId) {
     const path = this.getSessionPath(sessionId);
-    if (existsSync16(path)) {
+    if (existsSync17(path)) {
       unlinkSync3(path);
       return true;
     }
@@ -8111,7 +8496,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);
@@ -8126,7 +8511,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 [];
     }
@@ -8135,7 +8520,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;
@@ -8145,17 +8530,17 @@ var init_session_manager = __esm(() => {
 });
 
 // src/repl/voice.ts
-import { execSync as execSync9, spawn as spawn6 } from "node:child_process";
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, unlinkSync as unlinkSync4 } from "node:fs";
+import { execSync as execSync11, spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, unlinkSync as unlinkSync4 } from "node:fs";
 import { cpus, homedir as homedir4, platform, tmpdir as tmpdir4 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function getWhisperModelPath() {
-  return join17(WHISPER_MODELS_DIR, `ggml-${WHISPER_MODEL}.bin`);
+  return join18(WHISPER_MODELS_DIR, `ggml-${WHISPER_MODEL}.bin`);
 }
 function commandExists(cmd) {
   try {
     const which = platform() === "win32" ? "where" : "which";
-    execSync9(`${which} ${cmd}`, { stdio: "pipe" });
+    execSync11(`${which} ${cmd}`, { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -8168,16 +8553,16 @@ function findWhisperBinary() {
       return name;
   }
   for (const name of candidates) {
-    const fullPath = join17(LOCUS_BIN_DIR, name);
-    if (existsSync17(fullPath))
+    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 = join17(dir, name);
-        if (existsSync17(fullPath))
+        const fullPath = join18(dir, name);
+        if (existsSync18(fullPath))
           return fullPath;
       }
     }
@@ -8192,11 +8577,11 @@ function findSoxRecBinary() {
   if (platform() === "darwin") {
     const brewDirs = ["/opt/homebrew/bin", "/usr/local/bin"];
     for (const dir of brewDirs) {
-      const recPath = join17(dir, "rec");
-      if (existsSync17(recPath))
+      const recPath = join18(dir, "rec");
+      if (existsSync18(recPath))
         return recPath;
-      const soxPath = join17(dir, "sox");
-      if (existsSync17(soxPath))
+      const soxPath = join18(dir, "sox");
+      if (existsSync18(soxPath))
         return soxPath;
     }
   }
@@ -8205,7 +8590,7 @@ function findSoxRecBinary() {
 function checkDependencies() {
   const soxBinary = findSoxRecBinary();
   const whisperBinary = findWhisperBinary();
-  const modelDownloaded = existsSync17(getWhisperModelPath());
+  const modelDownloaded = existsSync18(getWhisperModelPath());
   return {
     sox: soxBinary !== null,
     whisper: whisperBinary !== null,
@@ -8281,22 +8666,22 @@ function installSox(pm) {
   try {
     switch (pm) {
       case "brew":
-        execSync9("brew install sox", { stdio: "inherit", timeout: 300000 });
+        execSync11("brew install sox", { stdio: "inherit", timeout: 300000 });
         break;
       case "apt":
-        execSync9("sudo apt-get install -y sox", {
+        execSync11("sudo apt-get install -y sox", {
           stdio: "inherit",
           timeout: 300000
         });
         break;
       case "dnf":
-        execSync9("sudo dnf install -y sox", {
+        execSync11("sudo dnf install -y sox", {
           stdio: "inherit",
           timeout: 300000
         });
         break;
       case "pacman":
-        execSync9("sudo pacman -S --noconfirm sox", {
+        execSync11("sudo pacman -S --noconfirm sox", {
           stdio: "inherit",
           timeout: 300000
         });
@@ -8310,7 +8695,7 @@ function installSox(pm) {
 function installWhisperCpp(pm) {
   if (pm === "brew") {
     try {
-      execSync9("brew install whisper-cpp", {
+      execSync11("brew install whisper-cpp", {
         stdio: "inherit",
         timeout: 300000
       });
@@ -8332,19 +8717,19 @@ function ensureBuildDeps(pm) {
   try {
     switch (pm) {
       case "apt":
-        execSync9("sudo apt-get install -y cmake g++ make git", {
+        execSync11("sudo apt-get install -y cmake g++ make git", {
           stdio: "inherit",
           timeout: 300000
         });
         break;
       case "dnf":
-        execSync9("sudo dnf install -y cmake gcc-c++ make git", {
+        execSync11("sudo dnf install -y cmake gcc-c++ make git", {
           stdio: "inherit",
           timeout: 300000
         });
         break;
       case "pacman":
-        execSync9("sudo pacman -S --noconfirm cmake gcc make git", {
+        execSync11("sudo pacman -S --noconfirm cmake gcc make git", {
           stdio: "inherit",
           timeout: 300000
         });
@@ -8359,40 +8744,40 @@ function ensureBuildDeps(pm) {
 }
 function buildWhisperFromSource(pm) {
   const out = process.stderr;
-  const buildDir = join17(tmpdir4(), `locus-whisper-build-${process.pid}`);
+  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 {
-    mkdirSync12(buildDir, { recursive: true });
-    mkdirSync12(LOCUS_BIN_DIR, { recursive: true });
+    mkdirSync13(buildDir, { recursive: true });
+    mkdirSync13(LOCUS_BIN_DIR, { recursive: true });
     out.write(`  ${dim2("Cloning whisper.cpp...")}
 `);
-    execSync9(`git clone --depth 1 https://github.com/ggerganov/whisper.cpp.git "${join17(buildDir, "whisper.cpp")}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
-    const srcDir = join17(buildDir, "whisper.cpp");
+    execSync11(`git clone --depth 1 https://github.com/ggerganov/whisper.cpp.git "${join18(buildDir, "whisper.cpp")}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
+    const srcDir = join18(buildDir, "whisper.cpp");
     const numCpus = cpus().length || 2;
     out.write(`  ${dim2("Building whisper.cpp (this may take a few minutes)...")}
 `);
-    execSync9("cmake -B build -DCMAKE_BUILD_TYPE=Release", {
+    execSync11("cmake -B build -DCMAKE_BUILD_TYPE=Release", {
       cwd: srcDir,
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 120000
     });
-    execSync9(`cmake --build build --config Release -j${numCpus}`, {
+    execSync11(`cmake --build build --config Release -j${numCpus}`, {
       cwd: srcDir,
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 600000
     });
-    const destPath = join17(LOCUS_BIN_DIR, "whisper-cli");
+    const destPath = join18(LOCUS_BIN_DIR, "whisper-cli");
     const binaryCandidates = [
-      join17(srcDir, "build", "bin", "whisper-cli"),
-      join17(srcDir, "build", "bin", "main")
+      join18(srcDir, "build", "bin", "whisper-cli"),
+      join18(srcDir, "build", "bin", "main")
     ];
     for (const candidate of binaryCandidates) {
-      if (existsSync17(candidate)) {
-        execSync9(`cp "${candidate}" "${destPath}" && chmod +x "${destPath}"`, {
+      if (existsSync18(candidate)) {
+        execSync11(`cp "${candidate}" "${destPath}" && chmod +x "${destPath}"`, {
           stdio: "pipe"
         });
         return true;
@@ -8407,7 +8792,7 @@ function buildWhisperFromSource(pm) {
     return false;
   } finally {
     try {
-      execSync9(`rm -rf "${buildDir}"`, { stdio: "pipe" });
+      execSync11(`rm -rf "${buildDir}"`, { stdio: "pipe" });
     } catch {}
   }
 }
@@ -8470,20 +8855,20 @@ ${bold2("Installing voice dependencies...")}
 }
 function downloadModel() {
   const modelPath = getWhisperModelPath();
-  if (existsSync17(modelPath))
+  if (existsSync18(modelPath))
     return true;
-  mkdirSync12(WHISPER_MODELS_DIR, { recursive: 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")) {
-      execSync9(`curl -L -o "${modelPath}" "${url}"`, {
+      execSync11(`curl -L -o "${modelPath}" "${url}"`, {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 300000
       });
     } else if (commandExists("wget")) {
-      execSync9(`wget -O "${modelPath}" "${url}"`, {
+      execSync11(`wget -O "${modelPath}" "${url}"`, {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 300000
       });
@@ -8517,7 +8902,7 @@ class VoiceController {
   onStateChange;
   constructor(options) {
     this.onStateChange = options.onStateChange;
-    this.tempFile = join17(tmpdir4(), `locus-voice-${process.pid}.wav`);
+    this.tempFile = join18(tmpdir4(), `locus-voice-${process.pid}.wav`);
     this.deps = checkDependencies();
   }
   getState() {
@@ -8585,7 +8970,7 @@ ${red2("✗")} Recording failed: ${err.message}\r
     this.recordProcess = null;
     this.setState("idle");
     await sleep2(200);
-    if (!existsSync17(this.tempFile)) {
+    if (!existsSync18(this.tempFile)) {
       return null;
     }
     try {
@@ -8676,12 +9061,12 @@ function sleep2(ms) {
 var WHISPER_MODEL = "base.en", WHISPER_MODELS_DIR, LOCUS_BIN_DIR;
 var init_voice = __esm(() => {
   init_terminal();
-  WHISPER_MODELS_DIR = join17(homedir4(), ".locus", "whisper-models");
-  LOCUS_BIN_DIR = join17(homedir4(), ".locus", "bin");
+  WHISPER_MODELS_DIR = join18(homedir4(), ".locus", "whisper-models");
+  LOCUS_BIN_DIR = join18(homedir4(), ".locus", "bin");
 });
 
 // src/repl/repl.ts
-import { execSync as execSync10 } from "node:child_process";
+import { execSync as execSync12 } from "node:child_process";
 async function startRepl(options) {
   const { projectRoot, config } = options;
   const sessionManager = new SessionManager(projectRoot);
@@ -8699,7 +9084,7 @@ async function startRepl(options) {
   } else {
     let branch = "main";
     try {
-      branch = execSync10("git rev-parse --abbrev-ref HEAD", {
+      branch = execSync12("git rev-parse --abbrev-ref HEAD", {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -8751,7 +9136,7 @@ async function runInteractiveRepl(session, sessionManager, options) {
     const provider = inferProviderFromModel(config.ai.model) || config.ai.provider;
     const sandboxName = getProviderSandboxName(config.sandbox, provider);
     if (sandboxName) {
-      sandboxRunner = createUserManagedSandboxRunner(provider, sandboxName);
+      sandboxRunner = createUserManagedSandboxRunner(provider, sandboxName, config.sandbox.containerWorkdir);
       process.stderr.write(`${dim2("Using")} ${dim2(provider)} ${dim2("sandbox")} ${dim2(sandboxName)}
 `);
     } else {
@@ -8802,7 +9187,7 @@ async function runInteractiveRepl(session, sessionManager, options) {
         if (providerChanged && config.sandbox.enabled) {
           const sandboxName = getProviderSandboxName(config.sandbox, inferredProvider);
           if (sandboxName) {
-            sandboxRunner = createUserManagedSandboxRunner(inferredProvider, sandboxName);
+            sandboxRunner = createUserManagedSandboxRunner(inferredProvider, sandboxName, config.sandbox.containerWorkdir);
             process.stderr.write(`${dim2("Switched sandbox agent to")} ${dim2(inferredProvider)} ${dim2(`(${sandboxName})`)}
 `);
           } else {
@@ -8930,6 +9315,7 @@ async function executeAITurn(prompt, session, options, verbose = false, runner)
     verbose,
     sandboxed: config.sandbox.enabled,
     sandboxName,
+    containerWorkdir: config.sandbox.containerWorkdir,
     runner
   });
   if (aiResult.interrupted) {
@@ -9134,7 +9520,7 @@ async function handleJsonStream(projectRoot, config, args, sessionId) {
   try {
     const fullPrompt = buildReplPrompt(prompt, projectRoot, config);
     const sandboxName = getProviderSandboxName(config.sandbox, config.ai.provider);
-    const runner = config.sandbox.enabled ? sandboxName ? createUserManagedSandboxRunner(config.ai.provider, sandboxName) : null : await createRunnerAsync(config.ai.provider, false);
+    const runner = config.sandbox.enabled ? sandboxName ? createUserManagedSandboxRunner(config.ai.provider, sandboxName, config.sandbox.containerWorkdir) : null : await createRunnerAsync(config.ai.provider, false);
     if (!runner) {
       const mismatch = checkProviderSandboxMismatch(config.sandbox, config.ai.model, config.ai.provider);
       stream.emitError(mismatch ?? `No sandbox configured for "${config.ai.provider}". Run "locus sandbox" to create one.`, false);
@@ -9187,11 +9573,11 @@ var init_exec = __esm(() => {
 });
 
 // src/core/submodule.ts
-import { execSync as execSync11 } from "node:child_process";
-import { existsSync as existsSync18 } from "node:fs";
-import { join as join18 } from "node:path";
+import { execSync as execSync13 } from "node:child_process";
+import { existsSync as existsSync19 } from "node:fs";
+import { join as join19 } from "node:path";
 function git2(args, cwd) {
-  return execSync11(`git ${args}`, {
+  return execSync13(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -9205,7 +9591,7 @@ function gitSafe(args, cwd) {
   }
 }
 function hasSubmodules(cwd) {
-  return existsSync18(join18(cwd, ".gitmodules"));
+  return existsSync19(join19(cwd, ".gitmodules"));
 }
 function listSubmodules(cwd) {
   if (!hasSubmodules(cwd))
@@ -9225,7 +9611,7 @@ function listSubmodules(cwd) {
         continue;
       submodules.push({
         path,
-        absolutePath: join18(cwd, path),
+        absolutePath: join19(cwd, path),
         dirty
       });
     }
@@ -9238,7 +9624,7 @@ function getDirtySubmodules(cwd) {
   const submodules = listSubmodules(cwd);
   const dirty = [];
   for (const sub of submodules) {
-    if (!existsSync18(sub.absolutePath))
+    if (!existsSync19(sub.absolutePath))
       continue;
     const status = gitSafe("status --porcelain", sub.absolutePath);
     if (status && status.trim().length > 0) {
@@ -9259,7 +9645,7 @@ function commitDirtySubmodules(cwd, issueNumber, issueTitle) {
       const message = `chore: complete #${issueNumber} - ${issueTitle}
 
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
-      execSync11("git commit -F -", {
+      execSync13("git commit -F -", {
         input: message,
         cwd: sub.absolutePath,
         encoding: "utf-8",
@@ -9325,7 +9711,7 @@ function pushSubmoduleBranches(cwd) {
   const log = getLogger();
   const submodules = listSubmodules(cwd);
   for (const sub of submodules) {
-    if (!existsSync18(sub.absolutePath))
+    if (!existsSync19(sub.absolutePath))
       continue;
     const branch = gitSafe("rev-parse --abbrev-ref HEAD", sub.absolutePath)?.trim();
     if (!branch || branch === "HEAD")
@@ -9346,7 +9732,7 @@ var init_submodule = __esm(() => {
 });
 
 // src/core/agent.ts
-import { execSync as execSync12 } from "node:child_process";
+import { execSync as execSync14 } from "node:child_process";
 async function executeIssue(projectRoot, options) {
   const log = getLogger();
   const timer = createTimer();
@@ -9375,7 +9761,7 @@ ${cyan2("●")} ${bold2(`#${issueNumber}`)} ${issue.title}
   }
   let issueComments = [];
   try {
-    const commentsRaw = execSync12(`gh issue view ${issueNumber} --json comments --jq '.comments[].body'`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const commentsRaw = execSync14(`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);
@@ -9412,7 +9798,8 @@ ${yellow2("⚠")} ${bold2("Dry run")} — would execute with:
     cwd: options.worktreePath ?? projectRoot,
     activity: `issue #${issueNumber}`,
     sandboxed: options.sandboxed,
-    sandboxName: options.sandboxName
+    sandboxName: options.sandboxName,
+    containerWorkdir: options.containerWorkdir
   });
   const output = aiResult.output;
   if (aiResult.interrupted) {
@@ -9518,7 +9905,8 @@ ${c.body}`),
     cwd: projectRoot,
     activity: `iterating on PR #${prNumber}`,
     sandboxed: config.sandbox.enabled,
-    sandboxName: getModelSandboxName(config.sandbox, config.ai.model, config.ai.provider)
+    sandboxName: getModelSandboxName(config.sandbox, config.ai.model, config.ai.provider),
+    containerWorkdir: config.sandbox.containerWorkdir
   });
   if (aiResult.interrupted) {
     process.stderr.write(`
@@ -9539,12 +9927,12 @@ ${aiResult.success ? green("✓") : red2("✗")} Iteration ${aiResult.success ?
 }
 async function createIssuePR(projectRoot, config, issue) {
   try {
-    const currentBranch = execSync12("git rev-parse --abbrev-ref HEAD", {
+    const currentBranch = execSync14("git rev-parse --abbrev-ref HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const diff = execSync12(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
+    const diff = execSync14(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9554,7 +9942,7 @@ async function createIssuePR(projectRoot, config, issue) {
       return;
     }
     pushSubmoduleBranches(projectRoot);
-    execSync12(`git push -u origin ${currentBranch}`, {
+    execSync14(`git push -u origin ${currentBranch}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9609,9 +9997,9 @@ var init_agent = __esm(() => {
 });
 
 // src/core/conflict.ts
-import { execSync as execSync13 } from "node:child_process";
+import { execSync as execSync15 } from "node:child_process";
 function git3(args, cwd) {
-  return execSync13(`git ${args}`, {
+  return execSync15(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -9740,19 +10128,19 @@ var init_conflict = __esm(() => {
 
 // src/core/run-state.ts
 import {
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync13,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync14,
   readFileSync as readFileSync12,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import { dirname as dirname6, join as join19 } from "node:path";
+import { dirname as dirname6, join as join20 } from "node:path";
 function getRunStatePath(projectRoot) {
-  return join19(projectRoot, ".locus", "run-state.json");
+  return join20(projectRoot, ".locus", "run-state.json");
 }
 function loadRunState(projectRoot) {
   const path = getRunStatePath(projectRoot);
-  if (!existsSync19(path))
+  if (!existsSync20(path))
     return null;
   try {
     return JSON.parse(readFileSync12(path, "utf-8"));
@@ -9764,15 +10152,15 @@ function loadRunState(projectRoot) {
 function saveRunState(projectRoot, state) {
   const path = getRunStatePath(projectRoot);
   const dir = dirname6(path);
-  if (!existsSync19(dir)) {
-    mkdirSync13(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 (existsSync19(path)) {
+  if (existsSync20(path)) {
     unlinkSync5(path);
   }
 }
@@ -9912,11 +10300,11 @@ var init_shutdown = __esm(() => {
 });
 
 // src/core/worktree.ts
-import { execSync as execSync14 } from "node:child_process";
-import { existsSync as existsSync20, readdirSync as readdirSync7, realpathSync, statSync as statSync4 } from "node:fs";
-import { join as join20 } from "node:path";
+import { execSync as execSync16 } from "node:child_process";
+import { existsSync as existsSync21, readdirSync as readdirSync7, realpathSync, statSync as statSync4 } from "node:fs";
+import { join as join21 } from "node:path";
 function git4(args, cwd) {
-  return execSync14(`git ${args}`, {
+  return execSync16(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -9930,10 +10318,10 @@ function gitSafe3(args, cwd) {
   }
 }
 function getWorktreeDir(projectRoot) {
-  return join20(projectRoot, ".locus", "worktrees");
+  return join21(projectRoot, ".locus", "worktrees");
 }
 function getWorktreePath(projectRoot, issueNumber) {
-  return join20(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
+  return join21(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
 }
 function generateBranchName(issueNumber) {
   const randomSuffix = Math.random().toString(36).slice(2, 8);
@@ -9941,7 +10329,7 @@ function generateBranchName(issueNumber) {
 }
 function getWorktreeBranch(worktreePath) {
   try {
-    return execSync14("git branch --show-current", {
+    return execSync16("git branch --show-current", {
       cwd: worktreePath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9953,7 +10341,7 @@ function getWorktreeBranch(worktreePath) {
 function createWorktree(projectRoot, issueNumber, baseBranch) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (existsSync20(worktreePath)) {
+  if (existsSync21(worktreePath)) {
     log.verbose(`Worktree already exists for issue #${issueNumber}`);
     const existingBranch = getWorktreeBranch(worktreePath) ?? `locus/issue-${issueNumber}`;
     return {
@@ -9981,7 +10369,7 @@ function createWorktree(projectRoot, issueNumber, baseBranch) {
 function removeWorktree(projectRoot, issueNumber) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync20(worktreePath)) {
+  if (!existsSync21(worktreePath)) {
     log.verbose(`Worktree for issue #${issueNumber} does not exist`);
     return;
   }
@@ -10000,7 +10388,7 @@ function removeWorktree(projectRoot, issueNumber) {
 function listWorktrees(projectRoot) {
   const log = getLogger();
   const worktreeDir = getWorktreeDir(projectRoot);
-  if (!existsSync20(worktreeDir)) {
+  if (!existsSync21(worktreeDir)) {
     return [];
   }
   const entries = readdirSync7(worktreeDir).filter((entry) => entry.startsWith("issue-"));
@@ -10020,7 +10408,7 @@ function listWorktrees(projectRoot) {
     if (!match)
       continue;
     const issueNumber = Number.parseInt(match[1], 10);
-    const path = join20(worktreeDir, entry);
+    const path = join21(worktreeDir, entry);
     const branch = getWorktreeBranch(path) ?? `locus/issue-${issueNumber}`;
     let resolvedPath;
     try {
@@ -10068,12 +10456,12 @@ var exports_run = {};
 __export(exports_run, {
   runCommand: () => runCommand
 });
-import { execSync as execSync15 } from "node:child_process";
+import { execSync as execSync17 } from "node:child_process";
 function resolveExecutionContext(config, modelOverride) {
   const model = modelOverride ?? config.ai.model;
   const provider = inferProviderFromModel(model) ?? config.ai.provider;
   const sandboxName = getModelSandboxName(config.sandbox, model, provider);
-  return { provider, model, sandboxName };
+  return { provider, model, sandboxName, containerWorkdir: config.sandbox.containerWorkdir };
 }
 function printRunHelp() {
   process.stderr.write(`
@@ -10228,7 +10616,7 @@ ${yellow2("⚠")} A sprint run is already in progress.
   }
   if (!flags.dryRun) {
     try {
-      execSync15(`git checkout -B ${branchName}`, {
+      execSync17(`git checkout -B ${branchName}`, {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -10278,7 +10666,7 @@ ${red2("✗")} Auto-rebase failed. Resolve manually.
     let sprintContext;
     if (i > 0 && !flags.dryRun) {
       try {
-        sprintContext = execSync15(`git diff origin/${config.agent.baseBranch}..HEAD`, {
+        sprintContext = execSync17(`git diff origin/${config.agent.baseBranch}..HEAD`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10299,7 +10687,8 @@ ${progressBar(i, state.tasks.length, { label: "Sprint Progress" })}
       sprintContext,
       skipPR: true,
       sandboxed,
-      sandboxName: execution.sandboxName
+      sandboxName: execution.sandboxName,
+      containerWorkdir: execution.containerWorkdir
     });
     if (result.success) {
       if (!flags.dryRun) {
@@ -10343,7 +10732,7 @@ ${bold2("Summary:")}
     const prNumber = await createSprintPR(projectRoot, config, sprintName, branchName, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync15(`git checkout ${config.agent.baseBranch}`, {
+        execSync17(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10376,7 +10765,8 @@ ${bold2("Running sprint issue")} ${cyan2(`#${issueNumber}`)} ${dim2("(sequential
       model: execution.model,
       dryRun: flags.dryRun,
       sandboxed,
-      sandboxName: execution.sandboxName
+      sandboxName: execution.sandboxName,
+      containerWorkdir: execution.containerWorkdir
     });
     return;
   }
@@ -10388,7 +10778,7 @@ ${bold2("Running issue")} ${cyan2(`#${issueNumber}`)} ${dim2(`(branch: ${branchN
 `);
   if (!flags.dryRun) {
     try {
-      execSync15(`git checkout -B ${branchName} ${config.agent.baseBranch}`, {
+      execSync17(`git checkout -B ${branchName} ${config.agent.baseBranch}`, {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -10413,7 +10803,7 @@ ${bold2("Running issue")} ${cyan2(`#${issueNumber}`)} ${dim2(`(branch: ${branchN
   if (!flags.dryRun) {
     if (result.success) {
       try {
-        execSync15(`git checkout ${config.agent.baseBranch}`, {
+        execSync17(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10484,7 +10874,8 @@ ${bold2("Running")} ${cyan2(`${issueNumbers.length} issues`)} ${dim2(`(max ${max
         model: execution.model,
         dryRun: flags.dryRun,
         sandboxed,
-        sandboxName: execution.sandboxName
+        sandboxName: execution.sandboxName,
+        containerWorkdir: execution.containerWorkdir
       });
       if (result.success) {
         markTaskDone(state, issueNumber, result.prNumber);
@@ -10550,13 +10941,13 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
 `);
   if (state.type === "sprint" && state.branch) {
     try {
-      const currentBranch = execSync15("git rev-parse --abbrev-ref HEAD", {
+      const currentBranch = execSync17("git rev-parse --abbrev-ref HEAD", {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
       if (currentBranch !== state.branch) {
-        execSync15(`git checkout ${state.branch}`, {
+        execSync17(`git checkout ${state.branch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10584,7 +10975,8 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
       model: execution.model,
       skipPR: isSprintRun,
       sandboxed,
-      sandboxName: execution.sandboxName
+      sandboxName: execution.sandboxName,
+      containerWorkdir: execution.containerWorkdir
     });
     if (result.success) {
       if (isSprintRun) {
@@ -10623,7 +11015,7 @@ ${bold2("Resume complete:")} ${green(`✓ ${finalStats.done}`)} ${finalStats.fai
     const prNumber = await createSprintPR(projectRoot, config, state.sprint, state.branch, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync15(`git checkout ${config.agent.baseBranch}`, {
+        execSync17(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10659,14 +11051,14 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
       process.stderr.write(`  ${dim2(`Committed submodule changes: ${committedSubmodules.join(", ")}`)}
 `);
     }
-    const status = execSync15("git status --porcelain", {
+    const status = execSync17("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!status)
       return;
-    execSync15("git add -A", {
+    execSync17("git add -A", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10674,7 +11066,7 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
     const message = `chore: complete #${issueNumber} - ${issueTitle}
 
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
-    execSync15(`git commit -F -`, {
+    execSync17(`git commit -F -`, {
       input: message,
       cwd: projectRoot,
       encoding: "utf-8",
@@ -10688,7 +11080,7 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
   if (!config.agent.autoPR)
     return;
   try {
-    const diff = execSync15(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
+    const diff = execSync17(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10699,7 +11091,7 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
       return;
     }
     pushSubmoduleBranches(projectRoot);
-    execSync15(`git push -u origin ${branchName}`, {
+    execSync17(`git push -u origin ${branchName}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10857,14 +11249,14 @@ __export(exports_plan, {
   parsePlanArgs: () => parsePlanArgs
 });
 import {
-  existsSync as existsSync21,
-  mkdirSync as mkdirSync14,
+  existsSync as existsSync22,
+  mkdirSync as mkdirSync15,
   readdirSync as readdirSync8,
   readFileSync as readFileSync13,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { join as join21 } from "node:path";
-function printHelp() {
+import { join as join22 } from "node:path";
+function printHelp2() {
   process.stderr.write(`
 ${bold2("locus plan")} — AI-powered sprint planning
 
@@ -10894,12 +11286,12 @@ function normalizeSprintName(name) {
   return name.trim().toLowerCase();
 }
 function getPlansDir(projectRoot) {
-  return join21(projectRoot, ".locus", "plans");
+  return join22(projectRoot, ".locus", "plans");
 }
 function ensurePlansDir(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync21(dir)) {
-    mkdirSync14(dir, { recursive: true });
+  if (!existsSync22(dir)) {
+    mkdirSync15(dir, { recursive: true });
   }
   return dir;
 }
@@ -10908,14 +11300,14 @@ function generateId() {
 }
 function loadPlanFile(projectRoot, id) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync21(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(join21(dir, match), "utf-8");
+    const content = readFileSync13(join22(dir, match), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -10923,7 +11315,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") {
@@ -10961,7 +11353,7 @@ async function planCommand(projectRoot, args, flags = {}) {
 }
 function handleListPlans(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync21(dir)) {
+  if (!existsSync22(dir)) {
     process.stderr.write(`${dim2("No saved plans yet.")}
 `);
     return;
@@ -10979,7 +11371,7 @@ ${bold2("Saved Plans:")}
   for (const file of files) {
     const id = file.replace(".json", "");
     try {
-      const content = readFileSync13(join21(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;
@@ -11090,7 +11482,7 @@ ${bold2("Approving plan:")}
 async function handleAIPlan(projectRoot, config, directive, sprintName, flags) {
   const id = generateId();
   const plansDir = ensurePlansDir(projectRoot);
-  const planPath = join21(plansDir, `${id}.json`);
+  const planPath = join22(plansDir, `${id}.json`);
   const planPathRelative = `.locus/plans/${id}.json`;
   const displayDirective = directive;
   process.stderr.write(`
@@ -11118,7 +11510,8 @@ ${bold2("Planning:")} ${cyan2(displayDirective)}
     cwd: projectRoot,
     activity: "planning",
     sandboxed: config.sandbox.enabled,
-    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
+    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider),
+    containerWorkdir: config.sandbox.containerWorkdir
   });
   if (aiResult.interrupted) {
     process.stderr.write(`
@@ -11132,7 +11525,7 @@ ${red2("✗")} Planning failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync21(planPath)) {
+  if (!existsSync22(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
 `);
@@ -11164,7 +11557,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)}
 
@@ -11241,7 +11634,8 @@ Start with foundational/setup tasks, then core features, then integration/testin
     activity: "issue ordering",
     silent: true,
     sandboxed: config.sandbox.enabled,
-    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
+    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider),
+    containerWorkdir: config.sandbox.containerWorkdir
   });
   if (aiResult.interrupted) {
     process.stderr.write(`
@@ -11313,15 +11707,15 @@ ${directive}${sprintName ? `
 
 **Sprint:** ${sprintName}` : ""}
 </directive>`);
-  const locusPath = join21(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync21(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 = join21(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync21(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)}
@@ -11501,10 +11895,10 @@ var exports_review = {};
 __export(exports_review, {
   reviewCommand: () => reviewCommand
 });
-import { execFileSync as execFileSync2, execSync as execSync16 } from "node:child_process";
-import { existsSync as existsSync22, readFileSync as readFileSync14 } from "node:fs";
-import { join as join22 } from "node:path";
-function printHelp2() {
+import { execFileSync as execFileSync2, execSync as execSync18 } 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
 
@@ -11527,7 +11921,7 @@ ${bold2("Examples:")}
 }
 async function reviewCommand(projectRoot, args, flags = {}) {
   if (args[0] === "help") {
-    printHelp2();
+    printHelp3();
     return;
   }
   const config = loadConfig(projectRoot);
@@ -11587,7 +11981,7 @@ ${bold2("Review complete:")} ${green(`✓ ${reviewed}`)}${failed > 0 ? ` ${red2(
 async function reviewSinglePR(projectRoot, config, prNumber, focus, flags) {
   let prInfo;
   try {
-    const result = execSync16(`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 = execSync18(`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,
@@ -11632,7 +12026,8 @@ async function reviewPR(projectRoot, config, pr, focus, flags) {
     cwd: projectRoot,
     activity: `PR #${pr.number}`,
     sandboxed: config.sandbox.enabled,
-    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
+    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider),
+    containerWorkdir: config.sandbox.containerWorkdir
   });
   if (aiResult.interrupted) {
     process.stderr.write(`  ${yellow2("⚡")} Review interrupted.
@@ -11671,8 +12066,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 = join22(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync22(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)}
@@ -11734,8 +12129,8 @@ var exports_iterate = {};
 __export(exports_iterate, {
   iterateCommand: () => iterateCommand
 });
-import { execSync as execSync17 } from "node:child_process";
-function printHelp3() {
+import { execSync as execSync19 } from "node:child_process";
+function printHelp4() {
   process.stderr.write(`
 ${bold2("locus iterate")} — Re-execute tasks with PR feedback
 
@@ -11760,7 +12155,7 @@ ${bold2("Examples:")}
 }
 async function iterateCommand(projectRoot, args, flags = {}) {
   if (args[0] === "help") {
-    printHelp3();
+    printHelp4();
     return;
   }
   const config = loadConfig(projectRoot);
@@ -11952,12 +12347,12 @@ ${bold2("Summary:")} ${green(`✓ ${succeeded}`)}${failed > 0 ? ` ${red2(`✗ ${
 }
 function findPRForIssue(projectRoot, issueNumber) {
   try {
-    const result = execSync17(`gh pr list --search "Closes #${issueNumber}" --json number --state open`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const result = execSync19(`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 = execSync17(`gh pr list --head "locus/issue-${issueNumber}" --json number --state open`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const branchResult = execSync19(`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;
@@ -11993,15 +12388,15 @@ __export(exports_discuss, {
   discussCommand: () => discussCommand
 });
 import {
-  existsSync as existsSync23,
-  mkdirSync as mkdirSync15,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync16,
   readdirSync as readdirSync9,
   readFileSync as readFileSync15,
   unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { join as join23 } from "node:path";
-function printHelp4() {
+import { join as join24 } from "node:path";
+function printHelp5() {
   process.stderr.write(`
 ${bold2("locus discuss")} — AI-powered architectural discussions
 
@@ -12022,12 +12417,12 @@ ${bold2("Examples:")}
 `);
 }
 function getDiscussionsDir(projectRoot) {
-  return join23(projectRoot, ".locus", "discussions");
+  return join24(projectRoot, ".locus", "discussions");
 }
 function ensureDiscussionsDir(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync23(dir)) {
-    mkdirSync15(dir, { recursive: true });
+  if (!existsSync24(dir)) {
+    mkdirSync16(dir, { recursive: true });
   }
   return dir;
 }
@@ -12036,7 +12431,7 @@ function generateId2() {
 }
 async function discussCommand(projectRoot, args, flags = {}) {
   if (args[0] === "help") {
-    printHelp4();
+    printHelp5();
     return;
   }
   const subcommand = args[0];
@@ -12053,7 +12448,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
     return deleteDiscussion(projectRoot, args[1]);
   }
   if (args.length === 0) {
-    printHelp4();
+    printHelp5();
     return;
   }
   const topic = args.join(" ").trim();
@@ -12061,7 +12456,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
 }
 function listDiscussions(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${dim2("No discussions yet.")}
 `);
     return;
@@ -12078,7 +12473,7 @@ ${bold2("Discussions:")}
 `);
   for (const file of files) {
     const id = file.replace(".md", "");
-    const content = readFileSync15(join23(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*(.+)/);
@@ -12096,7 +12491,7 @@ function showDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -12108,7 +12503,7 @@ function showDiscussion(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join23(dir, match), "utf-8");
+  const content = readFileSync15(join24(dir, match), "utf-8");
   process.stdout.write(`${content}
 `);
 }
@@ -12119,7 +12514,7 @@ function deleteDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -12131,7 +12526,7 @@ function deleteDiscussion(projectRoot, id) {
 `);
     return;
   }
-  unlinkSync6(join23(dir, match));
+  unlinkSync6(join24(dir, match));
   process.stderr.write(`${green("✓")} Deleted discussion: ${match.replace(".md", "")}
 `);
 }
@@ -12144,7 +12539,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -12156,7 +12551,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync15(join23(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, [
@@ -12214,7 +12609,8 @@ ${bold2("Discussion:")} ${cyan2(topic)}
       cwd: projectRoot,
       activity: "discussion",
       sandboxed: config.sandbox.enabled,
-      sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
+      sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider),
+      containerWorkdir: config.sandbox.containerWorkdir
     });
     if (aiResult.interrupted) {
       process.stderr.write(`
@@ -12281,7 +12677,7 @@ ${turn.content}`;
     ...conversation.length > 1 ? [`---`, ``, `## Discussion Transcript`, ``, transcript, ``] : []
   ].join(`
 `);
-  writeFileSync10(join23(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()})`)}
 `);
@@ -12296,15 +12692,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 = join23(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync23(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 = join23(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync23(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)}
@@ -12376,9 +12772,9 @@ __export(exports_artifacts, {
   formatDate: () => formatDate2,
   artifactsCommand: () => artifactsCommand
 });
-import { existsSync as existsSync24, readdirSync as readdirSync10, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
-import { join as join24 } 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
 
@@ -12397,14 +12793,14 @@ ${dim2("Artifact names support partial matching.")}
 `);
 }
 function getArtifactsDir(projectRoot) {
-  return join24(projectRoot, ".locus", "artifacts");
+  return join25(projectRoot, ".locus", "artifacts");
 }
 function listArtifacts(projectRoot) {
   const dir = getArtifactsDir(projectRoot);
-  if (!existsSync24(dir))
+  if (!existsSync25(dir))
     return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".md")).map((fileName) => {
-    const filePath = join24(dir, fileName);
+    const filePath = join25(dir, fileName);
     const stat = statSync5(filePath);
     return {
       name: fileName.replace(/\.md$/, ""),
@@ -12417,8 +12813,8 @@ function listArtifacts(projectRoot) {
 function readArtifact(projectRoot, name) {
   const dir = getArtifactsDir(projectRoot);
   const fileName = name.endsWith(".md") ? name : `${name}.md`;
-  const filePath = join24(dir, fileName);
-  if (!existsSync24(filePath))
+  const filePath = join25(dir, fileName);
+  if (!existsSync25(filePath))
     return null;
   const stat = statSync5(filePath);
   return {
@@ -12450,7 +12846,7 @@ function formatDate2(date) {
 }
 async function artifactsCommand(projectRoot, args) {
   if (args[0] === "help") {
-    printHelp5();
+    printHelp6();
     return;
   }
   const subcommand = args[0];
@@ -12587,10 +12983,10 @@ __export(exports_sandbox2, {
   parseSandboxLogsArgs: () => parseSandboxLogsArgs,
   parseSandboxInstallArgs: () => parseSandboxInstallArgs
 });
-import { execSync as execSync18, spawn as spawn7 } from "node:child_process";
+import { execSync as execSync20, spawn as spawn7 } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync as existsSync25, readFileSync as readFileSync17 } from "node:fs";
-import { basename as basename4, join as join25 } 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(`
@@ -12721,11 +13117,20 @@ async function handleCreate(projectRoot) {
   }
   process.stderr.write(`${green("✓")} ${provider} sandbox created: ${bold2(name)}
 `);
+  if (!config.sandbox.containerWorkdir) {
+    const containerWorkdir = detectContainerWorkdir(name, projectRoot);
+    if (containerWorkdir) {
+      config.sandbox.containerWorkdir = containerWorkdir;
+      process.stderr.write(`  ${dim2(`Container workdir: ${containerWorkdir}`)}
+`);
+    }
+  }
   readySandboxes[provider] = name;
   config.sandbox.enabled = true;
   config.sandbox.providers = readySandboxes;
   saveConfig(projectRoot, config);
-  await runSandboxSetup(name, projectRoot);
+  const workdir = config.sandbox.containerWorkdir ?? projectRoot;
+  await runSandboxSetup(name, projectRoot, workdir);
   process.stderr.write(`
 ${green("✓")} Sandbox mode enabled for ${bold2(provider)}.
 `);
@@ -12750,19 +13155,20 @@ async function handleAgentLogin(projectRoot, agent) {
   if (agent === "codex") {
     await ensureCodexInSandbox(sandboxName);
   }
+  const workdir = config.sandbox.containerWorkdir ?? projectRoot;
   process.stderr.write(`Connecting to ${agent} sandbox ${dim2(sandboxName)}...
 `);
   process.stderr.write(`${dim2("Login and then exit when ready.")}
 
 `);
-  const child = spawn7("docker", ["sandbox", "exec", "-it", "-w", projectRoot, sandboxName, agent], {
+  const child = spawn7("docker", ["sandbox", "exec", "-it", "-w", workdir, sandboxName, agent], {
     stdio: "inherit"
   });
   await new Promise((resolve2) => {
     child.on("close", async (code) => {
       const backup = backupIgnoredFiles(projectRoot);
       try {
-        await enforceSandboxIgnore(sandboxName, projectRoot);
+        await enforceSandboxIgnore(sandboxName, projectRoot, config.sandbox.containerWorkdir);
       } finally {
         backup.restore();
       }
@@ -12799,7 +13205,7 @@ function handleRemove(projectRoot) {
     process.stderr.write(`Removing sandbox ${bold2(sandboxName)}...
 `);
     try {
-      execSync18(`docker sandbox rm ${sandboxName}`, {
+      execSync20(`docker sandbox rm ${sandboxName}`, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 15000
@@ -12808,6 +13214,7 @@ function handleRemove(projectRoot) {
   }
   config.sandbox.providers = {};
   config.sandbox.enabled = false;
+  delete config.sandbox.containerWorkdir;
   saveConfig(projectRoot, config);
   process.stderr.write(`${green("✓")} Provider sandboxes removed. Sandbox mode disabled.
 `);
@@ -12820,6 +13227,10 @@ ${bold2("Sandbox Status")}
 `);
   process.stderr.write(`  ${dim2("Enabled:")}  ${config.sandbox.enabled ? green("yes") : red2("no")}
 `);
+  if (config.sandbox.containerWorkdir) {
+    process.stderr.write(`  ${dim2("Container workdir:")}  ${config.sandbox.containerWorkdir}
+`);
+  }
   for (const provider of PROVIDERS) {
     const name = config.sandbox.providers[provider];
     process.stderr.write(`  ${dim2(`${provider}:`).padEnd(15)}${name ? bold2(name) : dim2("(not configured)")}
@@ -12956,10 +13367,12 @@ async function handleShell(projectRoot, args) {
 `);
     return;
   }
+  const config = loadConfig(projectRoot);
   const sandboxName = getActiveProviderSandbox(projectRoot, provider);
   if (!sandboxName) {
     return;
   }
+  const workdir = config.sandbox.containerWorkdir ?? projectRoot;
   process.stderr.write(`Opening shell in ${provider} sandbox ${dim2(sandboxName)}...
 `);
   await runInteractiveCommand("docker", [
@@ -12967,7 +13380,7 @@ async function handleShell(projectRoot, args) {
     "exec",
     "-it",
     "-w",
-    projectRoot,
+    workdir,
     sandboxName,
     "sh"
   ]);
@@ -13048,7 +13461,7 @@ async function handleLogs(projectRoot, args) {
 }
 function detectPackageManager2(projectRoot) {
   try {
-    const raw = readFileSync17(join25(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];
@@ -13057,13 +13470,13 @@ function detectPackageManager2(projectRoot) {
       }
     }
   } catch {}
-  if (existsSync25(join25(projectRoot, "bun.lock")) || existsSync25(join25(projectRoot, "bun.lockb"))) {
+  if (existsSync26(join26(projectRoot, "bun.lock")) || existsSync26(join26(projectRoot, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync25(join25(projectRoot, "yarn.lock"))) {
+  if (existsSync26(join26(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync25(join25(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync26(join26(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
   return "npm";
@@ -13080,7 +13493,8 @@ function getInstallCommand(pm) {
       return ["npm", "install"];
   }
 }
-async function runSandboxSetup(sandboxName, projectRoot) {
+async function runSandboxSetup(sandboxName, projectRoot, containerWorkdir) {
+  const workdir = containerWorkdir ?? projectRoot;
   const ecosystem = detectProjectEcosystem(projectRoot);
   const isJS = isJavaScriptEcosystem(ecosystem);
   if (isJS) {
@@ -13096,7 +13510,7 @@ Installing dependencies (${bold2(installCmd.join(" "))}) in sandbox ${dim2(sandb
       "sandbox",
       "exec",
       "-w",
-      projectRoot,
+      workdir,
       sandboxName,
       ...installCmd
     ]);
@@ -13112,18 +13526,19 @@ Installing dependencies (${bold2(installCmd.join(" "))}) in sandbox ${dim2(sandb
 ${dim2(`Detected ${ecosystem} project — skipping JS package install.`)}
 `);
   }
-  const setupScript = join25(projectRoot, ".locus", "sandbox-setup.sh");
-  if (existsSync25(setupScript)) {
+  const setupScript = join26(projectRoot, ".locus", "sandbox-setup.sh");
+  const containerSetupScript = containerWorkdir ? join26(containerWorkdir, ".locus", "sandbox-setup.sh") : setupScript;
+  if (existsSync26(setupScript)) {
     process.stderr.write(`Running ${bold2(".locus/sandbox-setup.sh")} in sandbox ${dim2(sandboxName)}...
 `);
     const hookOk = await runInteractiveCommand("docker", [
       "sandbox",
       "exec",
       "-w",
-      projectRoot,
+      workdir,
       sandboxName,
       "sh",
-      setupScript
+      containerSetupScript
     ]);
     if (!hookOk) {
       process.stderr.write(`${yellow2("⚠")} Setup hook failed in sandbox ${dim2(sandboxName)}.
@@ -13154,7 +13569,7 @@ async function handleSetup(projectRoot) {
 `);
       continue;
     }
-    await runSandboxSetup(sandboxName, projectRoot);
+    await runSandboxSetup(sandboxName, projectRoot, config.sandbox.containerWorkdir);
   }
 }
 function buildProviderSandboxNames(projectRoot) {
@@ -13199,9 +13614,9 @@ function runInteractiveCommand(command, args) {
     child.on("error", () => resolve2(false));
   });
 }
-async function createProviderSandbox(provider, sandboxName, projectRoot) {
+async function createProviderSandbox(provider, sandboxName, projectRoot, containerWorkdir) {
   try {
-    execSync18(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
+    execSync20(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 120000
     });
@@ -13214,7 +13629,7 @@ async function createProviderSandbox(provider, sandboxName, projectRoot) {
   }
   const backup = backupIgnoredFiles(projectRoot);
   try {
-    await enforceSandboxIgnore(sandboxName, projectRoot);
+    await enforceSandboxIgnore(sandboxName, projectRoot, containerWorkdir);
   } finally {
     backup.restore();
   }
@@ -13222,7 +13637,7 @@ async function createProviderSandbox(provider, sandboxName, projectRoot) {
 }
 async function ensurePackageManagerInSandbox(sandboxName, pm) {
   try {
-    execSync18(`docker sandbox exec ${sandboxName} which ${pm}`, {
+    execSync20(`docker sandbox exec ${sandboxName} which ${pm}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -13231,7 +13646,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
     process.stderr.write(`Installing ${bold2(pm)} in sandbox...
 `);
     try {
-      execSync18(`docker sandbox exec ${sandboxName} npm install -g ${npmPkg}`, {
+      execSync20(`docker sandbox exec ${sandboxName} npm install -g ${npmPkg}`, {
         stdio: "inherit",
         timeout: 120000
       });
@@ -13243,7 +13658,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
 }
 async function ensureCodexInSandbox(sandboxName) {
   try {
-    execSync18(`docker sandbox exec ${sandboxName} which codex`, {
+    execSync20(`docker sandbox exec ${sandboxName} which codex`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -13251,7 +13666,7 @@ async function ensureCodexInSandbox(sandboxName) {
     process.stderr.write(`Installing codex in sandbox...
 `);
     try {
-      execSync18(`docker sandbox exec ${sandboxName} npm install -g @openai/codex`, { stdio: "inherit", timeout: 120000 });
+      execSync20(`docker sandbox exec ${sandboxName} npm install -g @openai/codex`, { stdio: "inherit", timeout: 120000 });
     } catch {
       process.stderr.write(`${red2("✗")} Failed to install codex in sandbox.
 `);
@@ -13260,7 +13675,7 @@ async function ensureCodexInSandbox(sandboxName) {
 }
 function isSandboxAlive(name) {
   try {
-    const output = execSync18("docker sandbox ls", {
+    const output = execSync20("docker sandbox ls", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -13286,13 +13701,13 @@ init_context();
 init_logger();
 init_rate_limiter();
 init_terminal();
-import { existsSync as existsSync26, readFileSync as readFileSync18 } from "node:fs";
-import { join as join26 } 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 = join26(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
-  if (!existsSync26(packageJsonPath)) {
+  const packageJsonPath = join27(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
+  if (!existsSync27(packageJsonPath)) {
     return fallbackVersion;
   }
   try {
@@ -13442,7 +13857,7 @@ function printLogo() {
 `);
   }
 }
-function printHelp6() {
+function printHelp7() {
   printLogo();
   process.stderr.write(`
 
@@ -13463,6 +13878,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)
@@ -13546,7 +13962,7 @@ async function main() {
     process.exit(0);
   }
   if (parsed.flags.help && !parsed.command) {
-    printHelp6();
+    printHelp7();
     process.exit(0);
   }
   const command = resolveAlias(parsed.command);
@@ -13557,7 +13973,7 @@ async function main() {
     try {
       const root = getGitRoot(cwd);
       if (isInitialized(root)) {
-        logDir = join26(root, ".locus", "logs");
+        logDir = join27(root, ".locus", "logs");
         getRateLimiter(root);
       }
     } catch {}
@@ -13578,7 +13994,7 @@ async function main() {
     printVersionNotice = startVersionCheck2(VERSION);
   }
   if (!command) {
-    printHelp6();
+    printHelp7();
     process.exit(0);
   }
   if (command === "init") {
@@ -13587,6 +14003,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));