@fitlab-ai/agent-infra 0.8.5 → 0.9.1

package/lib/sandbox/commands/create.ts

@@ -24,6 +24,12 @@ import {
   worktreeDirCandidates
 } from '../constants.ts';
 import { prepareDockerfile } from '../dockerfile.ts';
+import {
+  assertBuildProxyCompatibility,
+  buildProxyFailureHint,
+  prepareBuildProxy,
+  redactBuildProxyValues
+} from '../build-proxy.ts';
 import { detectEngine, ensureDocker } from '../engine.ts';
 import {
   commandForEngine,
@@ -39,10 +45,18 @@ import {
 import { resolveTaskBranch } from '../task-resolver.ts';
 import {
   resolveTools,
+  tmpfsSeedStagingPath,
+  tmpfsSeedTargetPath,
   toolConfigDirCandidates
 } from '../tools.ts';
-import type { SandboxTool } from '../tools.ts';
+import type { SandboxTool, TmpfsSeedEntry } from '../tools.ts';
+import {
+  assertFreshSandboxReady,
+  hydrateTmpfsSeedEntries,
+  prepareTmpfsMounts
+} from '../recovery.ts';
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.ts';
+import { sandboxCoreBindMounts } from '../mounts.ts';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.ts';
 import { validateSelinuxDisableEnv } from '../engines/selinux.ts';
 import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.ts';
@@ -87,7 +101,7 @@ alias gy='gemini --yolo; tput ed'
 `;
 const CONTAINER_HOME = '/home/devuser';
 const CONTAINER_SHELL_CONFIG_MOUNT = `${CONTAINER_HOME}/.host-shell-config`;
-const USAGE = `Usage: ai sandbox create <branch> [base] [--cpu <n>] [--memory <n>] [--no-refresh] [--inherit-proxy|-P]
+const USAGE = `Usage: ai sandbox create <branch> [base] [--cpu <n>] [--memory <n>] [--no-refresh] [--inherit-proxy|-P] [--inherit-build-proxy|-B]
 
 Host aliases:
   ${'~'}/.agent-infra/aliases/sandbox.sh is auto-created on first run and exposed
@@ -97,7 +111,9 @@ Host aliases:
 
 Proxy:
   --inherit-proxy, -P  Copy non-empty standard host proxy variables into the
-                       container environment through the private env file.`;
+                       container environment through the private env file.
+  --inherit-build-proxy, -B  Pass uppercase HTTP_PROXY, HTTPS_PROXY, and NO_PROXY
+                             to managed image build steps for this invocation.`;
 const HOST_PROXY_ENV_KEYS = [
   'http_proxy',
   'HTTP_PROXY',
@@ -108,13 +124,20 @@ const HOST_PROXY_ENV_KEYS = [
   'no_proxy',
   'NO_PROXY'
 ] as const;
+const MANAGED_GITHUB_GIT_CONFIG = [
+  '[credential]',
+  '\thelper = !gh auth git-credential',
+  '[credential "https://github.com"]',
+  '\thelper =',
+  '\thelper = !gh auth git-credential',
+  '[url "https://github.com/"]',
+  '\tinsteadOf = git@github.com:'
+];
 
 type SandboxCreateConfig = ReturnType<typeof loadConfig>;
 type PreparedDockerfile = ReturnType<typeof prepareDockerfile>;
 type ResolvedTool = { tool: SandboxTool; dir: string };
-type TmpfsSeedPlanEntry = {
-  stagingPath: string;
-  targetPath: string;
+type TmpfsSeedPlanEntry = TmpfsSeedEntry & {
   volumeArgs: string[];
 };
 type RuntimeCheck = { name: string; cmd: string[] };
@@ -128,9 +151,9 @@ type ExecSyncOptions = ExecFileSyncOptions & {
 };
 type ExecSyncFn = (cmd: string, args: string[], options?: ExecSyncOptions) => Buffer | string;
 type EngineExecFn = (engine: string, cmd: string, args: string[], opts?: ExecFileSyncOptions) => Buffer | string;
-type EngineRunFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string }) => string;
+type EngineRunFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string; env?: NodeJS.ProcessEnv }) => string;
 type EngineRunSafeFn = EngineRunFn;
-type EngineRunVerboseFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string }) => void;
+type EngineRunVerboseFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string; env?: NodeJS.ProcessEnv }) => void;
 type DirectRunFn = (cmd: string, args: string[], opts?: { cwd?: string }) => string;
 type DirectRunSafeFn = DirectRunFn;
 type DirectRunVerboseFn = (cmd: string, args: string[], opts?: { cwd?: string }) => void;
@@ -249,6 +272,16 @@ function normalizeContainerHomeSeparators(content: string): string {
   return content.replace(containerHomePattern, (value) => value.replaceAll('\\', '/'));
 }
 
+function isGitHubCliCredentialHelper(line: string): boolean {
+  const helperMatch = line.match(/^\s*helper\s*=\s*(.+?)\s*$/i);
+  if (!helperMatch) {
+    return false;
+  }
+
+  const helper = (helperMatch[1] ?? '').trim().replace(/^"(.*)"$/, '$1');
+  return /^!\s*(?:"[^"]*[\\/]+gh"|(?:\S*[\\/]+)?gh)\s+auth\s+git-credential(?:\s|$)/i.test(helper);
+}
+
 export function sanitizeGitConfig(
   gitconfig: string,
   home: string,
@@ -266,11 +299,13 @@ export function sanitizeGitConfig(
   const sanitized = [];
   let inGpgSection = false;
   let currentSection = '';
+  let currentSectionName = '';
 
   for (const line of lines) {
     const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*$/);
     if (sectionMatch) {
       const sectionName = (sectionMatch[1] ?? '').trim();
+      currentSectionName = sectionName;
       currentSection = ((sectionName.match(/^([^\s"]+)/)?.[1]) ?? '').toLowerCase();
       inGpgSection = /^gpg(?:\s+"[^"]+")?$/i.test(sectionName);
       if (stripGpg && inGpgSection) {
@@ -298,11 +333,23 @@ export function sanitizeGitConfig(
     if (stripGpg && currentSection === 'user' && /^\s*signingKey\s*=.*$/i.test(line)) {
       continue;
     }
+    if (currentSection === 'credential' && isGitHubCliCredentialHelper(line)) {
+      continue;
+    }
+    if (
+      /^url\s+"https:\/\/github\.com\/"$/i.test(currentSectionName)
+      && /^\s*insteadOf\s*=\s*git@github\.com:\s*$/i.test(line)
+    ) {
+      continue;
+    }
 
     sanitized.push(line);
   }
 
-  return appendSafeDirectories(sanitized, repoRoot).join('\n');
+  return [
+    ...appendSafeDirectories(sanitized, repoRoot),
+    ...MANAGED_GITHUB_GIT_CONFIG
+  ].join('\n');
 }
 
 export function hostHasGpgKeys(home: string, execFn: ExecSyncFn = execFileSync): boolean {
@@ -1225,7 +1272,9 @@ export function buildImage(
     runVerboseFn = runVerboseEngine,
     env = process.env,
     refresh = false,
-    lastRefresh
+    lastRefresh,
+    buildProxyArgs = [],
+    buildEnv
   }: {
     engine?: string;
     runFn?: EngineRunFn;
@@ -1234,6 +1283,8 @@ export function buildImage(
     env?: NodeJS.ProcessEnv;
     refresh?: boolean;
     lastRefresh?: number;
+    buildProxyArgs?: string[];
+    buildEnv?: NodeJS.ProcessEnv;
   } = {}
 ): void {
   const selectedEngine = engine ?? detectEngine({ engine: config.engine });
@@ -1246,9 +1297,10 @@ export function buildImage(
       runSafeFn,
       env,
       refresh,
-      lastRefresh
+      lastRefresh,
+      buildProxyArgs
     }),
-    { cwd: config.repoRoot }
+    { cwd: config.repoRoot, env: buildEnv }
   );
 }
 
@@ -1272,6 +1324,7 @@ export async function create(args: string[]): Promise<void> {
       memory: { type: 'string' },
       'no-refresh': { type: 'boolean' },
       'inherit-proxy': { type: 'boolean', short: 'P' },
+      'inherit-build-proxy': { type: 'boolean', short: 'B' },
       help: { type: 'boolean', short: 'h' }
     }
   });
@@ -1323,6 +1376,7 @@ export async function create(args: string[]): Promise<void> {
   const baseBranch = base ?? runSafe('git', ['-C', effectiveConfig.repoRoot, 'branch', '--show-current']);
   const expectedImageSignature = buildImageSignature(preparedDockerfile, tools);
   const engine = detectEngine(effectiveConfig);
+  let createdTmpfsSeedPlan: TmpfsSeedPlanEntry[] = [];
 
   p.intro(pc.cyan('AI Sandbox'));
   p.log.info(
@@ -1356,6 +1410,15 @@ export async function create(args: string[]): Promise<void> {
     const needsImageBuild = signatureStale || refreshDue;
 
     if (needsImageBuild) {
+      if (values['inherit-build-proxy'] && effectiveConfig.dockerfile) {
+        throw new Error('Build proxy inheritance is unavailable with a custom sandbox Dockerfile.');
+      }
+      const buildProxy = prepareBuildProxy(
+        values['inherit-build-proxy'] ?? false,
+        process.env,
+        engine
+      );
+      if (values['inherit-build-proxy']) assertBuildProxyCompatibility(engine);
       const buildRefresh = !imageExists || refreshDue;
       const buildLastRefresh = buildRefresh ? now : currentLastRefresh || 0;
 
@@ -1372,7 +1435,13 @@ export async function create(args: string[]): Promise<void> {
           tools,
           preparedDockerfile.path,
           expectedImageSignature,
-          { engine, refresh: buildRefresh, lastRefresh: buildLastRefresh }
+          {
+            engine,
+            refresh: buildRefresh,
+            lastRefresh: buildLastRefresh,
+            buildProxyArgs: buildProxy.args,
+            buildEnv: buildProxy.env
+          }
         );
         p.log.success(
           refreshDue
@@ -1385,10 +1454,14 @@ export async function create(args: string[]): Promise<void> {
         if (refreshDue && !signatureStale && imageExists) {
           p.log.warn(
             'Scheduled sandbox image refresh failed; continuing with the existing image. ' +
-            commandErrorMessage(error)
+            redactBuildProxyValues(commandErrorMessage(error), buildProxy.redactionValues)
+            + (values['inherit-build-proxy'] ? ` ${buildProxyFailureHint(engine)}` : '')
           );
         } else {
-          throw error;
+          const hint = values['inherit-build-proxy'] ? `\n${buildProxyFailureHint(engine)}` : '';
+          throw new Error(
+            `${redactBuildProxyValues(commandErrorMessage(error), buildProxy.redactionValues)}${hint}`
+          );
         }
       }
     } else {
@@ -1571,9 +1644,12 @@ export async function create(args: string[]): Promise<void> {
               branch,
               repoRoot: effectiveConfig.repoRoot
             });
-            const shellConfigVolumes = hostShellConfig.mounts.flatMap(({ hostPath, containerPath }) => [
+            const coreVolumes = sandboxCoreBindMounts(effectiveConfig, branch, {
+              worktree,
+              shellConfigHostDir: hostShellConfig.hostDir
+            }).flatMap(({ hostPaths, containerPath, readOnly }) => [
               '-v',
-              volumeArg(engine, hostPath, containerPath, ':ro')
+              volumeArg(engine, hostPaths[0]!, containerPath, readOnly ? ':ro' : '')
             ]);
             // Mount each declared seed read-only at an isolated staging path.
             // After docker run mounts the empty tmpfs, the container's default
@@ -1583,14 +1659,17 @@ export async function create(args: string[]): Promise<void> {
             // being exposed or written through.
             tmpfsSeedPlan = effectiveResolvedTools.flatMap(({ tool, dir }) =>
               (tool.tmpfs?.seed ?? []).flatMap((entry, index) => {
+                const targetPath = tmpfsSeedTargetPath(tool.containerMount, entry);
                 const hostPath = path.join(dir, entry);
                 if (!fs.existsSync(hostPath)) {
                   return [];
                 }
-                const stagingPath = path.posix.join('/run/agent-infra/tmpfs-seeds', tool.id, String(index));
+                const stagingPath = tmpfsSeedStagingPath(tool.id, index);
                 return [{
+                  toolId: tool.id,
+                  containerMount: tool.containerMount,
                   stagingPath,
-                  targetPath: path.posix.join(tool.containerMount, entry),
+                  targetPath,
                   volumeArgs: ['-v', volumeArg(engine, hostPath, stagingPath, ':ro')]
                 }];
               })
@@ -1630,14 +1709,7 @@ export async function create(args: string[]): Promise<void> {
               sandboxLabel(effectiveConfig),
               '--label',
               `${sandboxBranchLabel(effectiveConfig)}=${branch}`,
-              '-v',
-              volumeArg(engine, worktree, '/workspace'),
-              '-v',
-              volumeArg(engine, workspaceDir, '/workspace/.agents/workspace'),
-              '-v',
-              volumeArg(engine, shareCommon, '/share/common'),
-              '-v',
-              volumeArg(engine, shareBranch, '/share/branch'),
+              ...coreVolumes,
               ...buildClipboardVolumeArgs(engine, effectiveConfig.home),
               '-v',
               volumeArg(
@@ -1650,25 +1722,30 @@ export async function create(args: string[]): Promise<void> {
               ...tmpfsArgs,
               ...tmpfsSeedPlan.flatMap(({ volumeArgs }) => volumeArgs),
               ...liveMountVolumes,
-              ...shellConfigVolumes,
               ...envFile.dockerArgs,
               ...tzFlags,
               '-w',
               '/workspace',
               effectiveConfig.imageName
             ]);
+            createdTmpfsSeedPlan = tmpfsSeedPlan;
           } finally {
             envFile.cleanup();
           }
 
-          for (const { stagingPath, targetPath } of tmpfsSeedPlan) {
-            runEngineTaskCommand(engine, 'docker', [
-              'exec', container, 'mkdir', '-p', path.posix.dirname(targetPath)
-            ]);
-            runEngineTaskCommand(engine, 'docker', [
-              'exec', container, 'cp', '-R', '--', stagingPath, targetPath
-            ]);
-          }
+          prepareTmpfsMounts({
+            engine,
+            container,
+            mountPaths: effectiveResolvedTools
+              .filter(({ tool }) => tool.tmpfs)
+              .map(({ tool }) => tool.containerMount)
+          });
+          hydrateTmpfsSeedEntries({
+            engine,
+            container,
+            entries: tmpfsSeedPlan,
+            replace: true
+          });
 
           // Belt-and-suspenders: re-create the four shell-config symlinks at
           // runtime so users with a custom `sandbox.dockerfile` (which won't
@@ -1737,6 +1814,13 @@ export async function create(args: string[]): Promise<void> {
   }
 
   p.log.step('Verifying setup...');
+  assertFreshSandboxReady({
+    config: effectiveConfig,
+    engine,
+    branch,
+    container,
+    copiedEntries: createdTmpfsSeedPlan
+  });
   const runningContainers = runSafeEngine(engine, 'docker', ['ps', '--format', '{{.Names}}']).split('\n');
   const checks = [
     { name: 'Container running', ok: runningContainers.includes(container) },

package/lib/sandbox/commands/enter.ts

@@ -6,6 +6,7 @@ import {
   sandboxLabel
 } from '../constants.ts';
 import { detectEngine } from '../engine.ts';
+import { ensureSandboxReady } from '../recovery.ts';
 import {
   formatCredentialWarnings,
   formatRemaining,
@@ -22,15 +23,15 @@ import {
   fetchSandboxRows,
   resolveBranchArg,
   selectSandboxContainer,
-  startSandboxContainer
 } from './list-running.ts';
 
-const USAGE = `Usage: ai sandbox exec <branch | TASK-id | N | '#N'> [cmd...]
+const USAGE = `Usage: ai sandbox exec [--recreate] <branch | TASK-id | N> [cmd...]
 
-N (bare) and '#N' both reference the same active task short id from
+N references an active task short id from
 .agents/workspace/active/.short-ids.json. They resolve only via that
 registry — they do not reference a container's row position in
-'ai sandbox ls' output.`;
+'ai sandbox ls' output. --recreate is a host recovery flag only before the
+target; the same token after the target is passed to the container command.`;
 const TMUX_ENTRY_PATH = '/usr/local/bin/sandbox-tmux-entry';
 
 // Terminal-detection variables that interactive TUIs (e.g. claude-code)
@@ -123,6 +124,24 @@ export function formatCredentialSyncStatus(
   return null;
 }
 
+export function parseEnterArgs(args: string[]): {
+  target: string;
+  command: string[];
+  recreate: boolean;
+} {
+  let recreate = false;
+  let index = 0;
+  while (args[index] === '--recreate') {
+    recreate = true;
+    index += 1;
+  }
+  const target = args[index] ?? '';
+  if (!target) {
+    throw new Error(USAGE);
+  }
+  return { target, command: args.slice(index + 1), recreate };
+}
+
 export async function enter(args: string[]): Promise<number> {
   if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
     process.stdout.write(`${USAGE}\n`);
@@ -135,8 +154,8 @@ export async function enter(args: string[]): Promise<number> {
   const config = loadConfig();
   validateClaudeCredentialsEnvOverride();
   const engine = detectEngine(config);
-  const [firstArg = '', ...cmd] = args;
-  const branch = resolveBranchArg(firstArg, { repoRoot: config.repoRoot });
+  const parsed = parseEnterArgs(args);
+  const branch = resolveBranchArg(parsed.target, { repoRoot: config.repoRoot });
   assertValidBranchName(branch);
 
   const { running, nonRunning } = fetchSandboxRows(
@@ -154,11 +173,19 @@ export async function enter(args: string[]): Promise<number> {
       `No sandbox found for branch '${branch}'. Run 'ai sandbox create ${branch}' to create one.`
     );
   }
-  if (!found.running) {
-    process.stderr.write(`Sandbox '${found.name}' is stopped; starting it...\n`);
-    startSandboxContainer(engine, found.name);
-  }
-  const container = found.name;
+  const ready = await ensureSandboxReady({
+    config,
+    engine,
+    branch,
+    row: found,
+    allowRecreate: parsed.recreate,
+    recreate: async (targetBranch) => {
+      const { create } = await import('./create.ts');
+      await create([targetBranch, '--no-refresh']);
+    }
+  });
+  const container = ready.container;
+  const cmd = parsed.command;
 
   if (config.tools.includes('claude-code')) {
     try {

package/lib/sandbox/commands/list-running.ts

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { runSafeEngine, runVerboseEngine } from '../shell.ts';
 import { resolveTaskBranch } from '../task-resolver.ts';
+import { isRemovedHashShortIdInput } from '../../task/short-id.ts';
 
 export type SandboxRow = {
   name: string;
@@ -90,13 +91,13 @@ export function fetchSandboxRows(
 
 /**
  * Returns true iff `arg` is a syntactically valid task short reference.
- * Accepts both bare numeric ('11') and '#'-prefixed ('#11') forms.
+ * Accepts bare numeric ('11') task short ids.
  * Zero IO. Callers MUST use this as the gate before constructing any context
  * for resolveTaskShortRef — that way non-matching arguments (e.g. '#abc',
  * '#1.5', '#') never trigger sandbox list IO.
  */
 export function isTaskShortRef(arg: string): boolean {
-  return /^#?\d+$/.test(arg);
+  return /^\d+$/.test(arg);
 }
 
 type RegistryLookup =
@@ -115,9 +116,7 @@ type RegistryLookup =
 function tryResolveFromRegistry(arg: string, repoRoot: string): RegistryLookup {
   const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
   if (!fs.existsSync(scriptPath)) return { status: 'miss' };
-  // Strip leading '#' when forwarding bare-numeric input through the script's CLI.
-  // (Script accepts both forms, but this avoids shell quoting confusion in error
-  // messages echoed back to the user.)
+  // Forward the bare-numeric short ref to the registry script for ID resolution.
   const result = spawnSync('node', [scriptPath, 'resolve', arg], { encoding: 'utf8', cwd: repoRoot });
   if (result.status !== 0) return { status: 'miss' };
   const taskId = (result.stdout || '').trim();
@@ -149,7 +148,7 @@ function tryResolveFromRegistry(arg: string, repoRoot: string): RegistryLookup {
 
 /**
 /**
- * Resolve a task short reference (bare 'N' or '#N') to a branch name for the
+ * Resolve a bare task short reference to a branch name for the
  * sandbox entrypoint.
  *
  * Resolution: registry-only. Look up the short id in the global task-short-id
@@ -169,13 +168,13 @@ export function resolveTaskShortRef(
   if (lookup.status === 'hit') return lookup.branch;
   throw new Error(
     `short ref '${arg}' is not in the active task registry. ` +
-      `'#N' and bare N resolve only via the registry (not by row position in 'ai sandbox ls'); ` +
+      `bare N resolves only via the registry (not by row position in 'ai sandbox ls'); ` +
       `use a task short id (e.g. 'ai sandbox exec 11'), a TASK-id, or a branch name.`
   );
 }
 
 /**
- * Resolve a sandbox command argument (`<branch | TASK-id | N | '#N'>`) to a
+ * Resolve a sandbox command argument (`<branch | TASK-id | N>`) to a
  * branch name, mirroring `ai sandbox exec` so that `start` and `exec` share one
  * input contract. Short refs go through the registry-only resolver (which throws
  * an actionable error on a miss); everything else flows through resolveTaskBranch
@@ -183,6 +182,9 @@ export function resolveTaskShortRef(
  * Callers still run assertValidBranchName on the result.
  */
 export function resolveBranchArg(arg: string, ctx: { repoRoot: string }): string {
+  if (isRemovedHashShortIdInput(arg)) {
+    throw new Error(`Invalid task short id '${arg}': task short ids must use bare digits`);
+  }
   return isTaskShortRef(arg)
     ? resolveTaskShortRef(arg, ctx)
     : resolveTaskBranch(arg, ctx.repoRoot);

package/lib/sandbox/commands/rebuild.ts

@@ -16,8 +16,14 @@ import {
   parseImageLabels,
   parseRefreshTimestamp
 } from '../image-build.ts';
+import {
+  assertBuildProxyCompatibility,
+  buildProxyFailureHint,
+  prepareBuildProxy,
+  redactBuildProxyValues
+} from '../build-proxy.ts';
 
-const USAGE = `Usage: ai sandbox rebuild [--quiet] [--refresh]`;
+const USAGE = `Usage: ai sandbox rebuild [--quiet] [--refresh] [--inherit-build-proxy|-B]`;
 
 type EngineRunFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string }) => string;
 type EngineRunSafeFn = EngineRunFn;
@@ -33,7 +39,8 @@ export function buildArgs(
     runSafeFn = runSafeEngine,
     env = process.env,
     refresh = false,
-    lastRefresh
+    lastRefresh,
+    buildProxyArgs = []
   }: {
     engine?: string;
     runFn?: EngineRunFn;
@@ -41,6 +48,7 @@ export function buildArgs(
     env?: NodeJS.ProcessEnv;
     refresh?: boolean;
     lastRefresh?: number;
+    buildProxyArgs?: string[];
   } = {}
 ): string[] {
   return buildSandboxImageArgs(config, tools, dockerfilePath, imageSignature, {
@@ -49,7 +57,8 @@ export function buildArgs(
     runSafeFn,
     env,
     refresh,
-    lastRefresh
+    lastRefresh,
+    buildProxyArgs
   });
 }
 
@@ -77,6 +86,7 @@ export async function rebuild(args: string[]): Promise<void> {
     options: {
       refresh: { type: 'boolean' },
       quiet: { type: 'boolean', short: 'q' },
+      'inherit-build-proxy': { type: 'boolean', short: 'B' },
       help: { type: 'boolean', short: 'h' }
     }
   });
@@ -95,6 +105,11 @@ export async function rebuild(args: string[]): Promise<void> {
   const engine = detectEngine(config);
 
   await ensureDocker(config, undefined);
+  if (values['inherit-build-proxy'] && config.dockerfile) {
+    throw new Error('Build proxy inheritance is unavailable with a custom sandbox Dockerfile.');
+  }
+  const buildProxy = prepareBuildProxy(values['inherit-build-proxy'] ?? false, process.env, engine);
+  if (values['inherit-build-proxy']) assertBuildProxyCompatibility(engine);
   const lastRefresh = refresh ? Date.now() : readExistingLastRefresh(config, engine);
   p.intro(pc.cyan('Rebuilding sandbox image'));
 
@@ -105,9 +120,11 @@ export async function rebuild(args: string[]): Promise<void> {
       runEngine(engine, 'docker', buildArgs(config, tools, preparedDockerfile.path, imageSignature, {
         engine,
         refresh,
-        lastRefresh
+        lastRefresh,
+        buildProxyArgs: buildProxy.args
       }), {
-        cwd: config.repoRoot
+        cwd: config.repoRoot,
+        env: buildProxy.env
       });
       spinner.stop(pc.green('Sandbox image rebuilt'));
     } else {
@@ -118,13 +135,18 @@ export async function rebuild(args: string[]): Promise<void> {
         buildArgs(config, tools, preparedDockerfile.path, imageSignature, {
           engine,
           refresh,
-          lastRefresh
+          lastRefresh,
+          buildProxyArgs: buildProxy.args
         }),
-        { cwd: config.repoRoot }
+        { cwd: config.repoRoot, env: buildProxy.env }
       );
       p.log.success(pc.green('Sandbox image rebuilt'));
     }
     pruneSandboxDanglingImages(config, engine);
+  } catch (error) {
+    const message = redactBuildProxyValues(error instanceof Error ? error.message : String(error), buildProxy.redactionValues);
+    const hint = values['inherit-build-proxy'] ? `\n${buildProxyFailureHint(engine)}` : '';
+    throw new Error(`${message}${hint}`);
   } finally {
     preparedDockerfile.cleanup();
   }

package/lib/sandbox/commands/show.ts

@@ -7,12 +7,12 @@ import { assertValidBranchName, worktreeDirCandidates } from '../constants.ts';
 import { resolveBranchArg } from './list-running.ts';
 import { resolveTools, toolConfigDirCandidates } from '../tools.ts';
 
-const USAGE = `Usage: ai sandbox show <branch | TASK-id | N | '#N'>
+const USAGE = `Usage: ai sandbox show <branch | TASK-id | N>
 
 Shows one sandbox's worktree path and per-tool state paths (Claude Code,
 Codex, Gemini CLI, OpenCode). The argument follows the same contract as
 'ai sandbox exec' and 'ai sandbox start': N (bare) is the recommended form
-for task short ids (e.g. 'ai sandbox show 11'); '#N', a TASK-id, or a plain
+for task short ids (e.g. 'ai sandbox show 11'); a TASK-id or a plain
 branch name are also accepted. Use 'ai sandbox ls' for the container list.`;
 
 export type SandboxDetail = {