@locusai/cli 0.18.2 → 0.19.1

package/bin/locus.js

@@ -62,6 +62,143 @@ var init_ai_models = __esm(() => {
   ALL_MODEL_SET = new Set([...CLAUDE_MODELS, ...CODEX_MODELS]);
 });
 
+// src/core/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+function getConfigPath(projectRoot) {
+  return join(projectRoot, ".locus", "config.json");
+}
+function loadConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  if (!existsSync(configPath)) {
+    throw new Error(`No Locus config found at ${configPath}. Run "locus init" first.`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (e) {
+    throw new Error(`Failed to parse config at ${configPath}: ${e}`);
+  }
+  const config = deepMerge(DEFAULT_CONFIG, raw);
+  const inferredProvider = inferProviderFromModel(config.ai.model);
+  if (inferredProvider) {
+    config.ai.provider = inferredProvider;
+  }
+  if (raw.version !== config.version) {
+    saveConfig(projectRoot, config);
+  }
+  return config;
+}
+function saveConfig(projectRoot, config) {
+  const configPath = getConfigPath(projectRoot);
+  const dir = dirname(configPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+}
+function updateConfigValue(projectRoot, path, value) {
+  const config = loadConfig(projectRoot);
+  setNestedValue(config, path, value);
+  if (path === "ai.model" && typeof value === "string") {
+    const inferredProvider = inferProviderFromModel(value);
+    if (inferredProvider) {
+      config.ai.provider = inferredProvider;
+    }
+  }
+  saveConfig(projectRoot, config);
+  return config;
+}
+function isInitialized(projectRoot) {
+  return existsSync(join(projectRoot, ".locus", "config.json"));
+}
+function deepMerge(target, source) {
+  if (typeof target !== "object" || target === null || typeof source !== "object" || source === null) {
+    return source ?? target;
+  }
+  const result = {
+    ...target
+  };
+  const src = source;
+  for (const key of Object.keys(src)) {
+    if (key in result && typeof result[key] === "object" && result[key] !== null && typeof src[key] === "object" && src[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(result[key], src[key]);
+    } else if (src[key] !== undefined) {
+      result[key] = src[key];
+    }
+  }
+  return result;
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0;i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  let coerced = value;
+  if (value === "true")
+    coerced = true;
+  else if (value === "false")
+    coerced = false;
+  else if (typeof value === "string" && /^\d+$/.test(value))
+    coerced = Number.parseInt(value, 10);
+  current[lastKey] = coerced;
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null)
+      return;
+    current = current[key];
+  }
+  return current;
+}
+var DEFAULT_CONFIG;
+var init_config = __esm(() => {
+  init_ai_models();
+  DEFAULT_CONFIG = {
+    version: "3.2.0",
+    github: {
+      owner: "",
+      repo: "",
+      defaultBranch: "main"
+    },
+    ai: {
+      provider: "claude",
+      model: "claude-sonnet-4-6"
+    },
+    agent: {
+      maxParallel: 3,
+      autoLabel: true,
+      autoPR: true,
+      baseBranch: "main",
+      rebaseBeforeTask: true
+    },
+    sprint: {
+      active: null,
+      stopOnFailure: true
+    },
+    logging: {
+      level: "normal",
+      maxFiles: 20,
+      maxTotalSizeMB: 50
+    },
+    sandbox: {
+      enabled: true,
+      providers: {},
+      extraWorkspaces: [],
+      readOnlyPaths: []
+    }
+  };
+});
+
 // src/display/terminal.ts
 function getCapabilities() {
   if (cachedCapabilities)
@@ -183,13 +320,13 @@ var init_terminal = __esm(() => {
 // src/core/logger.ts
 import {
   appendFileSync,
-  existsSync,
-  mkdirSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
   readdirSync,
   statSync,
   unlinkSync
 } from "node:fs";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 function redactSensitive(text) {
   let result = text;
   for (const pattern of SENSITIVE_PATTERNS) {
@@ -219,11 +356,11 @@ class Logger {
   initLogFile() {
     if (!this.logDir)
       return;
-    if (!existsSync(this.logDir)) {
-      mkdirSync(this.logDir, { recursive: true });
+    if (!existsSync2(this.logDir)) {
+      mkdirSync2(this.logDir, { recursive: true });
     }
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    this.logFile = join(this.logDir, `locus-${timestamp}.log`);
+    this.logFile = join2(this.logDir, `locus-${timestamp}.log`);
     this.pruneOldLogs();
   }
   startFlushTimer() {
@@ -318,14 +455,14 @@ class Logger {
     }
   }
   pruneOldLogs() {
-    if (!this.logDir || !existsSync(this.logDir))
+    if (!this.logDir || !existsSync2(this.logDir))
       return;
     try {
       const logDir = this.logDir;
       const files = readdirSync(logDir).filter((f) => f.startsWith("locus-") && f.endsWith(".log")).map((f) => ({
         name: f,
-        path: join(logDir, f),
-        stat: statSync(join(logDir, f))
+        path: join2(logDir, f),
+        stat: statSync(join2(logDir, f))
       })).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
       while (files.length > this.maxFiles) {
         const oldest = files.pop();
@@ -405,258 +542,92 @@ var init_logger = __esm(() => {
   ];
 });
 
-// src/core/config.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
-function applyMigrations(config) {
-  const currentVersion = config.version ?? "3.0.0";
-  let migrated = { ...config };
-  let version = currentVersion;
-  for (const migration of migrations) {
-    if (version.startsWith(migration.from)) {
-      migrated = migration.migrate(migrated);
-      version = migration.to;
-      getLogger().info(`Migrated config from ${migration.from} → ${migration.to}`);
+// src/core/context.ts
+import { execSync } from "node:child_process";
+function detectRepoContext(cwd) {
+  const log = getLogger();
+  const remoteUrl = git("config --get remote.origin.url", cwd).trim();
+  if (!remoteUrl) {
+    throw new Error("No git remote 'origin' found. Add a GitHub remote: git remote add origin <url>");
+  }
+  log.verbose("Detected remote URL", { remoteUrl });
+  const { owner, repo } = parseRemoteUrl(remoteUrl);
+  if (!owner || !repo) {
+    throw new Error(`Could not parse owner/repo from remote URL: ${remoteUrl}`);
+  }
+  const currentBranch = git("rev-parse --abbrev-ref HEAD", cwd).trim();
+  let defaultBranch = "main";
+  try {
+    const ghOutput = execSync("gh repo view --json defaultBranchRef --jq .defaultBranchRef.name", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (ghOutput) {
+      defaultBranch = ghOutput;
+    }
+  } catch {
+    try {
+      const remoteHead = git("symbolic-ref refs/remotes/origin/HEAD", cwd).trim().replace("refs/remotes/origin/", "");
+      if (remoteHead) {
+        defaultBranch = remoteHead;
+      }
+    } catch {
+      log.verbose("Could not detect default branch, using 'main'");
     }
   }
-  return migrated;
+  log.verbose("Repository context", {
+    owner,
+    repo,
+    defaultBranch,
+    currentBranch
+  });
+  return { owner, repo, defaultBranch, currentBranch, remoteUrl };
 }
-function getConfigPath(projectRoot) {
-  return join2(projectRoot, ".locus", "config.json");
+function parseRemoteUrl(url) {
+  let match = url.match(/git@github\.com:([^/]+)\/([^/.]+)/);
+  if (match)
+    return { owner: match[1], repo: match[2] };
+  match = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
+  if (match)
+    return { owner: match[1], repo: match[2] };
+  match = url.match(/^([^/]+)\/([^/.]+)$/);
+  if (match)
+    return { owner: match[1], repo: match[2] };
+  return { owner: "", repo: "" };
 }
-function loadConfig(projectRoot) {
-  const configPath = getConfigPath(projectRoot);
-  if (!existsSync2(configPath)) {
-    throw new Error(`No Locus config found at ${configPath}. Run "locus init" first.`);
-  }
-  let raw;
+function isGitRepo(cwd) {
   try {
-    raw = JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch (e) {
-    throw new Error(`Failed to parse config at ${configPath}: ${e}`);
-  }
-  const migrated = applyMigrations(raw);
-  const config = deepMerge(DEFAULT_CONFIG, migrated);
-  const inferredProvider = inferProviderFromModel(config.ai.model);
-  if (inferredProvider) {
-    config.ai.provider = inferredProvider;
-  }
-  if (raw.version !== config.version) {
-    saveConfig(projectRoot, config);
+    git("rev-parse --git-dir", cwd);
+    return true;
+  } catch {
+    return false;
   }
-  return config;
 }
-function saveConfig(projectRoot, config) {
-  const configPath = getConfigPath(projectRoot);
-  const dir = dirname(configPath);
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+function checkGhCli() {
+  try {
+    execSync("gh --version", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return { installed: false, authenticated: false };
   }
-  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
-`, "utf-8");
-}
-function updateConfigValue(projectRoot, path, value) {
-  const config = loadConfig(projectRoot);
-  setNestedValue(config, path, value);
-  if (path === "ai.model" && typeof value === "string") {
-    const inferredProvider = inferProviderFromModel(value);
-    if (inferredProvider) {
-      config.ai.provider = inferredProvider;
-    }
+  try {
+    execSync("gh auth status", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { installed: true, authenticated: true };
+  } catch {
+    return { installed: true, authenticated: false };
   }
-  saveConfig(projectRoot, config);
-  return config;
 }
-function isInitialized(projectRoot) {
-  return existsSync2(join2(projectRoot, ".locus", "config.json"));
+function getGitRoot(cwd) {
+  return git("rev-parse --show-toplevel", cwd).trim();
 }
-function deepMerge(target, source) {
-  if (typeof target !== "object" || target === null || typeof source !== "object" || source === null) {
-    return source ?? target;
-  }
-  const result = {
-    ...target
-  };
-  const src = source;
-  for (const key of Object.keys(src)) {
-    if (key in result && typeof result[key] === "object" && result[key] !== null && typeof src[key] === "object" && src[key] !== null && !Array.isArray(result[key])) {
-      result[key] = deepMerge(result[key], src[key]);
-    } else if (src[key] !== undefined) {
-      result[key] = src[key];
-    }
-  }
-  return result;
-}
-function setNestedValue(obj, path, value) {
-  const keys = path.split(".");
-  let current = obj;
-  for (let i = 0;i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (typeof current[key] !== "object" || current[key] === null) {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-  const lastKey = keys[keys.length - 1];
-  let coerced = value;
-  if (value === "true")
-    coerced = true;
-  else if (value === "false")
-    coerced = false;
-  else if (typeof value === "string" && /^\d+$/.test(value))
-    coerced = Number.parseInt(value, 10);
-  current[lastKey] = coerced;
-}
-function getNestedValue(obj, path) {
-  const keys = path.split(".");
-  let current = obj;
-  for (const key of keys) {
-    if (typeof current !== "object" || current === null)
-      return;
-    current = current[key];
-  }
-  return current;
-}
-var DEFAULT_CONFIG, migrations;
-var init_config = __esm(() => {
-  init_ai_models();
-  init_logger();
-  DEFAULT_CONFIG = {
-    version: "3.1.0",
-    github: {
-      owner: "",
-      repo: "",
-      defaultBranch: "main"
-    },
-    ai: {
-      provider: "claude",
-      model: "claude-sonnet-4-6"
-    },
-    agent: {
-      maxParallel: 3,
-      autoLabel: true,
-      autoPR: true,
-      baseBranch: "main",
-      rebaseBeforeTask: true
-    },
-    sprint: {
-      active: null,
-      stopOnFailure: true
-    },
-    logging: {
-      level: "normal",
-      maxFiles: 20,
-      maxTotalSizeMB: 50
-    },
-    sandbox: {
-      enabled: true,
-      extraWorkspaces: [],
-      readOnlyPaths: []
-    }
-  };
-  migrations = [
-    {
-      from: "3.0",
-      to: "3.1.0",
-      migrate: (config) => {
-        config.sandbox ??= {
-          enabled: true,
-          extraWorkspaces: [],
-          readOnlyPaths: []
-        };
-        config.version = "3.1.0";
-        return config;
-      }
-    }
-  ];
-});
-
-// src/core/context.ts
-import { execSync } from "node:child_process";
-function detectRepoContext(cwd) {
-  const log = getLogger();
-  const remoteUrl = git("config --get remote.origin.url", cwd).trim();
-  if (!remoteUrl) {
-    throw new Error("No git remote 'origin' found. Add a GitHub remote: git remote add origin <url>");
-  }
-  log.verbose("Detected remote URL", { remoteUrl });
-  const { owner, repo } = parseRemoteUrl(remoteUrl);
-  if (!owner || !repo) {
-    throw new Error(`Could not parse owner/repo from remote URL: ${remoteUrl}`);
-  }
-  const currentBranch = git("rev-parse --abbrev-ref HEAD", cwd).trim();
-  let defaultBranch = "main";
-  try {
-    const ghOutput = execSync("gh repo view --json defaultBranchRef --jq .defaultBranchRef.name", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (ghOutput) {
-      defaultBranch = ghOutput;
-    }
-  } catch {
-    try {
-      const remoteHead = git("symbolic-ref refs/remotes/origin/HEAD", cwd).trim().replace("refs/remotes/origin/", "");
-      if (remoteHead) {
-        defaultBranch = remoteHead;
-      }
-    } catch {
-      log.verbose("Could not detect default branch, using 'main'");
-    }
-  }
-  log.verbose("Repository context", {
-    owner,
-    repo,
-    defaultBranch,
-    currentBranch
-  });
-  return { owner, repo, defaultBranch, currentBranch, remoteUrl };
-}
-function parseRemoteUrl(url) {
-  let match = url.match(/git@github\.com:([^/]+)\/([^/.]+)/);
-  if (match)
-    return { owner: match[1], repo: match[2] };
-  match = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
-  if (match)
-    return { owner: match[1], repo: match[2] };
-  match = url.match(/^([^/]+)\/([^/.]+)$/);
-  if (match)
-    return { owner: match[1], repo: match[2] };
-  return { owner: "", repo: "" };
-}
-function isGitRepo(cwd) {
-  try {
-    git("rev-parse --git-dir", cwd);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function checkGhCli() {
-  try {
-    execSync("gh --version", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-    return { installed: false, authenticated: false };
-  }
-  try {
-    execSync("gh auth status", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return { installed: true, authenticated: true };
-  } catch {
-    return { installed: true, authenticated: false };
-  }
-}
-function getGitRoot(cwd) {
-  return git("rev-parse --show-toplevel", cwd).trim();
-}
-function git(args, cwd) {
-  return execSync(`git ${args}`, {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
+function git(args, cwd) {
+  return execSync(`git ${args}`, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
 }
 var init_context = __esm(() => {
   init_logger();
@@ -915,11 +886,20 @@ var init_progress = __esm(() => {
 var exports_sandbox = {};
 __export(exports_sandbox, {
   resolveSandboxMode: () => resolveSandboxMode,
+  getProviderSandboxName: () => getProviderSandboxName,
+  getModelSandboxName: () => getModelSandboxName,
   displaySandboxWarning: () => displaySandboxWarning,
   detectSandboxSupport: () => detectSandboxSupport
 });
 import { execFile } from "node:child_process";
 import { createInterface } from "node:readline";
+function getProviderSandboxName(config, provider) {
+  return config.providers[provider];
+}
+function getModelSandboxName(config, model, fallbackProvider) {
+  const provider = inferProviderFromModel(model) ?? fallbackProvider;
+  return getProviderSandboxName(config, provider);
+}
 async function detectSandboxSupport() {
   if (cachedStatus)
     return cachedStatus;
@@ -1051,6 +1031,7 @@ function waitForEnter() {
 var TIMEOUT_MS = 5000, cachedStatus = null;
 var init_sandbox = __esm(() => {
   init_terminal();
+  init_ai_models();
   init_logger();
 });
 
@@ -1816,14 +1797,13 @@ ${bold("Sandbox mode")} ${dim("(recommended)")}
   process.stderr.write(`  Run AI agents in an isolated Docker sandbox for safety.
 
 `);
-  process.stderr.write(`  ${gray("1.")} ${cyan("locus sandbox")}          ${dim("Create the sandbox environment")}
+  process.stderr.write(`  ${gray("1.")} ${cyan("locus sandbox")}          ${dim("Create claude/codex sandboxes")}
 `);
   process.stderr.write(`  ${gray("2.")} ${cyan("locus sandbox claude")}   ${dim("Login to Claude inside the sandbox")}
 `);
-  process.stderr.write(`  ${gray("3.")} ${cyan("locus exec")}             ${dim("All commands now run sandboxed")}
+  process.stderr.write(`  ${gray("3.")} ${cyan("locus sandbox codex")}    ${dim("Login to Codex inside the sandbox")}
 `);
-  process.stderr.write(`
-  ${dim("Using Codex? Run")} ${cyan("locus sandbox codex")} ${dim("instead of step 2.")}
+  process.stderr.write(`  ${gray("4.")} ${cyan("locus exec")}             ${dim("All commands now run sandboxed")}
 `);
   process.stderr.write(`  ${dim("Learn more:")} ${cyan("locus sandbox help")}
 `);
@@ -4402,449 +4382,161 @@ var init_sandbox_ignore = __esm(() => {
   execAsync = promisify(exec);
 });
 
-// src/core/run-state.ts
-import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync9,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync6
-} from "node:fs";
-import { dirname as dirname3, join as join12 } from "node:path";
-function getRunStatePath(projectRoot) {
-  return join12(projectRoot, ".locus", "run-state.json");
-}
-function loadRunState(projectRoot) {
-  const path = getRunStatePath(projectRoot);
-  if (!existsSync13(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync9(path, "utf-8"));
-  } catch {
-    getLogger().warn("Corrupted run-state.json, ignoring");
-    return null;
-  }
-}
-function saveRunState(projectRoot, state) {
-  const path = getRunStatePath(projectRoot);
-  const dir = dirname3(path);
-  if (!existsSync13(dir)) {
-    mkdirSync9(dir, { recursive: true });
-  }
-  writeFileSync6(path, `${JSON.stringify(state, null, 2)}
-`, "utf-8");
-}
-function clearRunState(projectRoot) {
-  const path = getRunStatePath(projectRoot);
-  if (existsSync13(path)) {
-    unlinkSync3(path);
-  }
-}
-function createSprintRunState(sprint, branch, issues) {
-  return {
-    runId: `run-${new Date().toISOString().slice(0, 19).replace(/[:.]/g, "-")}`,
-    type: "sprint",
-    sprint,
-    branch,
-    startedAt: new Date().toISOString(),
-    tasks: issues.map(({ number, order }) => ({
-      issue: number,
-      order,
-      status: "pending"
-    }))
-  };
-}
-function createParallelRunState(issueNumbers) {
-  return {
-    runId: `run-${new Date().toISOString().slice(0, 19).replace(/[:.]/g, "-")}`,
-    type: "parallel",
-    startedAt: new Date().toISOString(),
-    tasks: issueNumbers.map((issue, i) => ({
-      issue,
-      order: i + 1,
-      status: "pending"
-    }))
-  };
-}
-function markTaskInProgress(state, issueNumber) {
-  const task = state.tasks.find((t) => t.issue === issueNumber);
-  if (task) {
-    task.status = "in_progress";
+// src/ai/claude-sandbox.ts
+import { spawn as spawn3 } from "node:child_process";
+
+class SandboxedClaudeRunner {
+  sandboxName;
+  name = "claude-sandboxed";
+  process = null;
+  aborted = false;
+  constructor(sandboxName) {
+    this.sandboxName = sandboxName;
   }
-}
-function markTaskDone(state, issueNumber, prNumber) {
-  const task = state.tasks.find((t) => t.issue === issueNumber);
-  if (task) {
-    task.status = "done";
-    task.completedAt = new Date().toISOString();
-    if (prNumber)
-      task.pr = prNumber;
+  async isAvailable() {
+    const { ClaudeRunner: ClaudeRunner2 } = await Promise.resolve().then(() => (init_claude(), exports_claude));
+    const delegate = new ClaudeRunner2;
+    return delegate.isAvailable();
   }
-}
-function markTaskFailed(state, issueNumber, error) {
-  const task = state.tasks.find((t) => t.issue === issueNumber);
-  if (task) {
-    task.status = "failed";
-    task.failedAt = new Date().toISOString();
-    task.error = error;
-  }
-}
-function getRunStats(state) {
-  const tasks = state.tasks;
-  return {
-    total: tasks.length,
-    done: tasks.filter((t) => t.status === "done").length,
-    failed: tasks.filter((t) => t.status === "failed").length,
-    pending: tasks.filter((t) => t.status === "pending").length,
-    inProgress: tasks.filter((t) => t.status === "in_progress").length
-  };
-}
-function getNextTask(state) {
-  const failed = state.tasks.find((t) => t.status === "failed");
-  if (failed)
-    return failed;
-  return state.tasks.find((t) => t.status === "pending") ?? null;
-}
-var init_run_state = __esm(() => {
-  init_logger();
-});
-
-// src/core/shutdown.ts
-import { execSync as execSync6 } from "node:child_process";
-function registerActiveSandbox(name) {
-  activeSandboxes.add(name);
-}
-function unregisterActiveSandbox(name) {
-  activeSandboxes.delete(name);
-}
-function cleanupActiveSandboxes() {
-  for (const name of activeSandboxes) {
-    try {
-      execSync6(`docker sandbox rm ${name}`, { timeout: 1e4 });
-    } catch {}
-  }
-  activeSandboxes.clear();
-}
-function registerShutdownHandlers(ctx) {
-  shutdownContext = ctx;
-  interruptCount = 0;
-  const handler = () => {
-    interruptCount++;
-    if (interruptCount >= 2) {
-      process.stderr.write(`
-Force exit.
-`);
-      process.exit(1);
-    }
-    process.stderr.write(`
-
-Interrupted. Saving state...
-`);
-    const state = shutdownContext?.getRunState?.();
-    if (state && shutdownContext) {
-      for (const task of state.tasks) {
-        if (task.status === "in_progress") {
-          task.status = "failed";
-          task.failedAt = new Date().toISOString();
-          task.error = "Interrupted by user";
-        }
-      }
-      try {
-        saveRunState(shutdownContext.projectRoot, state);
-        process.stderr.write(`State saved. Resume with: locus run --resume
-`);
-      } catch {
-        process.stderr.write(`Warning: Could not save run state.
-`);
-      }
-    }
-    cleanupActiveSandboxes();
-    shutdownContext?.onShutdown?.();
-    if (interruptTimer)
-      clearTimeout(interruptTimer);
-    interruptTimer = setTimeout(() => {
-      interruptCount = 0;
-    }, 2000);
-    setTimeout(() => {
-      process.exit(130);
-    }, 100);
-  };
-  if (!shutdownRegistered) {
-    process.on("SIGINT", handler);
-    process.on("SIGTERM", handler);
-    shutdownRegistered = true;
-  }
-  return () => {
-    process.removeListener("SIGINT", handler);
-    process.removeListener("SIGTERM", handler);
-    shutdownRegistered = false;
-    shutdownContext = null;
-    interruptCount = 0;
-    if (interruptTimer) {
-      clearTimeout(interruptTimer);
-      interruptTimer = null;
-    }
-  };
-}
-var shutdownRegistered = false, shutdownContext = null, interruptCount = 0, interruptTimer = null, activeSandboxes;
-var init_shutdown = __esm(() => {
-  init_run_state();
-  activeSandboxes = new Set;
-});
-
-// src/ai/claude-sandbox.ts
-import { execSync as execSync7, spawn as spawn3 } from "node:child_process";
-
-class SandboxedClaudeRunner {
-  name = "claude-sandboxed";
-  process = null;
-  aborted = false;
-  sandboxName = null;
-  persistent;
-  sandboxCreated = false;
-  userManaged = false;
-  constructor(persistentName, userManaged = false) {
-    if (persistentName) {
-      this.persistent = true;
-      this.sandboxName = persistentName;
-      this.userManaged = userManaged;
-      if (userManaged) {
-        this.sandboxCreated = true;
-      }
-    } else {
-      this.persistent = false;
-    }
-  }
-  async isAvailable() {
-    const { ClaudeRunner: ClaudeRunner2 } = await Promise.resolve().then(() => (init_claude(), exports_claude));
-    const delegate = new ClaudeRunner2;
-    return delegate.isAvailable();
-  }
-  async getVersion() {
-    const { ClaudeRunner: ClaudeRunner2 } = await Promise.resolve().then(() => (init_claude(), exports_claude));
-    const delegate = new ClaudeRunner2;
-    return delegate.getVersion();
+  async getVersion() {
+    const { ClaudeRunner: ClaudeRunner2 } = await Promise.resolve().then(() => (init_claude(), exports_claude));
+    const delegate = new ClaudeRunner2;
+    return delegate.getVersion();
   }
   async execute(options) {
     const log = getLogger();
     this.aborted = false;
-    const claudeArgs = ["-p", options.prompt, ...buildClaudeArgs(options)];
-    let dockerArgs;
-    if (this.persistent && !this.sandboxName) {
-      throw new Error("Sandbox name is required");
-    }
-    if (this.persistent && this.sandboxCreated && await this.isSandboxRunning()) {
-      const name = this.sandboxName;
-      if (!name) {
-        throw new Error("Sandbox name is required");
-      }
-      options.onStatusChange?.("Syncing sandbox...");
-      await enforceSandboxIgnore(name, options.cwd);
-      options.onStatusChange?.("Thinking...");
-      dockerArgs = [
-        "sandbox",
-        "exec",
-        "-w",
-        options.cwd,
-        name,
-        "claude",
-        ...claudeArgs
-      ];
-    } else {
-      if (!this.persistent) {
-        this.sandboxName = buildSandboxName(options);
-      }
-      const name = this.sandboxName;
-      if (!name) {
-        throw new Error("Sandbox name is required");
-      }
-      registerActiveSandbox(name);
-      options.onStatusChange?.("Syncing sandbox...");
-      dockerArgs = [
-        "sandbox",
-        "run",
-        "--name",
-        name,
-        "claude",
-        options.cwd,
-        "--",
-        ...claudeArgs
-      ];
+    if (!await this.isSandboxRunning()) {
+      return {
+        success: false,
+        output: "",
+        error: `Sandbox is not running: ${this.sandboxName}`,
+        exitCode: 1
+      };
     }
+    const claudeArgs = ["-p", options.prompt, ...buildClaudeArgs(options)];
+    options.onStatusChange?.("Syncing sandbox...");
+    await enforceSandboxIgnore(this.sandboxName, options.cwd);
+    options.onStatusChange?.("Thinking...");
+    const dockerArgs = [
+      "sandbox",
+      "exec",
+      "-w",
+      options.cwd,
+      this.sandboxName,
+      "claude",
+      ...claudeArgs
+    ];
     log.debug("Spawning sandboxed claude", {
       sandboxName: this.sandboxName,
-      persistent: this.persistent,
-      reusing: this.persistent && this.sandboxCreated,
       args: dockerArgs.join(" "),
       cwd: options.cwd
     });
-    try {
-      return await new Promise((resolve2) => {
-        let output = "";
-        let errorOutput = "";
-        this.process = spawn3("docker", dockerArgs, {
-          stdio: ["ignore", "pipe", "pipe"],
-          env: process.env
-        });
-        if (this.persistent && !this.sandboxCreated) {
-          this.process.on("spawn", () => {
-            this.sandboxCreated = true;
-          });
-        }
-        if (options.verbose) {
-          let lineBuffer = "";
-          const seenToolIds = new Set;
-          this.process.stdout?.on("data", (chunk) => {
-            lineBuffer += chunk.toString();
-            const lines = lineBuffer.split(`
-`);
-            lineBuffer = lines.pop() ?? "";
-            for (const line of lines) {
-              if (!line.trim())
-                continue;
-              try {
-                const event = JSON.parse(line);
-                if (event.type === "assistant" && event.message?.content) {
-                  for (const item of event.message.content) {
-                    if (item.type === "tool_use" && item.id && !seenToolIds.has(item.id)) {
-                      seenToolIds.add(item.id);
-                      options.onToolActivity?.(formatToolCall2(item.name ?? "", item.input ?? {}));
-                    }
+    return await new Promise((resolve2) => {
+      let output = "";
+      let errorOutput = "";
+      this.process = spawn3("docker", dockerArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env
+      });
+      if (options.verbose) {
+        let lineBuffer = "";
+        const seenToolIds = new Set;
+        this.process.stdout?.on("data", (chunk) => {
+          lineBuffer += chunk.toString();
+          const lines = lineBuffer.split(`
+`);
+          lineBuffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (!line.trim())
+              continue;
+            try {
+              const event = JSON.parse(line);
+              if (event.type === "assistant" && event.message?.content) {
+                for (const item of event.message.content) {
+                  if (item.type === "tool_use" && item.id && !seenToolIds.has(item.id)) {
+                    seenToolIds.add(item.id);
+                    options.onToolActivity?.(formatToolCall2(item.name ?? "", item.input ?? {}));
                   }
-                } else if (event.type === "result") {
-                  const text = event.result ?? "";
-                  output = text;
-                  options.onOutput?.(text);
                 }
-              } catch {
-                const newLine = `${line}
-`;
-                output += newLine;
-                options.onOutput?.(newLine);
+              } else if (event.type === "result") {
+                const text = event.result ?? "";
+                output = text;
+                options.onOutput?.(text);
               }
+            } catch {
+              const newLine = `${line}
+`;
+              output += newLine;
+              options.onOutput?.(newLine);
             }
-          });
-        } else {
-          this.process.stdout?.on("data", (chunk) => {
-            const text = chunk.toString();
-            output += text;
-            options.onOutput?.(text);
-          });
-        }
-        this.process.stderr?.on("data", (chunk) => {
+          }
+        });
+      } else {
+        this.process.stdout?.on("data", (chunk) => {
           const text = chunk.toString();
-          errorOutput += text;
-          log.debug("sandboxed claude stderr", { text: text.slice(0, 500) });
+          output += text;
           options.onOutput?.(text);
         });
-        this.process.on("close", (code) => {
-          this.process = null;
-          if (this.aborted) {
-            resolve2({
-              success: false,
-              output,
-              error: "Aborted by user",
-              exitCode: code ?? 143
-            });
-            return;
-          }
-          if (code === 0) {
-            resolve2({
-              success: true,
-              output,
-              exitCode: 0
-            });
-          } else {
-            resolve2({
-              success: false,
-              output,
-              error: errorOutput || `sandboxed claude exited with code ${code}`,
-              exitCode: code ?? 1
-            });
-          }
-        });
-        this.process.on("error", (err) => {
-          this.process = null;
-          if (this.persistent && !this.sandboxCreated) {}
+      }
+      this.process.stderr?.on("data", (chunk) => {
+        const text = chunk.toString();
+        errorOutput += text;
+        log.debug("sandboxed claude stderr", { text: text.slice(0, 500) });
+        options.onOutput?.(text);
+      });
+      this.process.on("close", (code) => {
+        this.process = null;
+        if (this.aborted) {
           resolve2({
             success: false,
             output,
-            error: `Failed to spawn docker sandbox: ${err.message}`,
-            exitCode: 1
+            error: "Aborted by user",
+            exitCode: code ?? 143
           });
-        });
-        if (options.signal) {
-          options.signal.addEventListener("abort", () => {
-            this.abort();
+          return;
+        }
+        if (code === 0) {
+          resolve2({ success: true, output, exitCode: 0 });
+        } else {
+          resolve2({
+            success: false,
+            output,
+            error: errorOutput || `sandboxed claude exited with code ${code}`,
+            exitCode: code ?? 1
           });
         }
       });
-    } finally {
-      if (!this.persistent) {
-        this.cleanupSandbox();
+      this.process.on("error", (err) => {
+        this.process = null;
+        resolve2({
+          success: false,
+          output,
+          error: `Failed to spawn docker sandbox: ${err.message}`,
+          exitCode: 1
+        });
+      });
+      if (options.signal) {
+        options.signal.addEventListener("abort", () => {
+          this.abort();
+        });
       }
-    }
+    });
   }
   abort() {
     this.aborted = true;
-    const log = getLogger();
-    if (this.persistent) {
-      log.debug("Aborting sandboxed claude (persistent — keeping sandbox)", {
-        sandboxName: this.sandboxName
-      });
+    if (!this.process)
+      return;
+    this.process.kill("SIGTERM");
+    const timer = setTimeout(() => {
       if (this.process) {
-        this.process.kill("SIGTERM");
-        const timer = setTimeout(() => {
-          if (this.process) {
-            this.process.kill("SIGKILL");
-          }
-        }, 3000);
-        if (timer.unref)
-          timer.unref();
+        this.process.kill("SIGKILL");
       }
-    } else {
-      if (!this.sandboxName)
-        return;
-      log.debug("Aborting sandboxed claude (ephemeral — removing sandbox)", {
-        sandboxName: this.sandboxName
-      });
-      try {
-        execSync7(`docker sandbox rm ${this.sandboxName}`, { timeout: 60000 });
-      } catch {}
-    }
-  }
-  destroy() {
-    if (!this.sandboxName)
-      return;
-    if (this.userManaged) {
-      unregisterActiveSandbox(this.sandboxName);
-      return;
-    }
-    const log = getLogger();
-    log.debug("Destroying sandbox", { sandboxName: this.sandboxName });
-    try {
-      execSync7(`docker sandbox rm ${this.sandboxName}`, { timeout: 60000 });
-    } catch {}
-    unregisterActiveSandbox(this.sandboxName);
-    this.sandboxName = null;
-    this.sandboxCreated = false;
-  }
-  cleanupSandbox() {
-    if (!this.sandboxName)
-      return;
-    const log = getLogger();
-    log.debug("Cleaning up sandbox", { sandboxName: this.sandboxName });
-    try {
-      execSync7(`docker sandbox rm ${this.sandboxName}`, {
-        timeout: 60000
-      });
-    } catch {}
-    unregisterActiveSandbox(this.sandboxName);
-    this.sandboxName = null;
+    }, 3000);
+    if (timer.unref)
+      timer.unref();
   }
   async isSandboxRunning() {
-    if (!this.sandboxName)
-      return false;
     try {
       const { promisify: promisify2 } = await import("node:util");
       const { exec: exec2 } = await import("node:child_process");
@@ -4857,24 +4549,6 @@ class SandboxedClaudeRunner {
       return false;
     }
   }
-  getSandboxName() {
-    return this.sandboxName;
-  }
-}
-function buildSandboxName(options) {
-  const ts = Date.now();
-  if (options.activity) {
-    const match = options.activity.match(/issue\s*#(\d+)/i);
-    if (match) {
-      return `locus-issue-${match[1]}-${ts}`;
-    }
-  }
-  const segment = options.cwd.split("/").pop() ?? "run";
-  return `locus-${segment}-${ts}`;
-}
-function buildPersistentSandboxName(cwd) {
-  const segment = cwd.split("/").pop() ?? "repl";
-  return `locus-${segment}-${Date.now()}`;
 }
 function formatToolCall2(name, input) {
   switch (name) {
@@ -4898,7 +4572,7 @@ function formatToolCall2(name, input) {
     case "WebSearch":
       return `searching: ${input.query ?? ""}`;
     case "Task":
-      return `spawning agent`;
+      return "spawning agent";
     default:
       return name;
   }
@@ -4906,12 +4580,11 @@ function formatToolCall2(name, input) {
 var init_claude_sandbox = __esm(() => {
   init_logger();
   init_sandbox_ignore();
-  init_shutdown();
   init_claude();
 });
 
 // src/ai/codex.ts
-import { execSync as execSync8, spawn as spawn4 } from "node:child_process";
+import { execSync as execSync6, spawn as spawn4 } from "node:child_process";
 function buildCodexArgs(model) {
   const args = ["exec", "--full-auto", "--skip-git-repo-check", "--json"];
   if (model) {
@@ -4927,7 +4600,7 @@ class CodexRunner {
   aborted = false;
   async isAvailable() {
     try {
-      execSync8("codex --version", {
+      execSync6("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -4938,7 +4611,7 @@ class CodexRunner {
   }
   async getVersion() {
     try {
-      const output = execSync8("codex --version", {
+      const output = execSync6("codex --version", {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -5086,28 +4759,16 @@ var init_codex = __esm(() => {
 });
 
 // src/ai/codex-sandbox.ts
-import { execSync as execSync9, spawn as spawn5 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 
 class SandboxedCodexRunner {
+  sandboxName;
   name = "codex-sandboxed";
   process = null;
   aborted = false;
-  sandboxName = null;
-  persistent;
-  sandboxCreated = false;
-  userManaged = false;
   codexInstalled = false;
-  constructor(persistentName, userManaged = false) {
-    if (persistentName) {
-      this.persistent = true;
-      this.sandboxName = persistentName;
-      this.userManaged = userManaged;
-      if (userManaged) {
-        this.sandboxCreated = true;
-      }
-    } else {
-      this.persistent = false;
-    }
+  constructor(sandboxName) {
+    this.sandboxName = sandboxName;
   }
   async isAvailable() {
     const delegate = new CodexRunner;
@@ -5120,251 +4781,158 @@ class SandboxedCodexRunner {
   async execute(options) {
     const log = getLogger();
     this.aborted = false;
-    const codexArgs = buildCodexArgs(options.model);
-    let dockerArgs;
-    if (this.persistent && !this.sandboxName) {
-      throw new Error("Sandbox name is required");
+    if (!await this.isSandboxRunning()) {
+      return {
+        success: false,
+        output: "",
+        error: `Sandbox is not running: ${this.sandboxName}`,
+        exitCode: 1
+      };
     }
-    if (this.persistent && this.sandboxCreated && await this.isSandboxRunning()) {
-      const name = this.sandboxName;
-      if (!name) {
-        throw new Error("Sandbox name is required");
-      }
-      options.onStatusChange?.("Syncing sandbox...");
-      await enforceSandboxIgnore(name, options.cwd);
-      if (!this.codexInstalled) {
-        options.onStatusChange?.("Checking codex...");
-        await this.ensureCodexInstalled(name);
-        this.codexInstalled = true;
-      }
-      options.onStatusChange?.("Thinking...");
-      dockerArgs = [
-        "sandbox",
-        "exec",
-        "-i",
-        "-w",
-        options.cwd,
-        name,
-        "codex",
-        ...codexArgs
-      ];
-    } else {
-      if (!this.persistent) {
-        this.sandboxName = buildSandboxName2(options);
-      }
-      const name = this.sandboxName;
-      if (!name) {
-        throw new Error("Sandbox name is required");
-      }
-      registerActiveSandbox(name);
-      options.onStatusChange?.("Creating sandbox...");
-      await this.createSandboxWithClaude(name, options.cwd);
-      options.onStatusChange?.("Installing codex...");
-      await this.ensureCodexInstalled(name);
+    const codexArgs = buildCodexArgs(options.model);
+    options.onStatusChange?.("Syncing sandbox...");
+    await enforceSandboxIgnore(this.sandboxName, options.cwd);
+    if (!this.codexInstalled) {
+      options.onStatusChange?.("Checking codex...");
+      await this.ensureCodexInstalled(this.sandboxName);
       this.codexInstalled = true;
-      options.onStatusChange?.("Syncing sandbox...");
-      await enforceSandboxIgnore(name, options.cwd);
-      options.onStatusChange?.("Thinking...");
-      dockerArgs = [
-        "sandbox",
-        "exec",
-        "-i",
-        "-w",
-        options.cwd,
-        name,
-        "codex",
-        ...codexArgs
-      ];
     }
+    options.onStatusChange?.("Thinking...");
+    const dockerArgs = [
+      "sandbox",
+      "exec",
+      "-i",
+      "-w",
+      options.cwd,
+      this.sandboxName,
+      "codex",
+      ...codexArgs
+    ];
     log.debug("Spawning sandboxed codex", {
       sandboxName: this.sandboxName,
-      persistent: this.persistent,
-      reusing: this.persistent && this.sandboxCreated,
       args: dockerArgs.join(" "),
       cwd: options.cwd
     });
-    try {
-      return await new Promise((resolve2) => {
-        let rawOutput = "";
-        let errorOutput = "";
-        this.process = spawn5("docker", dockerArgs, {
-          stdio: ["pipe", "pipe", "pipe"],
-          env: process.env
-        });
-        if (this.persistent && !this.sandboxCreated) {
-          this.process.on("spawn", () => {
-            this.sandboxCreated = true;
-          });
-        }
-        let agentMessages = [];
-        const flushAgentMessages = () => {
-          if (agentMessages.length > 0) {
-            options.onOutput?.(agentMessages.join(`
+    return await new Promise((resolve2) => {
+      let rawOutput = "";
+      let errorOutput = "";
+      this.process = spawn5("docker", dockerArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: process.env
+      });
+      let agentMessages = [];
+      const flushAgentMessages = () => {
+        if (agentMessages.length > 0) {
+          options.onOutput?.(agentMessages.join(`
 
 `));
-            agentMessages = [];
-          }
-        };
-        let lineBuffer = "";
-        this.process.stdout?.on("data", (chunk) => {
-          lineBuffer += chunk.toString();
-          const lines = lineBuffer.split(`
+          agentMessages = [];
+        }
+      };
+      let lineBuffer = "";
+      this.process.stdout?.on("data", (chunk) => {
+        lineBuffer += chunk.toString();
+        const lines = lineBuffer.split(`
 `);
-          lineBuffer = lines.pop() ?? "";
-          for (const line of lines) {
-            if (!line.trim())
-              continue;
-            rawOutput += `${line}
+        lineBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim())
+            continue;
+          rawOutput += `${line}
 `;
-            log.debug("sandboxed codex stdout line", { line });
-            try {
-              const event = JSON.parse(line);
-              const { type, item } = event;
-              if (type === "item.started" && item?.type === "command_execution") {
-                const cmd = (item.command ?? "").split(`
+          log.debug("sandboxed codex stdout line", { line });
+          try {
+            const event = JSON.parse(line);
+            const { type, item } = event;
+            if (type === "item.started" && item?.type === "command_execution") {
+              const cmd = (item.command ?? "").split(`
 `)[0].slice(0, 80);
-                options.onToolActivity?.(`running: ${cmd}`);
-              } else if (type === "item.completed" && item?.type === "command_execution") {
-                const code = item.exit_code;
-                options.onToolActivity?.(code === 0 ? "done" : `exit ${code}`);
-              } else if (type === "item.completed" && item?.type === "reasoning") {
-                const text = (item.text ?? "").trim().replace(/\*\*([^*]+)\*\*/g, "$1").replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "$1");
-                if (text)
-                  options.onToolActivity?.(text);
-              } else if (type === "item.completed" && item?.type === "agent_message") {
-                const text = item.text ?? "";
-                if (text) {
-                  agentMessages.push(text);
-                  options.onToolActivity?.(text.split(`
+              options.onToolActivity?.(`running: ${cmd}`);
+            } else if (type === "item.completed" && item?.type === "command_execution") {
+              const code = item.exit_code;
+              options.onToolActivity?.(code === 0 ? "done" : `exit ${code}`);
+            } else if (type === "item.completed" && item?.type === "reasoning") {
+              const text = (item.text ?? "").trim().replace(/\*\*([^*]+)\*\*/g, "$1").replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "$1");
+              if (text)
+                options.onToolActivity?.(text);
+            } else if (type === "item.completed" && item?.type === "agent_message") {
+              const text = item.text ?? "";
+              if (text) {
+                agentMessages.push(text);
+                options.onToolActivity?.(text.split(`
 `)[0].slice(0, 80));
-                }
-              } else if (type === "turn.completed") {
-                flushAgentMessages();
               }
-            } catch {
-              const newLine = `${line}
-`;
-              rawOutput += newLine;
-              options.onOutput?.(newLine);
+            } else if (type === "turn.completed") {
+              flushAgentMessages();
             }
+          } catch {
+            const newLine = `${line}
+`;
+            rawOutput += newLine;
+            options.onOutput?.(newLine);
           }
-        });
-        this.process.stderr?.on("data", (chunk) => {
-          const text = chunk.toString();
-          errorOutput += text;
-          log.debug("sandboxed codex stderr", { text: text.slice(0, 500) });
-        });
-        this.process.on("close", (code) => {
-          this.process = null;
-          flushAgentMessages();
-          if (this.aborted) {
-            resolve2({
-              success: false,
-              output: rawOutput,
-              error: "Aborted by user",
-              exitCode: code ?? 143
-            });
-            return;
-          }
-          if (code === 0) {
-            resolve2({
-              success: true,
-              output: rawOutput,
-              exitCode: 0
-            });
-          } else {
-            resolve2({
-              success: false,
-              output: rawOutput,
-              error: errorOutput || `sandboxed codex exited with code ${code}`,
-              exitCode: code ?? 1
-            });
-          }
-        });
-        this.process.on("error", (err) => {
-          this.process = null;
-          if (this.persistent && !this.sandboxCreated) {}
+        }
+      });
+      this.process.stderr?.on("data", (chunk) => {
+        const text = chunk.toString();
+        errorOutput += text;
+        log.debug("sandboxed codex stderr", { text: text.slice(0, 500) });
+      });
+      this.process.on("close", (code) => {
+        this.process = null;
+        flushAgentMessages();
+        if (this.aborted) {
           resolve2({
             success: false,
             output: rawOutput,
-            error: `Failed to spawn docker sandbox: ${err.message}`,
-            exitCode: 1
+            error: "Aborted by user",
+            exitCode: code ?? 143
           });
-        });
-        if (options.signal) {
-          options.signal.addEventListener("abort", () => {
-            this.abort();
+          return;
+        }
+        if (code === 0) {
+          resolve2({ success: true, output: rawOutput, exitCode: 0 });
+        } else {
+          resolve2({
+            success: false,
+            output: rawOutput,
+            error: errorOutput || `sandboxed codex exited with code ${code}`,
+            exitCode: code ?? 1
           });
         }
-        this.process.stdin?.write(options.prompt);
-        this.process.stdin?.end();
       });
-    } finally {
-      if (!this.persistent) {
-        this.cleanupSandbox();
+      this.process.on("error", (err) => {
+        this.process = null;
+        resolve2({
+          success: false,
+          output: rawOutput,
+          error: `Failed to spawn docker sandbox: ${err.message}`,
+          exitCode: 1
+        });
+      });
+      if (options.signal) {
+        options.signal.addEventListener("abort", () => {
+          this.abort();
+        });
       }
-    }
+      this.process.stdin?.write(options.prompt);
+      this.process.stdin?.end();
+    });
   }
   abort() {
     this.aborted = true;
-    const log = getLogger();
-    if (this.persistent) {
-      log.debug("Aborting sandboxed codex (persistent — keeping sandbox)", {
-        sandboxName: this.sandboxName
-      });
+    if (!this.process)
+      return;
+    this.process.kill("SIGTERM");
+    const timer = setTimeout(() => {
       if (this.process) {
-        this.process.kill("SIGTERM");
-        const timer = setTimeout(() => {
-          if (this.process) {
-            this.process.kill("SIGKILL");
-          }
-        }, 3000);
-        if (timer.unref)
-          timer.unref();
+        this.process.kill("SIGKILL");
       }
-    } else {
-      if (!this.sandboxName)
-        return;
-      log.debug("Aborting sandboxed codex (ephemeral — removing sandbox)", {
-        sandboxName: this.sandboxName
-      });
-      try {
-        execSync9(`docker sandbox rm ${this.sandboxName}`, { timeout: 60000 });
-      } catch {}
-    }
-  }
-  destroy() {
-    if (!this.sandboxName)
-      return;
-    if (this.userManaged) {
-      unregisterActiveSandbox(this.sandboxName);
-      return;
-    }
-    const log = getLogger();
-    log.debug("Destroying sandbox", { sandboxName: this.sandboxName });
-    try {
-      execSync9(`docker sandbox rm ${this.sandboxName}`, { timeout: 60000 });
-    } catch {}
-    unregisterActiveSandbox(this.sandboxName);
-    this.sandboxName = null;
-    this.sandboxCreated = false;
-  }
-  cleanupSandbox() {
-    if (!this.sandboxName)
-      return;
-    const log = getLogger();
-    log.debug("Cleaning up sandbox", { sandboxName: this.sandboxName });
-    try {
-      execSync9(`docker sandbox rm ${this.sandboxName}`, {
-        timeout: 60000
-      });
-    } catch {}
-    unregisterActiveSandbox(this.sandboxName);
-    this.sandboxName = null;
+    }, 3000);
+    if (timer.unref)
+      timer.unref();
   }
   async isSandboxRunning() {
-    if (!this.sandboxName)
-      return false;
     try {
       const { promisify: promisify2 } = await import("node:util");
       const { exec: exec2 } = await import("node:child_process");
@@ -5377,14 +4945,6 @@ class SandboxedCodexRunner {
       return false;
     }
   }
-  async createSandboxWithClaude(name, cwd) {
-    const { promisify: promisify2 } = await import("node:util");
-    const { exec: exec2 } = await import("node:child_process");
-    const execAsync2 = promisify2(exec2);
-    try {
-      await execAsync2(`docker sandbox run --name ${name} claude ${cwd} -- --version`, { timeout: 120000 });
-    } catch {}
-  }
   async ensureCodexInstalled(name) {
     const { promisify: promisify2 } = await import("node:util");
     const { exec: exec2 } = await import("node:child_process");
@@ -5394,38 +4954,28 @@ class SandboxedCodexRunner {
         timeout: 5000
       });
     } catch {
-      await execAsync2(`docker sandbox exec ${name} npm install -g @openai/codex`, { timeout: 120000 });
-    }
-  }
-  getSandboxName() {
-    return this.sandboxName;
-  }
-}
-function buildSandboxName2(options) {
-  const ts = Date.now();
-  if (options.activity) {
-    const match = options.activity.match(/issue\s*#(\d+)/i);
-    if (match) {
-      return `locus-codex-issue-${match[1]}-${ts}`;
+      await execAsync2(`docker sandbox exec ${name} npm install -g @openai/codex`, {
+        timeout: 120000
+      });
     }
   }
-  const segment = options.cwd.split("/").pop() ?? "run";
-  return `locus-codex-${segment}-${ts}`;
 }
 var init_codex_sandbox = __esm(() => {
   init_logger();
   init_sandbox_ignore();
-  init_shutdown();
   init_codex();
 });
 
 // src/ai/runner.ts
 async function createRunnerAsync(provider, sandboxed) {
+  if (sandboxed) {
+    throw new Error("Sandboxed runner creation requires a provider sandbox name. Use createUserManagedSandboxRunner().");
+  }
   switch (provider) {
     case "claude":
-      return sandboxed ? new SandboxedClaudeRunner : new ClaudeRunner;
+      return new ClaudeRunner;
     case "codex":
-      return sandboxed ? new SandboxedCodexRunner : new CodexRunner;
+      return new CodexRunner;
     default:
       throw new Error(`Unknown AI provider: ${provider}`);
   }
@@ -5433,9 +4983,9 @@ async function createRunnerAsync(provider, sandboxed) {
 function createUserManagedSandboxRunner(provider, sandboxName) {
   switch (provider) {
     case "claude":
-      return new SandboxedClaudeRunner(sandboxName, true);
+      return new SandboxedClaudeRunner(sandboxName);
     case "codex":
-      return new SandboxedCodexRunner(sandboxName, true);
+      return new SandboxedCodexRunner(sandboxName);
     default:
       throw new Error(`Unknown AI provider: ${provider}`);
   }
@@ -5535,10 +5085,20 @@ ${red("✗")} ${dim("Force exit.")}\r
     });
     if (options.runner) {
       runner = options.runner;
-    } else if (options.sandboxName) {
+    } else if (options.sandboxed ?? true) {
+      if (!options.sandboxName) {
+        indicator.stop();
+        return {
+          success: false,
+          output: "",
+          error: `Sandbox for provider "${resolvedProvider}" is not configured. ` + `Run "locus sandbox" and authenticate via "locus sandbox ${resolvedProvider}".`,
+          interrupted: false,
+          exitCode: 1
+        };
+      }
       runner = createUserManagedSandboxRunner(resolvedProvider, options.sandboxName);
     } else {
-      runner = await createRunnerAsync(resolvedProvider, options.sandboxed ?? true);
+      runner = await createRunnerAsync(resolvedProvider, false);
     }
     const available = await runner.isAvailable();
     if (!available) {
@@ -5864,7 +5424,7 @@ async function issueCreate(projectRoot, parsed) {
     silent: true,
     activity: "generating issue",
     sandboxed: config.sandbox.enabled,
-    sandboxName: config.sandbox.name
+    sandboxName: getModelSandboxName(config.sandbox, config.ai.model, config.ai.provider)
   });
   if (!aiResult.success && !aiResult.interrupted) {
     process.stderr.write(`${red("✗")} Failed to generate issue: ${aiResult.error}
@@ -6409,6 +5969,7 @@ var init_issue = __esm(() => {
   init_config();
   init_github();
   init_logger();
+  init_sandbox();
   init_table();
   init_terminal();
   init_types();
@@ -7066,9 +6627,9 @@ var init_sprint = __esm(() => {
 });
 
 // src/core/prompt-builder.ts
-import { execSync as execSync10 } from "node:child_process";
-import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "node:fs";
-import { join as join13 } from "node:path";
+import { execSync as execSync7 } from "node:child_process";
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "node:fs";
+import { join as join12 } from "node:path";
 function buildExecutionPrompt(ctx) {
   const sections = [];
   sections.push(buildSystemContext(ctx.projectRoot));
@@ -7098,13 +6659,13 @@ function buildFeedbackPrompt(ctx) {
 }
 function buildReplPrompt(userMessage, projectRoot, _config, previousMessages) {
   const sections = [];
-  const locusmd = readFileSafe(join13(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join12(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     sections.push(`<project-instructions>
 ${locusmd}
 </project-instructions>`);
   }
-  const learnings = readFileSafe(join13(projectRoot, ".locus", "LEARNINGS.md"));
+  const learnings = readFileSafe(join12(projectRoot, ".locus", "LEARNINGS.md"));
   if (learnings) {
     sections.push(`<past-learnings>
 ${learnings}
@@ -7130,24 +6691,24 @@ ${userMessage}
 }
 function buildSystemContext(projectRoot) {
   const parts = [];
-  const locusmd = readFileSafe(join13(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join12(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     parts.push(`<project-instructions>
 ${locusmd}
 </project-instructions>`);
   }
-  const learnings = readFileSafe(join13(projectRoot, ".locus", "LEARNINGS.md"));
+  const learnings = readFileSafe(join12(projectRoot, ".locus", "LEARNINGS.md"));
   if (learnings) {
     parts.push(`<past-learnings>
 ${learnings}
 </past-learnings>`);
   }
-  const discussionsDir = join13(projectRoot, ".locus", "discussions");
-  if (existsSync14(discussionsDir)) {
+  const discussionsDir = join12(projectRoot, ".locus", "discussions");
+  if (existsSync13(discussionsDir)) {
     try {
       const files = readdirSync3(discussionsDir).filter((f) => f.endsWith(".md")).slice(0, 3);
       for (const file of files) {
-        const content = readFileSafe(join13(discussionsDir, file));
+        const content = readFileSafe(join12(discussionsDir, file));
         if (content) {
           const name = file.replace(".md", "");
           parts.push(`<discussion name="${name}">
@@ -7214,7 +6775,7 @@ ${parts.join(`
 function buildRepoContext(projectRoot) {
   const parts = [];
   try {
-    const tree = execSync10("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 = 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();
     if (tree) {
       parts.push(`<file-tree>
 \`\`\`
@@ -7224,7 +6785,7 @@ ${tree}
     }
   } catch {}
   try {
-    const gitLog = execSync10("git log --oneline -10", {
+    const gitLog = execSync7("git log --oneline -10", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7238,7 +6799,7 @@ ${gitLog}
     }
   } catch {}
   try {
-    const branch = execSync10("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync7("git rev-parse --abbrev-ref HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7298,9 +6859,9 @@ function buildFeedbackInstructions() {
 }
 function readFileSafe(path) {
   try {
-    if (!existsSync14(path))
+    if (!existsSync13(path))
       return null;
-    return readFileSync10(path, "utf-8");
+    return readFileSync9(path, "utf-8");
   } catch {
     return null;
   }
@@ -7492,7 +7053,7 @@ var init_diff_renderer = __esm(() => {
 });
 
 // src/repl/commands.ts
-import { execSync as execSync11 } from "node:child_process";
+import { execSync as execSync8 } from "node:child_process";
 function getSlashCommands() {
   return [
     {
@@ -7684,7 +7245,7 @@ function cmdModel(args, ctx) {
 }
 function cmdDiff(_args, ctx) {
   try {
-    const diff = execSync11("git diff", {
+    const diff = execSync8("git diff", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7720,7 +7281,7 @@ function cmdDiff(_args, ctx) {
 }
 function cmdUndo(_args, ctx) {
   try {
-    const status = execSync11("git status --porcelain", {
+    const status = execSync8("git status --porcelain", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7730,7 +7291,7 @@ function cmdUndo(_args, ctx) {
 `);
       return;
     }
-    execSync11("git checkout .", {
+    execSync8("git checkout .", {
       cwd: ctx.projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7764,7 +7325,7 @@ var init_commands = __esm(() => {
 
 // src/repl/completions.ts
 import { readdirSync as readdirSync4 } from "node:fs";
-import { basename as basename2, dirname as dirname4, join as join14 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join13 } from "node:path";
 
 class SlashCommandCompletion {
   commands;
@@ -7819,7 +7380,7 @@ class FilePathCompletion {
   }
   findMatches(partial) {
     try {
-      const dir = partial.includes("/") ? join14(this.projectRoot, dirname4(partial)) : this.projectRoot;
+      const dir = partial.includes("/") ? join13(this.projectRoot, dirname3(partial)) : this.projectRoot;
       const prefix = basename2(partial);
       const entries = readdirSync4(dir, { withFileTypes: true });
       return entries.filter((e) => {
@@ -7830,7 +7391,7 @@ class FilePathCompletion {
         return e.name.startsWith(prefix);
       }).map((e) => {
         const name = e.isDirectory() ? `${e.name}/` : e.name;
-        return partial.includes("/") ? `${dirname4(partial)}/${name}` : name;
+        return partial.includes("/") ? `${dirname3(partial)}/${name}` : name;
       }).slice(0, 20);
     } catch {
       return [];
@@ -7855,14 +7416,14 @@ class CombinedCompletion {
 var init_completions = () => {};
 
 // src/repl/input-history.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname5, join as join15 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname4, join as join14 } from "node:path";
 
 class InputHistory {
   entries = [];
   filePath;
   constructor(projectRoot) {
-    this.filePath = join15(projectRoot, ".locus", "sessions", ".input-history");
+    this.filePath = join14(projectRoot, ".locus", "sessions", ".input-history");
     this.load();
   }
   add(text) {
@@ -7901,22 +7462,22 @@ class InputHistory {
   }
   load() {
     try {
-      if (!existsSync15(this.filePath))
+      if (!existsSync14(this.filePath))
         return;
-      const content = readFileSync11(this.filePath, "utf-8");
+      const content = readFileSync10(this.filePath, "utf-8");
       this.entries = content.split(`
 `).map((line) => this.unescape(line)).filter(Boolean);
     } catch {}
   }
   save() {
     try {
-      const dir = dirname5(this.filePath);
-      if (!existsSync15(dir)) {
-        mkdirSync10(dir, { recursive: true });
+      const dir = dirname4(this.filePath);
+      if (!existsSync14(dir)) {
+        mkdirSync9(dir, { recursive: true });
       }
       const content = this.entries.map((e) => this.escape(e)).join(`
 `);
-      writeFileSync7(this.filePath, content, "utf-8");
+      writeFileSync6(this.filePath, content, "utf-8");
     } catch {}
   }
   escape(text) {
@@ -7942,21 +7503,21 @@ var init_model_config = __esm(() => {
 
 // src/repl/session-manager.ts
 import {
-  existsSync as existsSync16,
-  mkdirSync as mkdirSync11,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync10,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync12,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync8
+  readFileSync as readFileSync11,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { basename as basename3, join as join16 } from "node:path";
+import { basename as basename3, join as join15 } 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 = join15(projectRoot, ".locus", "sessions");
+    if (!existsSync15(this.sessionsDir)) {
+      mkdirSync10(this.sessionsDir, { recursive: true });
     }
   }
   create(options) {
@@ -7981,14 +7542,14 @@ class SessionManager {
   }
   isPersisted(sessionOrId) {
     const sessionId = typeof sessionOrId === "string" ? sessionOrId : sessionOrId.id;
-    return existsSync16(this.getSessionPath(sessionId));
+    return existsSync15(this.getSessionPath(sessionId));
   }
   load(idOrPrefix) {
     const files = this.listSessionFiles();
     const exactPath = this.getSessionPath(idOrPrefix);
-    if (existsSync16(exactPath)) {
+    if (existsSync15(exactPath)) {
       try {
-        return JSON.parse(readFileSync12(exactPath, "utf-8"));
+        return JSON.parse(readFileSync11(exactPath, "utf-8"));
       } catch {
         return null;
       }
@@ -7996,7 +7557,7 @@ class SessionManager {
     const matches = files.filter((f) => basename3(f, ".json").startsWith(idOrPrefix));
     if (matches.length === 1) {
       try {
-        return JSON.parse(readFileSync12(matches[0], "utf-8"));
+        return JSON.parse(readFileSync11(matches[0], "utf-8"));
       } catch {
         return null;
       }
@@ -8009,7 +7570,7 @@ class SessionManager {
   save(session) {
     session.updated = new Date().toISOString();
     const path = this.getSessionPath(session.id);
-    writeFileSync8(path, `${JSON.stringify(session, null, 2)}
+    writeFileSync7(path, `${JSON.stringify(session, null, 2)}
 `, "utf-8");
   }
   addMessage(session, message) {
@@ -8021,7 +7582,7 @@ class SessionManager {
     const sessions = [];
     for (const file of files) {
       try {
-        const session = JSON.parse(readFileSync12(file, "utf-8"));
+        const session = JSON.parse(readFileSync11(file, "utf-8"));
         sessions.push({
           id: session.id,
           created: session.created,
@@ -8036,8 +7597,8 @@ class SessionManager {
   }
   delete(sessionId) {
     const path = this.getSessionPath(sessionId);
-    if (existsSync16(path)) {
-      unlinkSync4(path);
+    if (existsSync15(path)) {
+      unlinkSync3(path);
       return true;
     }
     return false;
@@ -8048,7 +7609,7 @@ class SessionManager {
     let pruned = 0;
     const withStats = files.map((f) => {
       try {
-        const session = JSON.parse(readFileSync12(f, "utf-8"));
+        const session = JSON.parse(readFileSync11(f, "utf-8"));
         return { path: f, updated: new Date(session.updated).getTime() };
       } catch {
         return { path: f, updated: 0 };
@@ -8058,7 +7619,7 @@ class SessionManager {
     for (const entry of withStats) {
       if (now - entry.updated > SESSION_MAX_AGE_MS) {
         try {
-          unlinkSync4(entry.path);
+          unlinkSync3(entry.path);
           pruned++;
         } catch {}
       }
@@ -8066,10 +7627,10 @@ 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) => existsSync15(e.path));
       for (let i = 0;i < toRemove && i < alive.length; i++) {
         try {
-          unlinkSync4(alive[i].path);
+          unlinkSync3(alive[i].path);
           pruned++;
         } catch {}
       }
@@ -8081,7 +7642,7 @@ class SessionManager {
   }
   listSessionFiles() {
     try {
-      return readdirSync5(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join16(this.sessionsDir, f));
+      return readdirSync5(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join15(this.sessionsDir, f));
     } catch {
       return [];
     }
@@ -8090,7 +7651,7 @@ class SessionManager {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
   getSessionPath(sessionId) {
-    return join16(this.sessionsDir, `${sessionId}.json`);
+    return join15(this.sessionsDir, `${sessionId}.json`);
   }
 }
 var MAX_SESSIONS = 50, SESSION_MAX_AGE_MS;
@@ -8100,7 +7661,7 @@ var init_session_manager = __esm(() => {
 });
 
 // src/repl/repl.ts
-import { execSync as execSync12 } from "node:child_process";
+import { execSync as execSync9 } from "node:child_process";
 async function startRepl(options) {
   const { projectRoot, config } = options;
   const sessionManager = new SessionManager(projectRoot);
@@ -8118,7 +7679,7 @@ async function startRepl(options) {
   } else {
     let branch = "main";
     try {
-      branch = execSync12("git rev-parse --abbrev-ref HEAD", {
+      branch = execSync9("git rev-parse --abbrev-ref HEAD", {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -8161,16 +7722,17 @@ async function executeOneShotPrompt(prompt, session, sessionManager, options) {
 async function runInteractiveRepl(session, sessionManager, options) {
   const { projectRoot, config } = options;
   let sandboxRunner = null;
-  if (config.sandbox.enabled && config.sandbox.name) {
+  if (config.sandbox.enabled) {
     const provider = inferProviderFromModel(config.ai.model) || config.ai.provider;
-    sandboxRunner = createUserManagedSandboxRunner(provider, config.sandbox.name);
-    process.stderr.write(`${dim("Using sandbox")} ${dim(config.sandbox.name)}
+    const sandboxName = getProviderSandboxName(config.sandbox, provider);
+    if (sandboxName) {
+      sandboxRunner = createUserManagedSandboxRunner(provider, sandboxName);
+      process.stderr.write(`${dim("Using")} ${dim(provider)} ${dim("sandbox")} ${dim(sandboxName)}
 `);
-  } else if (config.sandbox.enabled) {
-    const sandboxName = buildPersistentSandboxName(projectRoot);
-    sandboxRunner = new SandboxedClaudeRunner(sandboxName);
-    process.stderr.write(`${dim("Sandbox mode: prompts will share sandbox")} ${dim(sandboxName)}
+    } else {
+      process.stderr.write(`${yellow("⚠")} ${dim(`No sandbox configured for ${provider}. Run locus sandbox.`)}
 `);
+    }
   }
   const history = new InputHistory(projectRoot);
   const completion = new CombinedCompletion([
@@ -8204,10 +7766,17 @@ async function runInteractiveRepl(session, sessionManager, options) {
         const providerChanged = inferredProvider !== currentProvider;
         currentProvider = inferredProvider;
         session.metadata.provider = inferredProvider;
-        if (providerChanged && config.sandbox.enabled && config.sandbox.name) {
-          sandboxRunner = createUserManagedSandboxRunner(inferredProvider, config.sandbox.name);
-          process.stderr.write(`${dim("Switched sandbox agent to")} ${dim(inferredProvider)}
+        if (providerChanged && config.sandbox.enabled) {
+          const sandboxName = getProviderSandboxName(config.sandbox, inferredProvider);
+          if (sandboxName) {
+            sandboxRunner = createUserManagedSandboxRunner(inferredProvider, sandboxName);
+            process.stderr.write(`${dim("Switched sandbox agent to")} ${dim(inferredProvider)} ${dim(`(${sandboxName})`)}
+`);
+          } else {
+            sandboxRunner = null;
+            process.stderr.write(`${yellow("⚠")} ${dim(`No sandbox configured for ${inferredProvider}. Run locus sandbox.`)}
 `);
+          }
         }
       }
       persistReplModelSelection(projectRoot, config, model);
@@ -8279,10 +7848,6 @@ ${red("✗")} ${msg}
         break;
     }
   }
-  if (sandboxRunner && "destroy" in sandboxRunner) {
-    const runner = sandboxRunner;
-    runner.destroy();
-  }
   const shouldPersistOnExit = session.messages.length > 0 || sessionManager.isPersisted(session);
   if (shouldPersistOnExit) {
     sessionManager.save(session);
@@ -8300,6 +7865,7 @@ ${red("✗")} ${msg}
 }
 async function executeAITurn(prompt, session, options, verbose = false, runner) {
   const { config, projectRoot } = options;
+  const sandboxName = getModelSandboxName(config.sandbox, config.ai.model, config.ai.provider);
   const aiResult = await runAI({
     prompt,
     provider: config.ai.provider,
@@ -8307,7 +7873,7 @@ async function executeAITurn(prompt, session, options, verbose = false, runner)
     cwd: projectRoot,
     verbose,
     sandboxed: config.sandbox.enabled,
-    sandboxName: config.sandbox.name,
+    sandboxName,
     runner
   });
   if (aiResult.interrupted) {
@@ -8338,11 +7904,11 @@ function printWelcome(session) {
 `);
 }
 var init_repl = __esm(() => {
-  init_claude_sandbox();
   init_run_ai();
   init_runner();
   init_ai_models();
   init_prompt_builder();
+  init_sandbox();
   init_terminal();
   init_commands();
   init_completions();
@@ -8360,7 +7926,6 @@ __export(exports_exec, {
 });
 async function execCommand(projectRoot, args, flags = {}) {
   const config = loadConfig(projectRoot);
-  const _log = getLogger();
   if (args[0] === "sessions") {
     return handleSessionSubcommand(projectRoot, args.slice(1));
   }
@@ -8483,7 +8048,12 @@ async function handleJsonStream(projectRoot, config, args, sessionId) {
   stream.emitStatus("thinking");
   try {
     const fullPrompt = buildReplPrompt(prompt, projectRoot, config);
-    const runner = config.sandbox.name ? createUserManagedSandboxRunner(config.ai.provider, config.sandbox.name) : await createRunnerAsync(config.ai.provider, config.sandbox.enabled);
+    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);
+    if (!runner) {
+      stream.emitError(`Sandbox for provider "${config.ai.provider}" is not configured. Run locus sandbox.`, false);
+      return;
+    }
     const available = await runner.isAvailable();
     if (!available) {
       stream.emitError(`${config.ai.provider} CLI not available`, false);
@@ -8523,15 +8093,15 @@ function formatAge(isoDate) {
 var init_exec = __esm(() => {
   init_runner();
   init_config();
-  init_logger();
   init_prompt_builder();
+  init_sandbox();
   init_terminal();
   init_repl();
   init_session_manager();
 });
 
 // src/core/agent.ts
-import { execSync as execSync13 } from "node:child_process";
+import { execSync as execSync10 } from "node:child_process";
 async function executeIssue(projectRoot, options) {
   const log = getLogger();
   const timer = createTimer();
@@ -8560,7 +8130,7 @@ ${cyan("●")} ${bold(`#${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 = execSync10(`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);
@@ -8703,7 +8273,7 @@ ${c.body}`),
     cwd: projectRoot,
     activity: `iterating on PR #${prNumber}`,
     sandboxed: config.sandbox.enabled,
-    sandboxName: config.sandbox.name
+    sandboxName: getModelSandboxName(config.sandbox, config.ai.model, config.ai.provider)
   });
   if (aiResult.interrupted) {
     process.stderr.write(`
@@ -8724,12 +8294,12 @@ ${aiResult.success ? green("✓") : red("✗")} Iteration ${aiResult.success ? "
 }
 async function createIssuePR(projectRoot, config, issue) {
   try {
-    const currentBranch = execSync13("git rev-parse --abbrev-ref HEAD", {
+    const currentBranch = execSync10("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 = execSync10(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -8738,7 +8308,7 @@ async function createIssuePR(projectRoot, config, issue) {
       getLogger().verbose("No changes to create PR for");
       return;
     }
-    execSync13(`git push -u origin ${currentBranch}`, {
+    execSync10(`git push -u origin ${currentBranch}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -8781,12 +8351,13 @@ var init_agent = __esm(() => {
   init_github();
   init_logger();
   init_prompt_builder();
+  init_sandbox();
 });
 
 // src/core/conflict.ts
-import { execSync as execSync14 } from "node:child_process";
+import { execSync as execSync11 } from "node:child_process";
 function git2(args, cwd) {
-  return execSync14(`git ${args}`, {
+  return execSync11(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -8906,17 +8477,201 @@ ${bold(yellow("⚠"))} Base branch has ${result.newCommits} new commit${result.n
 `);
   }
 }
-var init_conflict = __esm(() => {
-  init_terminal();
-  init_logger();
+var init_conflict = __esm(() => {
+  init_terminal();
+  init_logger();
+});
+
+// src/core/run-state.ts
+import {
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync12,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { dirname as dirname5, join as join16 } from "node:path";
+function getRunStatePath(projectRoot) {
+  return join16(projectRoot, ".locus", "run-state.json");
+}
+function loadRunState(projectRoot) {
+  const path = getRunStatePath(projectRoot);
+  if (!existsSync16(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync12(path, "utf-8"));
+  } catch {
+    getLogger().warn("Corrupted run-state.json, ignoring");
+    return null;
+  }
+}
+function saveRunState(projectRoot, state) {
+  const path = getRunStatePath(projectRoot);
+  const dir = dirname5(path);
+  if (!existsSync16(dir)) {
+    mkdirSync11(dir, { recursive: true });
+  }
+  writeFileSync8(path, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
+function clearRunState(projectRoot) {
+  const path = getRunStatePath(projectRoot);
+  if (existsSync16(path)) {
+    unlinkSync4(path);
+  }
+}
+function createSprintRunState(sprint, branch, issues) {
+  return {
+    runId: `run-${new Date().toISOString().slice(0, 19).replace(/[:.]/g, "-")}`,
+    type: "sprint",
+    sprint,
+    branch,
+    startedAt: new Date().toISOString(),
+    tasks: issues.map(({ number, order }) => ({
+      issue: number,
+      order,
+      status: "pending"
+    }))
+  };
+}
+function createParallelRunState(issueNumbers) {
+  return {
+    runId: `run-${new Date().toISOString().slice(0, 19).replace(/[:.]/g, "-")}`,
+    type: "parallel",
+    startedAt: new Date().toISOString(),
+    tasks: issueNumbers.map((issue, i) => ({
+      issue,
+      order: i + 1,
+      status: "pending"
+    }))
+  };
+}
+function markTaskInProgress(state, issueNumber) {
+  const task = state.tasks.find((t) => t.issue === issueNumber);
+  if (task) {
+    task.status = "in_progress";
+  }
+}
+function markTaskDone(state, issueNumber, prNumber) {
+  const task = state.tasks.find((t) => t.issue === issueNumber);
+  if (task) {
+    task.status = "done";
+    task.completedAt = new Date().toISOString();
+    if (prNumber)
+      task.pr = prNumber;
+  }
+}
+function markTaskFailed(state, issueNumber, error) {
+  const task = state.tasks.find((t) => t.issue === issueNumber);
+  if (task) {
+    task.status = "failed";
+    task.failedAt = new Date().toISOString();
+    task.error = error;
+  }
+}
+function getRunStats(state) {
+  const tasks = state.tasks;
+  return {
+    total: tasks.length,
+    done: tasks.filter((t) => t.status === "done").length,
+    failed: tasks.filter((t) => t.status === "failed").length,
+    pending: tasks.filter((t) => t.status === "pending").length,
+    inProgress: tasks.filter((t) => t.status === "in_progress").length
+  };
+}
+function getNextTask(state) {
+  const failed = state.tasks.find((t) => t.status === "failed");
+  if (failed)
+    return failed;
+  return state.tasks.find((t) => t.status === "pending") ?? null;
+}
+var init_run_state = __esm(() => {
+  init_logger();
+});
+
+// src/core/shutdown.ts
+import { execSync as execSync12 } from "node:child_process";
+function cleanupActiveSandboxes() {
+  for (const name of activeSandboxes) {
+    try {
+      execSync12(`docker sandbox rm ${name}`, { timeout: 1e4 });
+    } catch {}
+  }
+  activeSandboxes.clear();
+}
+function registerShutdownHandlers(ctx) {
+  shutdownContext = ctx;
+  interruptCount = 0;
+  const handler = () => {
+    interruptCount++;
+    if (interruptCount >= 2) {
+      process.stderr.write(`
+Force exit.
+`);
+      process.exit(1);
+    }
+    process.stderr.write(`
+
+Interrupted. Saving state...
+`);
+    const state = shutdownContext?.getRunState?.();
+    if (state && shutdownContext) {
+      for (const task of state.tasks) {
+        if (task.status === "in_progress") {
+          task.status = "failed";
+          task.failedAt = new Date().toISOString();
+          task.error = "Interrupted by user";
+        }
+      }
+      try {
+        saveRunState(shutdownContext.projectRoot, state);
+        process.stderr.write(`State saved. Resume with: locus run --resume
+`);
+      } catch {
+        process.stderr.write(`Warning: Could not save run state.
+`);
+      }
+    }
+    cleanupActiveSandboxes();
+    shutdownContext?.onShutdown?.();
+    if (interruptTimer)
+      clearTimeout(interruptTimer);
+    interruptTimer = setTimeout(() => {
+      interruptCount = 0;
+    }, 2000);
+    setTimeout(() => {
+      process.exit(130);
+    }, 100);
+  };
+  if (!shutdownRegistered) {
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+    shutdownRegistered = true;
+  }
+  return () => {
+    process.removeListener("SIGINT", handler);
+    process.removeListener("SIGTERM", handler);
+    shutdownRegistered = false;
+    shutdownContext = null;
+    interruptCount = 0;
+    if (interruptTimer) {
+      clearTimeout(interruptTimer);
+      interruptTimer = null;
+    }
+  };
+}
+var shutdownRegistered = false, shutdownContext = null, interruptCount = 0, interruptTimer = null, activeSandboxes;
+var init_shutdown = __esm(() => {
+  init_run_state();
+  activeSandboxes = new Set;
 });
 
 // src/core/worktree.ts
-import { execSync as execSync15 } from "node:child_process";
+import { execSync as execSync13 } from "node:child_process";
 import { existsSync as existsSync17, readdirSync as readdirSync6, realpathSync, statSync as statSync3 } from "node:fs";
 import { join as join17 } from "node:path";
 function git3(args, cwd) {
-  return execSync15(`git ${args}`, {
+  return execSync13(`git ${args}`, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -8941,7 +8696,7 @@ function generateBranchName(issueNumber) {
 }
 function getWorktreeBranch(worktreePath) {
   try {
-    return execSync15("git branch --show-current", {
+    return execSync13("git branch --show-current", {
       cwd: worktreePath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9066,7 +8821,13 @@ var exports_run = {};
 __export(exports_run, {
   runCommand: () => runCommand
 });
-import { execSync as execSync16 } from "node:child_process";
+import { execSync as execSync14 } 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 };
+}
 function printRunHelp() {
   process.stderr.write(`
 ${bold("locus run")} — Execute issues using AI agents
@@ -9149,6 +8910,7 @@ async function runCommand(projectRoot, args, flags = {}) {
 }
 async function handleSprintRun(projectRoot, config, flags, sandboxed) {
   const log = getLogger();
+  const execution = resolveExecutionContext(config, flags.model);
   if (!config.sprint.active) {
     process.stderr.write(`${red("✗")} No active sprint. Set one with: ${bold("locus sprint active <name>")}
 `);
@@ -9210,7 +8972,7 @@ ${yellow("⚠")} A sprint run is already in progress.
   }
   if (!flags.dryRun) {
     try {
-      execSync16(`git checkout -B ${branchName}`, {
+      execSync14(`git checkout -B ${branchName}`, {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -9260,7 +9022,7 @@ ${red("✗")} Auto-rebase failed. Resolve manually.
     let sprintContext;
     if (i > 0 && !flags.dryRun) {
       try {
-        sprintContext = execSync16(`git diff origin/${config.agent.baseBranch}..HEAD`, {
+        sprintContext = execSync14(`git diff origin/${config.agent.baseBranch}..HEAD`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -9275,12 +9037,13 @@ ${progressBar(i, state.tasks.length, { label: "Sprint Progress" })}
     saveRunState(projectRoot, state);
     const result = await executeIssue(projectRoot, {
       issueNumber: task.issue,
-      provider: config.ai.provider,
-      model: flags.model ?? config.ai.model,
+      provider: execution.provider,
+      model: execution.model,
       dryRun: flags.dryRun,
       sprintContext,
       skipPR: true,
-      sandboxed
+      sandboxed,
+      sandboxName: execution.sandboxName
     });
     if (result.success) {
       if (!flags.dryRun) {
@@ -9324,7 +9087,7 @@ ${bold("Summary:")}
     const prNumber = await createSprintPR(projectRoot, config, sprintName, branchName, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync16(`git checkout ${config.agent.baseBranch}`, {
+        execSync14(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -9339,6 +9102,7 @@ ${bold("Summary:")}
   }
 }
 async function handleSingleIssue(projectRoot, config, issueNumber, flags, sandboxed) {
+  const execution = resolveExecutionContext(config, flags.model);
   let isSprintIssue = false;
   try {
     const issue = getIssue(issueNumber, { cwd: projectRoot });
@@ -9351,11 +9115,11 @@ ${bold("Running sprint issue")} ${cyan(`#${issueNumber}`)} ${dim("(sequential, n
 `);
     await executeIssue(projectRoot, {
       issueNumber,
-      provider: config.ai.provider,
-      model: flags.model ?? config.ai.model,
+      provider: execution.provider,
+      model: execution.model,
       dryRun: flags.dryRun,
       sandboxed,
-      sandboxName: config.sandbox.name
+      sandboxName: execution.sandboxName
     });
     return;
   }
@@ -9382,11 +9146,11 @@ ${bold("Running issue")} ${cyan(`#${issueNumber}`)} ${dim("(worktree)")}
   const result = await executeIssue(projectRoot, {
     issueNumber,
     worktreePath,
-    provider: config.ai.provider,
-    model: flags.model ?? config.ai.model,
+    provider: execution.provider,
+    model: execution.model,
     dryRun: flags.dryRun,
     sandboxed,
-    sandboxName: config.sandbox.name
+    sandboxName: execution.sandboxName
   });
   if (worktreePath && !flags.dryRun) {
     if (result.success) {
@@ -9401,6 +9165,7 @@ ${bold("Running issue")} ${cyan(`#${issueNumber}`)} ${dim("(worktree)")}
 }
 async function handleParallelRun(projectRoot, config, issueNumbers, flags, sandboxed) {
   const log = getLogger();
+  const execution = resolveExecutionContext(config, flags.model);
   const maxConcurrent = config.agent.maxParallel;
   process.stderr.write(`
 ${bold("Running")} ${cyan(`${issueNumbers.length} issues`)} ${dim(`(max ${maxConcurrent} parallel, worktrees)`)}
@@ -9452,11 +9217,11 @@ ${bold("Running")} ${cyan(`${issueNumbers.length} issues`)} ${dim(`(max ${maxCon
       const result = await executeIssue(projectRoot, {
         issueNumber,
         worktreePath,
-        provider: config.ai.provider,
-        model: flags.model ?? config.ai.model,
+        provider: execution.provider,
+        model: execution.model,
         dryRun: flags.dryRun,
         sandboxed,
-        sandboxName: config.sandbox.name
+        sandboxName: execution.sandboxName
       });
       if (result.success) {
         markTaskDone(state, issueNumber, result.prNumber);
@@ -9506,6 +9271,7 @@ ${yellow("⚠")} Failed worktrees preserved for debugging:
   }
 }
 async function handleResume(projectRoot, config, sandboxed) {
+  const execution = resolveExecutionContext(config);
   const state = loadRunState(projectRoot);
   if (!state) {
     process.stderr.write(`${red("✗")} No run state found. Nothing to resume.
@@ -9521,13 +9287,13 @@ ${bold("Resuming")} ${state.type} run ${dim(state.runId)}
 `);
   if (state.type === "sprint" && state.branch) {
     try {
-      const currentBranch = execSync16("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();
       if (currentBranch !== state.branch) {
-        execSync16(`git checkout ${state.branch}`, {
+        execSync14(`git checkout ${state.branch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -9551,11 +9317,11 @@ ${bold("Resuming")} ${state.type} run ${dim(state.runId)}
     saveRunState(projectRoot, state);
     const result = await executeIssue(projectRoot, {
       issueNumber: task.issue,
-      provider: config.ai.provider,
-      model: config.ai.model,
+      provider: execution.provider,
+      model: execution.model,
       skipPR: isSprintRun,
       sandboxed,
-      sandboxName: isSprintRun ? undefined : config.sandbox.name
+      sandboxName: execution.sandboxName
     });
     if (result.success) {
       if (isSprintRun) {
@@ -9594,7 +9360,7 @@ ${bold("Resume complete:")} ${green(`✓ ${finalStats.done}`)} ${finalStats.fail
     const prNumber = await createSprintPR(projectRoot, config, state.sprint, state.branch, completedTasks);
     if (prNumber !== undefined) {
       try {
-        execSync16(`git checkout ${config.agent.baseBranch}`, {
+        execSync14(`git checkout ${config.agent.baseBranch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -9625,14 +9391,14 @@ function getOrder2(issue) {
 }
 function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
   try {
-    const status = execSync16("git status --porcelain", {
+    const status = execSync14("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!status)
       return;
-    execSync16("git add -A", {
+    execSync14("git add -A", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9640,7 +9406,7 @@ function ensureTaskCommit(projectRoot, issueNumber, issueTitle) {
     const message = `chore: complete #${issueNumber} - ${issueTitle}
 
 Co-Authored-By: LocusAgent <agent@locusai.team>`;
-    execSync16(`git commit -F -`, {
+    execSync14(`git commit -F -`, {
       input: message,
       cwd: projectRoot,
       encoding: "utf-8",
@@ -9654,7 +9420,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 = execSync14(`git diff origin/${config.agent.baseBranch}..HEAD --stat`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9664,7 +9430,7 @@ async function createSprintPR(projectRoot, config, sprintName, branchName, tasks
 `);
       return;
     }
-    execSync16(`git push -u origin ${branchName}`, {
+    execSync14(`git push -u origin ${branchName}`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -9690,6 +9456,7 @@ ${taskLines}
   }
 }
 var init_run = __esm(() => {
+  init_ai_models();
   init_agent();
   init_config();
   init_conflict();
@@ -10066,7 +9833,7 @@ ${bold("Planning:")} ${cyan(displayDirective)}
     cwd: projectRoot,
     activity: "planning",
     sandboxed: config.sandbox.enabled,
-    sandboxName: config.sandbox.name
+    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
   });
   if (aiResult.interrupted) {
     process.stderr.write(`
@@ -10181,7 +9948,7 @@ Start with foundational/setup tasks, then core features, then integration/testin
     activity: "issue ordering",
     silent: true,
     sandboxed: config.sandbox.enabled,
-    sandboxName: config.sandbox.name
+    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
   });
   if (aiResult.interrupted) {
     process.stderr.write(`
@@ -10433,6 +10200,7 @@ var init_plan = __esm(() => {
   init_config();
   init_github();
   init_terminal();
+  init_sandbox();
 });
 
 // src/commands/review.ts
@@ -10440,7 +10208,7 @@ var exports_review = {};
 __export(exports_review, {
   reviewCommand: () => reviewCommand
 });
-import { execSync as execSync17 } from "node:child_process";
+import { execSync as execSync15 } from "node:child_process";
 import { existsSync as existsSync19, readFileSync as readFileSync14 } from "node:fs";
 import { join as join19 } from "node:path";
 function printHelp2() {
@@ -10518,7 +10286,7 @@ ${bold("Review complete:")} ${green(`✓ ${reviewed}`)}${failed > 0 ? ` ${red(`
 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 = execSync15(`gh pr view ${prNumber} --json number,title,body,state,headRefName,baseRefName,labels,url,createdAt`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const raw = JSON.parse(result);
     prInfo = {
       number: raw.number,
@@ -10563,7 +10331,7 @@ async function reviewPR(projectRoot, config, pr, focus, flags) {
     cwd: projectRoot,
     activity: `PR #${pr.number}`,
     sandboxed: config.sandbox.enabled,
-    sandboxName: config.sandbox.name
+    sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
   });
   if (aiResult.interrupted) {
     process.stderr.write(`  ${yellow("⚡")} Review interrupted.
@@ -10584,7 +10352,7 @@ ${output.slice(0, 60000)}
 
 ---
 _Reviewed by Locus AI (${config.ai.provider}/${flags.model ?? config.ai.model})_`;
-      execSync17(`gh pr comment ${pr.number} --body ${JSON.stringify(reviewBody)}`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+      execSync15(`gh pr comment ${pr.number} --body ${JSON.stringify(reviewBody)}`, { cwd: projectRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
       process.stderr.write(`  ${green("✓")} Review posted ${dim(`(${timer.formatted()})`)}
 `);
     } catch (e) {
@@ -10654,6 +10422,7 @@ var init_review = __esm(() => {
   init_run_ai();
   init_config();
   init_github();
+  init_sandbox();
   init_progress();
   init_terminal();
 });
@@ -10663,7 +10432,7 @@ var exports_iterate = {};
 __export(exports_iterate, {
   iterateCommand: () => iterateCommand
 });
-import { execSync as execSync18 } from "node:child_process";
+import { execSync as execSync16 } from "node:child_process";
 function printHelp3() {
   process.stderr.write(`
 ${bold("locus iterate")} — Re-execute tasks with PR feedback
@@ -10873,12 +10642,12 @@ ${bold("Summary:")} ${green(`✓ ${succeeded}`)}${failed > 0 ? ` ${red(`✗ ${fa
 }
 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 = execSync16(`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 = execSync16(`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;
@@ -11123,7 +10892,7 @@ ${bold("Discussion:")} ${cyan(topic)}
       cwd: projectRoot,
       activity: "discussion",
       sandboxed: config.sandbox.enabled,
-      sandboxName: config.sandbox.name
+      sandboxName: getModelSandboxName(config.sandbox, flags.model ?? config.ai.model, config.ai.provider)
     });
     if (aiResult.interrupted) {
       process.stderr.write(`
@@ -11269,6 +11038,7 @@ var MAX_DISCUSSION_ROUNDS = 5;
 var init_discuss = __esm(() => {
   init_run_ai();
   init_config();
+  init_sandbox();
   init_progress();
   init_terminal();
   init_input_handler();
@@ -11491,24 +11261,34 @@ var init_artifacts = __esm(() => {
 // src/commands/sandbox.ts
 var exports_sandbox2 = {};
 __export(exports_sandbox2, {
-  sandboxCommand: () => sandboxCommand
+  sandboxCommand: () => sandboxCommand,
+  parseSandboxLogsArgs: () => parseSandboxLogsArgs,
+  parseSandboxInstallArgs: () => parseSandboxInstallArgs,
+  parseSandboxExecArgs: () => parseSandboxExecArgs
 });
-import { execSync as execSync19, spawn as spawn6 } from "node:child_process";
+import { execSync as execSync17, spawn as spawn6 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { basename as basename4 } from "node:path";
 function printSandboxHelp() {
   process.stderr.write(`
 ${bold("locus sandbox")} — Manage Docker sandbox lifecycle
 
 ${bold("Usage:")}
-  locus sandbox                     ${dim("# Create sandbox and enable sandbox mode")}
+  locus sandbox                     ${dim("# Create claude/codex sandboxes and enable sandbox mode")}
   locus sandbox claude              ${dim("# Run claude interactively (for login)")}
   locus sandbox codex               ${dim("# Run codex interactively (for login)")}
-  locus sandbox rm                  ${dim("# Destroy sandbox and disable sandbox mode")}
+  locus sandbox install <pkg>       ${dim("# npm install -g package(s) in sandbox(es)")}
+  locus sandbox exec <provider> -- <cmd...> ${dim("# Run one command inside provider sandbox")}
+  locus sandbox shell <provider>    ${dim("# Open interactive shell in provider sandbox")}
+  locus sandbox logs <provider>     ${dim("# Show provider sandbox logs")}
+  locus sandbox rm                  ${dim("# Destroy all provider sandboxes and disable sandbox mode")}
   locus sandbox status              ${dim("# Show current sandbox state")}
 
 ${bold("Flow:")}
-  1. ${cyan("locus sandbox")}          Create the sandbox environment
-  2. ${cyan("locus sandbox claude")}   Login to Claude inside the sandbox
-  3. ${cyan("locus exec")}             All commands now run inside the sandbox
+  1. ${cyan("locus sandbox")}          Create provider sandboxes
+  2. ${cyan("locus sandbox claude")}   Login Claude inside its sandbox
+  3. ${cyan("locus sandbox codex")}    Login Codex inside its sandbox
+  4. ${cyan("locus sandbox install bun")}  Install extra tools (optional)
 
 `);
 }
@@ -11521,6 +11301,14 @@ async function sandboxCommand(projectRoot, args) {
     case "claude":
     case "codex":
       return handleAgentLogin(projectRoot, subcommand);
+    case "install":
+      return handleInstall(projectRoot, args.slice(1));
+    case "exec":
+      return handleExec(projectRoot, args.slice(1));
+    case "shell":
+      return handleShell(projectRoot, args.slice(1));
+    case "logs":
+      return handleLogs(projectRoot, args.slice(1));
     case "rm":
       return handleRemove(projectRoot);
     case "status":
@@ -11530,24 +11318,12 @@ async function sandboxCommand(projectRoot, args) {
     default:
       process.stderr.write(`${red("✗")} Unknown sandbox subcommand: ${bold(subcommand)}
 `);
-      process.stderr.write(`  Available: ${cyan("claude")}, ${cyan("codex")}, ${cyan("rm")}, ${cyan("status")}
+      process.stderr.write(`  Available: ${cyan("claude")}, ${cyan("codex")}, ${cyan("install")}, ${cyan("exec")}, ${cyan("shell")}, ${cyan("logs")}, ${cyan("rm")}, ${cyan("status")}
 `);
   }
 }
 async function handleCreate(projectRoot) {
   const config = loadConfig(projectRoot);
-  if (config.sandbox.name) {
-    const alive = isSandboxAlive(config.sandbox.name);
-    if (alive) {
-      process.stderr.write(`${green("✓")} Sandbox already exists: ${bold(config.sandbox.name)}
-`);
-      process.stderr.write(`  Run ${cyan("locus sandbox claude")} or ${cyan("locus sandbox codex")} to login.
-`);
-      return;
-    }
-    process.stderr.write(`${yellow("⚠")} Previous sandbox ${dim(config.sandbox.name)} is no longer running. Creating a new one.
-`);
-  }
   const status = await detectSandboxSupport();
   if (!status.available) {
     process.stderr.write(`${red("✗")} Docker sandbox not available: ${status.reason}
@@ -11556,86 +11332,68 @@ async function handleCreate(projectRoot) {
 `);
     return;
   }
-  const segment = projectRoot.split("/").pop() ?? "sandbox";
-  const sandboxName = `locus-${segment}-${Date.now()}`;
+  const sandboxNames = buildProviderSandboxNames(projectRoot);
+  const readySandboxes = {};
+  let failed = false;
+  for (const provider of PROVIDERS) {
+    const name = sandboxNames[provider];
+    if (isSandboxAlive(name)) {
+      process.stderr.write(`${green("✓")} ${provider} sandbox ready: ${bold(name)}
+`);
+      readySandboxes[provider] = name;
+      continue;
+    }
+    process.stderr.write(`Creating ${bold(provider)} sandbox ${dim(name)} with workspace ${dim(projectRoot)}...
+`);
+    const created = await createProviderSandbox(provider, name, projectRoot);
+    if (!created) {
+      process.stderr.write(`${red("✗")} Failed to create ${provider} sandbox (${name}).
+`);
+      failed = true;
+      continue;
+    }
+    process.stderr.write(`${green("✓")} ${provider} sandbox created: ${bold(name)}
+`);
+    readySandboxes[provider] = name;
+  }
   config.sandbox.enabled = true;
-  config.sandbox.name = sandboxName;
+  config.sandbox.providers = readySandboxes;
   saveConfig(projectRoot, config);
-  process.stderr.write(`${green("✓")} Sandbox name reserved: ${bold(sandboxName)}
+  if (failed) {
+    process.stderr.write(`
+${yellow("⚠")} Some sandboxes failed to create. Re-run ${cyan("locus sandbox")} after resolving Docker issues.
 `);
-  process.stderr.write(`  Next: run ${cyan("locus sandbox claude")} or ${cyan("locus sandbox codex")} to create the sandbox and login.
+  }
+  process.stderr.write(`
+${green("✓")} Sandbox mode enabled with provider-specific sandboxes.
+`);
+  process.stderr.write(`  Next: run ${cyan("locus sandbox claude")} and ${cyan("locus sandbox codex")} to authenticate both providers.
 `);
 }
 async function handleAgentLogin(projectRoot, agent) {
   const config = loadConfig(projectRoot);
-  if (!config.sandbox.name) {
-    const status = await detectSandboxSupport();
-    if (!status.available) {
-      process.stderr.write(`${red("✗")} Docker sandbox not available: ${status.reason}
-`);
-      process.stderr.write(`  Install Docker Desktop 4.58+ with sandbox support.
+  const sandboxName = getProviderSandboxName(config.sandbox, agent);
+  if (!sandboxName) {
+    process.stderr.write(`${red("✗")} No ${agent} sandbox configured. Run ${cyan("locus sandbox")} first.
 `);
-      return;
-    }
-    const segment = projectRoot.split("/").pop() ?? "sandbox";
-    config.sandbox.name = `locus-${segment}-${Date.now()}`;
-    config.sandbox.enabled = true;
-    saveConfig(projectRoot, config);
+    return;
   }
-  const sandboxName = config.sandbox.name;
-  const alive = isSandboxAlive(sandboxName);
-  let dockerArgs;
-  if (alive) {
-    if (agent === "codex") {
-      await ensureCodexInSandbox(sandboxName);
-    }
-    process.stderr.write(`Connecting to sandbox ${dim(sandboxName)}...
-`);
-    process.stderr.write(`${dim("Login and then exit when ready.")}
-
-`);
-    dockerArgs = [
-      "sandbox",
-      "exec",
-      "-it",
-      "-w",
-      projectRoot,
-      sandboxName,
-      agent
-    ];
-  } else if (agent === "codex") {
-    process.stderr.write(`Creating sandbox ${bold(sandboxName)} with workspace ${dim(projectRoot)}...
+  if (!isSandboxAlive(sandboxName)) {
+    process.stderr.write(`${red("✗")} ${agent} sandbox is not running: ${dim(sandboxName)}
 `);
-    try {
-      execSync19(`docker sandbox run --name ${sandboxName} claude ${projectRoot} -- --version`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
-    } catch {}
-    if (!isSandboxAlive(sandboxName)) {
-      process.stderr.write(`${red("✗")} Failed to create sandbox.
+    process.stderr.write(`  Recreate it with ${cyan("locus sandbox")}.
 `);
-      return;
-    }
+    return;
+  }
+  if (agent === "codex") {
     await ensureCodexInSandbox(sandboxName);
-    process.stderr.write(`${dim("Login and then exit when ready.")}
-
-`);
-    dockerArgs = [
-      "sandbox",
-      "exec",
-      "-it",
-      "-w",
-      projectRoot,
-      sandboxName,
-      "codex"
-    ];
-  } else {
-    process.stderr.write(`Creating sandbox ${bold(sandboxName)} with workspace ${dim(projectRoot)}...
+  }
+  process.stderr.write(`Connecting to ${agent} sandbox ${dim(sandboxName)}...
 `);
-    process.stderr.write(`${dim("Login and then exit when ready.")}
+  process.stderr.write(`${dim("Login and then exit when ready.")}
 
 `);
-    dockerArgs = ["sandbox", "run", "--name", sandboxName, agent, projectRoot];
-  }
-  const child = spawn6("docker", dockerArgs, {
+  const child = spawn6("docker", ["sandbox", "exec", "-it", "-w", projectRoot, sandboxName, agent], {
     stdio: "inherit"
   });
   await new Promise((resolve2) => {
@@ -11661,25 +11419,30 @@ ${yellow("⚠")} ${agent} exited with code ${code}.
 }
 function handleRemove(projectRoot) {
   const config = loadConfig(projectRoot);
-  if (!config.sandbox.name) {
-    process.stderr.write(`${dim("No sandbox to remove.")}
+  const names = Array.from(new Set(Object.values(config.sandbox.providers).filter((value) => typeof value === "string" && value.length > 0)));
+  if (names.length === 0) {
+    config.sandbox.enabled = false;
+    config.sandbox.providers = {};
+    saveConfig(projectRoot, config);
+    process.stderr.write(`${dim("No sandboxes to remove. Sandbox mode disabled.")}
 `);
     return;
   }
-  const sandboxName = config.sandbox.name;
-  process.stderr.write(`Removing sandbox ${bold(sandboxName)}...
+  for (const sandboxName of names) {
+    process.stderr.write(`Removing sandbox ${bold(sandboxName)}...
 `);
-  try {
-    execSync19(`docker sandbox rm ${sandboxName}`, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 15000
-    });
-  } catch {}
-  config.sandbox.name = undefined;
+    try {
+      execSync17(`docker sandbox rm ${sandboxName}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 15000
+      });
+    } catch {}
+  }
+  config.sandbox.providers = {};
   config.sandbox.enabled = false;
   saveConfig(projectRoot, config);
-  process.stderr.write(`${green("✓")} Sandbox removed. Sandbox mode disabled.
+  process.stderr.write(`${green("✓")} Provider sandboxes removed. Sandbox mode disabled.
 `);
 }
 function handleStatus(projectRoot) {
@@ -11690,24 +11453,338 @@ ${bold("Sandbox Status")}
 `);
   process.stderr.write(`  ${dim("Enabled:")}  ${config.sandbox.enabled ? green("yes") : red("no")}
 `);
-  process.stderr.write(`  ${dim("Name:")}     ${config.sandbox.name ? bold(config.sandbox.name) : dim("(none)")}
-`);
-  if (config.sandbox.name) {
-    const alive = isSandboxAlive(config.sandbox.name);
-    process.stderr.write(`  ${dim("Running:")}  ${alive ? green("yes") : red("no")}
+  for (const provider of PROVIDERS) {
+    const name = config.sandbox.providers[provider];
+    process.stderr.write(`  ${dim(`${provider}:`).padEnd(15)}${name ? bold(name) : dim("(not configured)")}
 `);
-    if (!alive) {
-      process.stderr.write(`
-  ${yellow("⚠")} Sandbox is not running. Run ${bold("locus sandbox")} to create a new one.
+    if (name) {
+      const alive = isSandboxAlive(name);
+      process.stderr.write(`  ${dim(`${provider} running:`).padEnd(15)}${alive ? green("yes") : red("no")}
 `);
     }
   }
+  if (!config.sandbox.providers.claude || !config.sandbox.providers.codex) {
+    process.stderr.write(`
+  ${yellow("⚠")} Provider sandboxes are incomplete. Run ${bold("locus sandbox")}.
+`);
+  }
   process.stderr.write(`
 `);
 }
+function parseSandboxInstallArgs(args) {
+  const packages = [];
+  let provider = "all";
+  for (let i = 0;i < args.length; i++) {
+    const token = args[i];
+    if (token === "--provider") {
+      const value = args[i + 1];
+      if (!value) {
+        return {
+          provider,
+          packages,
+          error: "Missing value for --provider (expected claude, codex, or all)."
+        };
+      }
+      if (value !== "claude" && value !== "codex" && value !== "all") {
+        return {
+          provider,
+          packages,
+          error: `Invalid provider "${value}". Expected claude, codex, or all.`
+        };
+      }
+      provider = value;
+      i++;
+      continue;
+    }
+    if (token.startsWith("--provider=")) {
+      const value = token.slice("--provider=".length);
+      if (value !== "claude" && value !== "codex" && value !== "all") {
+        return {
+          provider,
+          packages,
+          error: `Invalid provider "${value}". Expected claude, codex, or all.`
+        };
+      }
+      provider = value;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      return {
+        provider,
+        packages,
+        error: `Unknown option "${token}".`
+      };
+    }
+    packages.push(token);
+  }
+  if (packages.length === 0) {
+    return {
+      provider,
+      packages,
+      error: "Usage: locus sandbox install <package...> [--provider claude|codex|all]"
+    };
+  }
+  return { provider, packages };
+}
+async function handleInstall(projectRoot, args) {
+  const parsed = parseSandboxInstallArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${red("✗")} ${parsed.error}
+`);
+    return;
+  }
+  const config = loadConfig(projectRoot);
+  const targets = getTargetProviders(config.sandbox.providers, parsed.provider);
+  if (targets.length === 0) {
+    process.stderr.write(`${red("✗")} No provider sandboxes are configured. Run ${cyan("locus sandbox")} first.
+`);
+    return;
+  }
+  let anySucceeded = false;
+  let anyFailed = false;
+  for (const provider of targets) {
+    const sandboxName = config.sandbox.providers[provider];
+    if (!sandboxName) {
+      process.stderr.write(`${yellow("⚠")} ${provider} sandbox is not configured. Run ${cyan("locus sandbox")} first.
+`);
+      anyFailed = true;
+      continue;
+    }
+    if (!isSandboxAlive(sandboxName)) {
+      process.stderr.write(`${yellow("⚠")} ${provider} sandbox is not running: ${dim(sandboxName)}
+`);
+      anyFailed = true;
+      continue;
+    }
+    process.stderr.write(`Installing ${bold(parsed.packages.join(", "))} in ${provider} sandbox ${dim(sandboxName)}...
+`);
+    const ok = await runInteractiveCommand("docker", [
+      "sandbox",
+      "exec",
+      sandboxName,
+      "npm",
+      "install",
+      "-g",
+      ...parsed.packages
+    ]);
+    if (ok) {
+      anySucceeded = true;
+      process.stderr.write(`${green("✓")} Installed package(s) in ${provider} sandbox.
+`);
+    } else {
+      anyFailed = true;
+      process.stderr.write(`${red("✗")} Failed to install package(s) in ${provider} sandbox.
+`);
+    }
+  }
+  if (!anySucceeded && anyFailed) {
+    process.stderr.write(`${yellow("⚠")} No package installs completed successfully.
+`);
+  }
+}
+function parseSandboxExecArgs(args) {
+  if (args.length === 0) {
+    return {
+      command: [],
+      error: "Usage: locus sandbox exec <provider> -- <command...>"
+    };
+  }
+  const provider = args[0];
+  if (provider !== "claude" && provider !== "codex") {
+    return {
+      command: [],
+      error: `Invalid provider "${provider}". Expected claude or codex.`
+    };
+  }
+  const separatorIndex = args.indexOf("--");
+  const command = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : args.slice(1);
+  if (command.length === 0) {
+    return {
+      provider,
+      command: [],
+      error: "Missing command. Example: locus sandbox exec codex -- bun --version"
+    };
+  }
+  return { provider, command };
+}
+async function handleExec(projectRoot, args) {
+  const parsed = parseSandboxExecArgs(args);
+  if (parsed.error || !parsed.provider) {
+    process.stderr.write(`${red("✗")} ${parsed.error}
+`);
+    return;
+  }
+  const sandboxName = getActiveProviderSandbox(projectRoot, parsed.provider);
+  if (!sandboxName) {
+    return;
+  }
+  await runInteractiveCommand("docker", [
+    "sandbox",
+    "exec",
+    "-w",
+    projectRoot,
+    sandboxName,
+    ...parsed.command
+  ]);
+}
+async function handleShell(projectRoot, args) {
+  const provider = args[0];
+  if (provider !== "claude" && provider !== "codex") {
+    process.stderr.write(`${red("✗")} Usage: locus sandbox shell <provider>  (provider: claude|codex)
+`);
+    return;
+  }
+  const sandboxName = getActiveProviderSandbox(projectRoot, provider);
+  if (!sandboxName) {
+    return;
+  }
+  process.stderr.write(`Opening shell in ${provider} sandbox ${dim(sandboxName)}...
+`);
+  await runInteractiveCommand("docker", [
+    "sandbox",
+    "exec",
+    "-it",
+    "-w",
+    projectRoot,
+    sandboxName,
+    "sh"
+  ]);
+}
+function parseSandboxLogsArgs(args) {
+  if (args.length === 0) {
+    return {
+      follow: false,
+      error: "Usage: locus sandbox logs <provider> [--follow] [--tail <lines>]"
+    };
+  }
+  const provider = args[0];
+  if (provider !== "claude" && provider !== "codex") {
+    return {
+      follow: false,
+      error: `Invalid provider "${provider}". Expected claude or codex.`
+    };
+  }
+  let follow = false;
+  let tail;
+  for (let i = 1;i < args.length; i++) {
+    const token = args[i];
+    if (token === "--follow" || token === "-f") {
+      follow = true;
+      continue;
+    }
+    if (token === "--tail") {
+      const value = args[i + 1];
+      if (!value) {
+        return { provider, follow, tail, error: "Missing value for --tail." };
+      }
+      const parsedTail = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsedTail) || parsedTail < 0) {
+        return { provider, follow, tail, error: "Invalid --tail value." };
+      }
+      tail = parsedTail;
+      i++;
+      continue;
+    }
+    if (token.startsWith("--tail=")) {
+      const value = token.slice("--tail=".length);
+      const parsedTail = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsedTail) || parsedTail < 0) {
+        return { provider, follow, tail, error: "Invalid --tail value." };
+      }
+      tail = parsedTail;
+      continue;
+    }
+    return {
+      provider,
+      follow,
+      tail,
+      error: `Unknown option "${token}".`
+    };
+  }
+  return { provider, follow, tail };
+}
+async function handleLogs(projectRoot, args) {
+  const parsed = parseSandboxLogsArgs(args);
+  if (parsed.error || !parsed.provider) {
+    process.stderr.write(`${red("✗")} ${parsed.error}
+`);
+    return;
+  }
+  const sandboxName = getActiveProviderSandbox(projectRoot, parsed.provider);
+  if (!sandboxName) {
+    return;
+  }
+  const dockerArgs = ["sandbox", "logs"];
+  if (parsed.follow) {
+    dockerArgs.push("--follow");
+  }
+  if (parsed.tail !== undefined) {
+    dockerArgs.push("--tail", String(parsed.tail));
+  }
+  dockerArgs.push(sandboxName);
+  await runInteractiveCommand("docker", dockerArgs);
+}
+function buildProviderSandboxNames(projectRoot) {
+  const segment = sanitizeSegment(basename4(projectRoot));
+  const hash = createHash("sha1").update(projectRoot).digest("hex").slice(0, 8);
+  return {
+    claude: `locus-${segment}-claude-${hash}`,
+    codex: `locus-${segment}-codex-${hash}`
+  };
+}
+function sanitizeSegment(input) {
+  const cleaned = input.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return cleaned || "workspace";
+}
+function getTargetProviders(sandboxes, provider) {
+  if (provider === "claude" || provider === "codex") {
+    return [provider];
+  }
+  return PROVIDERS.filter((name) => Boolean(sandboxes[name]));
+}
+function getActiveProviderSandbox(projectRoot, provider) {
+  const config = loadConfig(projectRoot);
+  const sandboxName = config.sandbox.providers[provider];
+  if (!sandboxName) {
+    process.stderr.write(`${red("✗")} No ${provider} sandbox configured. Run ${cyan("locus sandbox")} first.
+`);
+    return null;
+  }
+  if (!isSandboxAlive(sandboxName)) {
+    process.stderr.write(`${red("✗")} ${provider} sandbox is not running: ${dim(sandboxName)}
+`);
+    process.stderr.write(`  Recreate it with ${cyan("locus sandbox")}.
+`);
+    return null;
+  }
+  return sandboxName;
+}
+function runInteractiveCommand(command, args) {
+  return new Promise((resolve2) => {
+    const child = spawn6(command, args, { stdio: "inherit" });
+    child.on("close", (code) => resolve2(code === 0));
+    child.on("error", () => resolve2(false));
+  });
+}
+async function createProviderSandbox(provider, sandboxName, projectRoot) {
+  try {
+    execSync17(`docker sandbox run --name ${sandboxName} claude ${projectRoot} -- --version`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 120000
+    });
+  } catch {}
+  if (!isSandboxAlive(sandboxName)) {
+    return false;
+  }
+  if (provider === "codex") {
+    await ensureCodexInSandbox(sandboxName);
+  }
+  await enforceSandboxIgnore(sandboxName, projectRoot);
+  return true;
+}
 async function ensureCodexInSandbox(sandboxName) {
   try {
-    execSync19(`docker sandbox exec ${sandboxName} which codex`, {
+    execSync17(`docker sandbox exec ${sandboxName} which codex`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
     });
@@ -11715,7 +11792,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 });
+      execSync17(`docker sandbox exec ${sandboxName} npm install -g @openai/codex`, { stdio: "inherit", timeout: 120000 });
     } catch {
       process.stderr.write(`${red("✗")} Failed to install codex in sandbox.
 `);
@@ -11724,7 +11801,7 @@ async function ensureCodexInSandbox(sandboxName) {
 }
 function isSandboxAlive(name) {
   try {
-    const output = execSync19("docker sandbox ls", {
+    const output = execSync17("docker sandbox ls", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -11734,11 +11811,13 @@ function isSandboxAlive(name) {
     return false;
   }
 }
+var PROVIDERS;
 var init_sandbox2 = __esm(() => {
   init_config();
   init_sandbox();
   init_sandbox_ignore();
   init_terminal();
+  PROVIDERS = ["claude", "codex"];
 });
 
 // src/cli.ts