@locusai/cli 0.22.1 → 0.22.3

package/bin/locus.js

@@ -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,30 @@ ${yellow2("⚠")}  Docker sandbox not available. Install Docker Desktop 4.58+ fo
   }
   return true;
 }
+function detectContainerWorkdir(sandboxName, hostProjectRoot) {
+  const log = getLogger();
+  try {
+    const containerPath = execSync2(`docker sandbox exec ${sandboxName} pwd`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+    if (!containerPath) {
+      log.debug("Container pwd returned empty result");
+      return null;
+    }
+    if (containerPath === hostProjectRoot) {
+      log.debug("Container workdir matches host path", { hostProjectRoot });
+      return null;
+    }
+    log.debug("Detected container workdir differs from host", {
+      hostProjectRoot,
+      containerWorkdir: containerPath
+    });
+    return containerPath;
+  } catch (err) {
+    log.debug("Container workdir detection via pwd failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return null;
+}
 function waitForEnter() {
   return new Promise((resolve) => {
     const rl = createInterface({
@@ -1062,7 +1087,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 +1103,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 +1115,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 +1134,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 +1498,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 +1507,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"],
@@ -2231,7 +2256,7 @@ var exports_create = {};
 __export(exports_create, {
   createCommand: () => createCommand
 });
-import { execSync as execSync4 } from "node:child_process";
+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) {
@@ -2250,7 +2275,7 @@ function capitalize(str) {
 }
 function checkNpmExists(fullName) {
   try {
-    execSync4(`npm view ${fullName} version 2>/dev/null`, {
+    execSync5(`npm view ${fullName} version 2>/dev/null`, {
       stdio: "pipe",
       timeout: 1e4
     });
@@ -2390,7 +2415,7 @@ function printHelp(): void {
 }
 `;
 }
-function generateReadme(name, displayName, description) {
+function generateReadme(name, description) {
   return `# @locusai/locus-${name}
 
 ${description}
@@ -2545,7 +2570,7 @@ ${bold2("Creating package:")} ${cyan2(fullNpmName)}
   writeFileSync5(join7(packagesDir, "src", "index.ts"), generateIndexTs(name), "utf-8");
   process.stderr.write(`${green("✓")} Generated src/index.ts
 `);
-  writeFileSync5(join7(packagesDir, "README.md"), generateReadme(name, displayName, description), "utf-8");
+  writeFileSync5(join7(packagesDir, "README.md"), generateReadme(name, description), "utf-8");
   process.stderr.write(`${green("✓")} Generated README.md
 `);
   process.stderr.write(`
@@ -3690,7 +3715,7 @@ var init_stream_renderer = __esm(() => {
 });
 
 // src/repl/clipboard.ts
-import { execSync as execSync5 } from "node:child_process";
+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 join11 } from "node:path";
@@ -3729,7 +3754,7 @@ function readMacOSClipboardImage() {
       `return "ok"`
     ].join(`
 `);
-    const result = execSync5("osascript", {
+    const result = execSync6("osascript", {
       input: script,
       encoding: "utf-8",
       timeout: 5000,
@@ -3743,13 +3768,13 @@ function readMacOSClipboardImage() {
 }
 function readLinuxClipboardImage() {
   try {
-    const targets = execSync5("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 = join11(STABLE_DIR, `clipboard-${Date.now()}.png`);
-    execSync5(`xclip -selection clipboard -t image/png -o > "${destPath}" 2>/dev/null`, { timeout: 5000 });
+    execSync6(`xclip -selection clipboard -t image/png -o > "${destPath}" 2>/dev/null`, { timeout: 5000 });
     if (existsSync12(destPath)) {
       return destPath;
     }
@@ -4770,7 +4795,7 @@ __export(exports_claude, {
   buildClaudeArgs: () => buildClaudeArgs,
   ClaudeRunner: () => ClaudeRunner
 });
-import { execSync as execSync6, 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) {
@@ -4788,7 +4813,7 @@ class ClaudeRunner {
   aborted = false;
   async isAvailable() {
     try {
-      execSync6("claude --version", {
+      execSync7("claude --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -4799,7 +4824,7 @@ class ClaudeRunner {
   }
   async getVersion() {
     try {
-      const output = execSync6("claude --version", {
+      const output = execSync7("claude --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -5141,13 +5166,13 @@ function backupIgnoredFiles(projectRoot) {
     }
   };
 }
-async function enforceSandboxIgnore(sandboxName, projectRoot) {
+async function enforceSandboxIgnore(sandboxName, projectRoot, containerWorkdir) {
   const log = getLogger();
   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", {
@@ -5187,11 +5212,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));
@@ -5217,13 +5244,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
@@ -5388,7 +5416,7 @@ var init_claude_sandbox = __esm(() => {
 });
 
 // src/ai/codex.ts
-import { execSync as execSync7, 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) {
@@ -5404,7 +5432,7 @@ class CodexRunner {
   aborted = false;
   async isAvailable() {
     try {
-      execSync7("codex --version", {
+      execSync8("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -5415,7 +5443,7 @@ class CodexRunner {
   }
   async getVersion() {
     try {
-      const output = execSync7("codex --version", {
+      const output = execSync8("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -5567,12 +5595,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;
@@ -5596,19 +5626,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
@@ -5789,12 +5820,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}`);
   }
@@ -5905,7 +5936,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);
     }
@@ -6240,7 +6271,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}
@@ -7443,7 +7475,7 @@ var init_sprint = __esm(() => {
 });
 
 // src/core/prompt-builder.ts
-import { execSync as execSync8 } from "node:child_process";
+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) {
@@ -7592,7 +7624,7 @@ ${parts.join(`
 function buildRepoContext(projectRoot) {
   const parts = [];
   try {
-    const tree = execSync8("find . -maxdepth 2 -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/.locus/*' -not -path '*/dist/*' -not -path '*/build/*' | head -80", { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    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>
 \`\`\`
@@ -7602,7 +7634,7 @@ ${tree}
     }
   } catch {}
   try {
-    const gitLog = execSync8("git log --oneline -10", {
+    const gitLog = execSync9("git log --oneline -10", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7616,7 +7648,7 @@ ${gitLog}
     }
   } catch {}
   try {
-    const branch = execSync8("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync9("git rev-parse --abbrev-ref HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7872,7 +7904,7 @@ var init_diff_renderer = __esm(() => {
 });
 
 // src/repl/commands.ts
-import { execSync as execSync9 } from "node:child_process";
+import { execSync as execSync10 } from "node:child_process";
 function getSlashCommands() {
   return [
     {
@@ -8070,7 +8102,7 @@ function cmdModel(args, ctx) {
 }
 function cmdDiff(_args, ctx) {
   try {
-    const diff = execSync9("git diff", {
+    const diff = execSync10("git diff", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -8106,7 +8138,7 @@ function cmdDiff(_args, ctx) {
 }
 function cmdUndo(_args, ctx) {
   try {
-    const status = execSync9("git status --porcelain", {
+    const status = execSync10("git status --porcelain", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -8116,7 +8148,7 @@ function cmdUndo(_args, ctx) {
 `);
       return;
     }
-    execSync9("git checkout .", {
+    execSync10("git checkout .", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -8494,7 +8526,7 @@ var init_session_manager = __esm(() => {
 });
 
 // src/repl/voice.ts
-import { execSync as execSync10, spawn as spawn6 } from "node:child_process";
+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 join18 } from "node:path";
@@ -8504,7 +8536,7 @@ function getWhisperModelPath() {
 function commandExists(cmd) {
   try {
     const which = platform() === "win32" ? "where" : "which";
-    execSync10(`${which} ${cmd}`, { stdio: "pipe" });
+    execSync11(`${which} ${cmd}`, { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -8630,22 +8662,22 @@ function installSox(pm) {
   try {
     switch (pm) {
       case "brew":
-        execSync10("brew install sox", { stdio: "inherit", timeout: 300000 });
+        execSync11("brew install sox", { stdio: "inherit", timeout: 300000 });
         break;
       case "apt":
-        execSync10("sudo apt-get install -y sox", {
+        execSync11("sudo apt-get install -y sox", {
           stdio: "inherit",
           timeout: 300000
         });
         break;
       case "dnf":
-        execSync10("sudo dnf install -y sox", {
+        execSync11("sudo dnf install -y sox", {
           stdio: "inherit",
           timeout: 300000
         });
         break;
       case "pacman":
-        execSync10("sudo pacman -S --noconfirm sox", {
+        execSync11("sudo pacman -S --noconfirm sox", {
           stdio: "inherit",
           timeout: 300000
         });
@@ -8659,7 +8691,7 @@ function installSox(pm) {
 function installWhisperCpp(pm) {
   if (pm === "brew") {
     try {
-      execSync10("brew install whisper-cpp", {
+      execSync11("brew install whisper-cpp", {
         stdio: "inherit",
         timeout: 300000
       });
@@ -8681,19 +8713,19 @@ function ensureBuildDeps(pm) {
   try {
     switch (pm) {
       case "apt":
-        execSync10("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":
-        execSync10("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":
-        execSync10("sudo pacman -S --noconfirm cmake gcc make git", {
+        execSync11("sudo pacman -S --noconfirm cmake gcc make git", {
           stdio: "inherit",
           timeout: 300000
         });
@@ -8719,17 +8751,17 @@ function buildWhisperFromSource(pm) {
     mkdirSync13(LOCUS_BIN_DIR, { recursive: true });
     out.write(`  ${dim2("Cloning whisper.cpp...")}
 `);
-    execSync10(`git clone --depth 1 https://github.com/ggerganov/whisper.cpp.git "${join18(buildDir, "whisper.cpp")}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
+    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)...")}
 `);
-    execSync10("cmake -B build -DCMAKE_BUILD_TYPE=Release", {
+    execSync11("cmake -B build -DCMAKE_BUILD_TYPE=Release", {
       cwd: srcDir,
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 120000
     });
-    execSync10(`cmake --build build --config Release -j${numCpus}`, {
+    execSync11(`cmake --build build --config Release -j${numCpus}`, {
       cwd: srcDir,
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 600000
@@ -8741,7 +8773,7 @@ function buildWhisperFromSource(pm) {
     ];
     for (const candidate of binaryCandidates) {
       if (existsSync18(candidate)) {
-        execSync10(`cp "${candidate}" "${destPath}" && chmod +x "${destPath}"`, {
+        execSync11(`cp "${candidate}" "${destPath}" && chmod +x "${destPath}"`, {
           stdio: "pipe"
         });
         return true;
@@ -8756,7 +8788,7 @@ function buildWhisperFromSource(pm) {
     return false;
   } finally {
     try {
-      execSync10(`rm -rf "${buildDir}"`, { stdio: "pipe" });
+      execSync11(`rm -rf "${buildDir}"`, { stdio: "pipe" });
     } catch {}
   }
 }
@@ -8827,12 +8859,12 @@ function downloadModel() {
 `);
   try {
     if (commandExists("curl")) {
-      execSync10(`curl -L -o "${modelPath}" "${url}"`, {
+      execSync11(`curl -L -o "${modelPath}" "${url}"`, {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 300000
       });
     } else if (commandExists("wget")) {
-      execSync10(`wget -O "${modelPath}" "${url}"`, {
+      execSync11(`wget -O "${modelPath}" "${url}"`, {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 300000
       });
@@ -9030,7 +9062,7 @@ var init_voice = __esm(() => {
 });
 
 // src/repl/repl.ts
-import { execSync as execSync11 } 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);
@@ -9048,7 +9080,7 @@ async function startRepl(options) {
   } else {
     let branch = "main";
     try {
-      branch = execSync11("git rev-parse --abbrev-ref HEAD", {
+      branch = execSync12("git rev-parse --abbrev-ref HEAD", {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -9100,7 +9132,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 {
@@ -9151,7 +9183,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 {
@@ -9279,6 +9311,7 @@ async function executeAITurn(prompt, session, options, verbose = false, runner)
     verbose,
     sandboxed: config.sandbox.enabled,
     sandboxName,
+    containerWorkdir: config.sandbox.containerWorkdir,
     runner
   });
   if (aiResult.interrupted) {
@@ -9483,7 +9516,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);
@@ -9536,11 +9569,11 @@ var init_exec = __esm(() => {
 });
 
 // src/core/submodule.ts
-import { execSync as execSync12 } from "node:child_process";
+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 execSync12(`git ${args}`, {
+  return execSync13(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -9608,7 +9641,7 @@ function commitDirtySubmodules(cwd, issueNumber, issueTitle) {
       const message = `chore: complete #${issueNumber} - ${issueTitle}
 
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
-      execSync12("git commit -F -", {
+      execSync13("git commit -F -", {
         input: message,
         cwd: sub.absolutePath,
         encoding: "utf-8",
@@ -9695,7 +9728,7 @@ var init_submodule = __esm(() => {
 });
 
 // src/core/agent.ts
-import { execSync as execSync13 } from "node:child_process";
+import { execSync as execSync14 } from "node:child_process";
 async function executeIssue(projectRoot, options) {
   const log = getLogger();
   const timer = createTimer();
@@ -9724,7 +9757,7 @@ ${cyan2("●")} ${bold2(`#${issueNumber}`)} ${issue.title}
   }
   let issueComments = [];
   try {
-    const commentsRaw = execSync13(`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);
@@ -9761,7 +9794,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) {
@@ -9867,7 +9901,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(`
@@ -9888,12 +9923,12 @@ ${aiResult.success ? green("✓") : red2("✗")} Iteration ${aiResult.success ?
 }
 async function createIssuePR(projectRoot, config, issue) {
   try {
-    const currentBranch = execSync13("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 = execSync13(`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"]
@@ -9903,7 +9938,7 @@ async function createIssuePR(projectRoot, config, issue) {
       return;
     }
     pushSubmoduleBranches(projectRoot);
-    execSync13(`git push -u origin ${currentBranch}`, {
+    execSync14(`git push -u origin ${currentBranch}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9958,9 +9993,9 @@ var init_agent = __esm(() => {
 });
 
 // src/core/conflict.ts
-import { execSync as execSync14 } from "node:child_process";
+import { execSync as execSync15 } from "node:child_process";
 function git3(args, cwd) {
-  return execSync14(`git ${args}`, {
+  return execSync15(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -10261,11 +10296,11 @@ var init_shutdown = __esm(() => {
 });
 
 // src/core/worktree.ts
-import { execSync as execSync15 } from "node:child_process";
+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 execSync15(`git ${args}`, {
+  return execSync16(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -10290,7 +10325,7 @@ function generateBranchName(issueNumber) {
 }
 function getWorktreeBranch(worktreePath) {
   try {
-    return execSync15("git branch --show-current", {
+    return execSync16("git branch --show-current", {
       cwd: worktreePath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10417,12 +10452,12 @@ var exports_run = {};
 __export(exports_run, {
   runCommand: () => runCommand
 });
-import { execSync as execSync16 } 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(`
@@ -10577,7 +10612,7 @@ ${yellow2("⚠")} A sprint run is already in progress.
   }
   if (!flags.dryRun) {
     try {
-      execSync16(`git checkout -B ${branchName}`, {
+      execSync17(`git checkout -B ${branchName}`, {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -10627,7 +10662,7 @@ ${red2("✗")} Auto-rebase failed. Resolve manually.
     let sprintContext;
     if (i > 0 && !flags.dryRun) {
       try {
-        sprintContext = execSync16(`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"]
@@ -10648,7 +10683,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) {
@@ -10692,7 +10728,7 @@ ${bold2("Summary:")}
     const prNumber = await createSprintPR(projectRoot, config, sprintName, branchName, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync16(`git checkout ${config.agent.baseBranch}`, {
+        execSync17(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10725,7 +10761,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;
   }
@@ -10737,7 +10774,7 @@ ${bold2("Running issue")} ${cyan2(`#${issueNumber}`)} ${dim2(`(branch: ${branchN
 `);
   if (!flags.dryRun) {
     try {
-      execSync16(`git checkout -B ${branchName} ${config.agent.baseBranch}`, {
+      execSync17(`git checkout -B ${branchName} ${config.agent.baseBranch}`, {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -10762,7 +10799,7 @@ ${bold2("Running issue")} ${cyan2(`#${issueNumber}`)} ${dim2(`(branch: ${branchN
   if (!flags.dryRun) {
     if (result.success) {
       try {
-        execSync16(`git checkout ${config.agent.baseBranch}`, {
+        execSync17(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10833,7 +10870,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);
@@ -10899,13 +10937,13 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}
 `);
   if (state.type === "sprint" && state.branch) {
     try {
-      const currentBranch = execSync16("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) {
-        execSync16(`git checkout ${state.branch}`, {
+        execSync17(`git checkout ${state.branch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -10933,7 +10971,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) {
@@ -10972,7 +11011,7 @@ ${bold2("Resume complete:")} ${green(`✓ ${finalStats.done}`)} ${finalStats.fai
     const prNumber = await createSprintPR(projectRoot, config, state.sprint, state.branch, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync16(`git checkout ${config.agent.baseBranch}`, {
+        execSync17(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -11008,14 +11047,14 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
       process.stderr.write(`  ${dim2(`Committed submodule changes: ${committedSubmodules.join(", ")}`)}
 `);
     }
-    const status = execSync16("git status --porcelain", {
+    const status = execSync17("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!status)
       return;
-    execSync16("git add -A", {
+    execSync17("git add -A", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -11023,7 +11062,7 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
     const message = `chore: complete #${issueNumber} - ${issueTitle}
 
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
-    execSync16(`git commit -F -`, {
+    execSync17(`git commit -F -`, {
       input: message,
       cwd: projectRoot,
       encoding: "utf-8",
@@ -11037,7 +11076,7 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
   if (!config.agent.autoPR)
     return;
   try {
-    const diff = execSync16(`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"]
@@ -11048,7 +11087,7 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
       return;
     }
     pushSubmoduleBranches(projectRoot);
-    execSync16(`git push -u origin ${branchName}`, {
+    execSync17(`git push -u origin ${branchName}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -11467,7 +11506,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(`
@@ -11590,7 +11630,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(`
@@ -11850,7 +11891,7 @@ var exports_review = {};
 __export(exports_review, {
   reviewCommand: () => reviewCommand
 });
-import { execFileSync as execFileSync2, execSync as execSync17 } from "node:child_process";
+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() {
@@ -11936,7 +11977,7 @@ ${bold2("Review complete:")} ${green(`✓ ${reviewed}`)}${failed > 0 ? ` ${red2(
 async function reviewSinglePR(projectRoot, config, prNumber, focus, flags) {
   let prInfo;
   try {
-    const result = execSync17(`gh pr view ${prNumber} --json number,title,body,state,headRefName,baseRefName,labels,url,createdAt`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const 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,
@@ -11981,7 +12022,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.
@@ -12083,7 +12125,7 @@ var exports_iterate = {};
 __export(exports_iterate, {
   iterateCommand: () => iterateCommand
 });
-import { execSync as execSync18 } from "node:child_process";
+import { execSync as execSync19 } from "node:child_process";
 function printHelp4() {
   process.stderr.write(`
 ${bold2("locus iterate")} — Re-execute tasks with PR feedback
@@ -12301,12 +12343,12 @@ ${bold2("Summary:")} ${green(`✓ ${succeeded}`)}${failed > 0 ? ` ${red2(`✗ ${
 }
 function findPRForIssue(projectRoot, issueNumber) {
   try {
-    const result = execSync18(`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 = execSync18(`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;
@@ -12563,7 +12605,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(`
@@ -12936,7 +12979,7 @@ __export(exports_sandbox2, {
   parseSandboxLogsArgs: () => parseSandboxLogsArgs,
   parseSandboxInstallArgs: () => parseSandboxInstallArgs
 });
-import { execSync as execSync19, 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 existsSync26, readFileSync as readFileSync17 } from "node:fs";
 import { basename as basename4, join as join26 } from "node:path";
@@ -13070,11 +13113,26 @@ 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}`)}
+`);
+    }
+  }
+  const workdir = config.sandbox.containerWorkdir ?? projectRoot;
+  const backup = backupIgnoredFiles(projectRoot);
+  try {
+    await enforceSandboxIgnore(name, projectRoot, config.sandbox.containerWorkdir);
+  } finally {
+    backup.restore();
+  }
   readySandboxes[provider] = name;
   config.sandbox.enabled = true;
   config.sandbox.providers = readySandboxes;
   saveConfig(projectRoot, config);
-  await runSandboxSetup(name, projectRoot);
+  await runSandboxSetup(name, projectRoot, workdir);
   process.stderr.write(`
 ${green("✓")} Sandbox mode enabled for ${bold2(provider)}.
 `);
@@ -13099,19 +13157,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();
       }
@@ -13148,7 +13207,7 @@ function handleRemove(projectRoot) {
     process.stderr.write(`Removing sandbox ${bold2(sandboxName)}...
 `);
     try {
-      execSync19(`docker sandbox rm ${sandboxName}`, {
+      execSync20(`docker sandbox rm ${sandboxName}`, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 15000
@@ -13157,6 +13216,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.
 `);
@@ -13169,6 +13229,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)")}
@@ -13305,10 +13369,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", [
@@ -13316,7 +13382,7 @@ async function handleShell(projectRoot, args) {
     "exec",
     "-it",
     "-w",
-    projectRoot,
+    workdir,
     sandboxName,
     "sh"
   ]);
@@ -13429,7 +13495,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) {
@@ -13445,7 +13512,7 @@ Installing dependencies (${bold2(installCmd.join(" "))}) in sandbox ${dim2(sandb
       "sandbox",
       "exec",
       "-w",
-      projectRoot,
+      workdir,
       sandboxName,
       ...installCmd
     ]);
@@ -13462,6 +13529,7 @@ ${dim2(`Detected ${ecosystem} project — skipping JS package install.`)}
 `);
   }
   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)}...
 `);
@@ -13469,10 +13537,10 @@ ${dim2(`Detected ${ecosystem} project — skipping JS package install.`)}
       "sandbox",
       "exec",
       "-w",
-      projectRoot,
+      workdir,
       sandboxName,
       "sh",
-      setupScript
+      containerSetupScript
     ]);
     if (!hookOk) {
       process.stderr.write(`${yellow2("⚠")} Setup hook failed in sandbox ${dim2(sandboxName)}.
@@ -13503,7 +13571,7 @@ async function handleSetup(projectRoot) {
 `);
       continue;
     }
-    await runSandboxSetup(sandboxName, projectRoot);
+    await runSandboxSetup(sandboxName, projectRoot, config.sandbox.containerWorkdir);
   }
 }
 function buildProviderSandboxNames(projectRoot) {
@@ -13550,7 +13618,7 @@ function runInteractiveCommand(command, args) {
 }
 async function createProviderSandbox(provider, sandboxName, projectRoot) {
   try {
-    execSync19(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
+    execSync20(`docker sandbox create --name ${sandboxName} claude ${projectRoot}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 120000
     });
@@ -13561,17 +13629,11 @@ async function createProviderSandbox(provider, sandboxName, projectRoot) {
   if (provider === "codex") {
     await ensureCodexInSandbox(sandboxName);
   }
-  const backup = backupIgnoredFiles(projectRoot);
-  try {
-    await enforceSandboxIgnore(sandboxName, projectRoot);
-  } finally {
-    backup.restore();
-  }
   return true;
 }
 async function ensurePackageManagerInSandbox(sandboxName, pm) {
   try {
-    execSync19(`docker sandbox exec ${sandboxName} which ${pm}`, {
+    execSync20(`docker sandbox exec ${sandboxName} which ${pm}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -13580,7 +13642,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
     process.stderr.write(`Installing ${bold2(pm)} in sandbox...
 `);
     try {
-      execSync19(`docker sandbox exec ${sandboxName} npm install -g ${npmPkg}`, {
+      execSync20(`docker sandbox exec ${sandboxName} npm install -g ${npmPkg}`, {
         stdio: "inherit",
         timeout: 120000
       });
@@ -13592,7 +13654,7 @@ async function ensurePackageManagerInSandbox(sandboxName, pm) {
 }
 async function ensureCodexInSandbox(sandboxName) {
   try {
-    execSync19(`docker sandbox exec ${sandboxName} which codex`, {
+    execSync20(`docker sandbox exec ${sandboxName} which codex`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -13600,7 +13662,7 @@ async function ensureCodexInSandbox(sandboxName) {
     process.stderr.write(`Installing codex in sandbox...
 `);
     try {
-      execSync19(`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.
 `);
@@ -13609,7 +13671,7 @@ async function ensureCodexInSandbox(sandboxName) {
 }
 function isSandboxAlive(name) {
   try {
-    const output = execSync19("docker sandbox ls", {
+    const output = execSync20("docker sandbox ls", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@locusai/cli",
-  "version": "0.22.1",
+  "version": "0.22.3",
   "description": "GitHub-native AI engineering assistant",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
   "license": "MIT",
   "dependencies": {},
   "devDependencies": {
-    "@locusai/sdk": "^0.22.1",
+    "@locusai/sdk": "^0.22.3",
     "@types/bun": "latest",
     "typescript": "^5.8.3"
   },