@fitlab-ai/agent-infra 0.7.0 → 0.7.2

package/bin/cli.ts

@@ -18,6 +18,7 @@ Usage:
   agent-infra init            Initialize a new project with update-agent-infra seed command
   agent-infra merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
   agent-infra sandbox         Manage Docker-based AI sandboxes
+  agent-infra task            Read-only views over .agents/workspace tasks (ls / show)
   agent-infra update          Update seed files and sync file registry for an existing project
   agent-infra version         Show version
 
@@ -93,7 +94,17 @@ switch (command) {
     const { runSandbox } = imported;
     await runSandbox(process.argv.slice(3)).catch((e: unknown) => {
       process.stderr.write(`Error: ${errorMessage(e)}\n`);
-      process.exitCode = 1;
+      process.exit(1);
+    });
+    break;
+  }
+  case 'task': {
+    const imported = await importCommand('../lib/task/index.ts');
+    if (!imported) break;
+    const { runTask } = imported;
+    await runTask(process.argv.slice(3)).catch((e: unknown) => {
+      process.stderr.write(`Error: ${errorMessage(e)}\n`);
+      process.exit(1);
     });
     break;
   }

package/dist/bin/cli.js

@@ -22,6 +22,7 @@ Usage:
   agent-infra init            Initialize a new project with update-agent-infra seed command
   agent-infra merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
   agent-infra sandbox         Manage Docker-based AI sandboxes
+  agent-infra task            Read-only views over .agents/workspace tasks (ls / show)
   agent-infra update          Update seed files and sync file registry for an existing project
   agent-infra version         Show version
 
@@ -96,7 +97,18 @@ switch (command) {
         const { runSandbox } = imported;
         await runSandbox(process.argv.slice(3)).catch((e) => {
             process.stderr.write(`Error: ${errorMessage(e)}\n`);
-            process.exitCode = 1;
+            process.exit(1);
+        });
+        break;
+    }
+    case 'task': {
+        const imported = await importCommand('../lib/task/index.ts');
+        if (!imported)
+            break;
+        const { runTask } = imported;
+        await runTask(process.argv.slice(3)).catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exit(1);
         });
         break;
     }

package/dist/lib/builtin-tuis.js

@@ -0,0 +1,45 @@
+const BUILTIN_TUI_IDS = ['claude-code', 'codex', 'gemini-cli', 'opencode'];
+const BUILTIN_TUI_DISPLAY = {
+    'claude-code': 'Claude Code',
+    'codex': 'Codex',
+    'gemini-cli': 'Gemini CLI',
+    'opencode': 'OpenCode'
+};
+const BUILTIN_TUI_OWNED_PATH_PREFIXES = {
+    'claude-code': ['.claude/'],
+    'codex': ['.codex/'],
+    'gemini-cli': ['.gemini/'],
+    'opencode': ['.opencode/']
+};
+function isBuiltinTUIId(value) {
+    return typeof value === 'string' && BUILTIN_TUI_IDS.includes(value);
+}
+function resolveEnabledTUIs(value) {
+    // Missing field / null / non-array → full set (backward compat for legacy
+    // .airc.json predating the `tuis` field).
+    if (!Array.isArray(value))
+        return new Set(BUILTIN_TUI_IDS);
+    // Empty array is a meaningful, user-set value: "no built-in TUI managed".
+    // This supports the customTUI-only project layout.
+    const set = new Set();
+    for (const v of value) {
+        if (isBuiltinTUIId(v))
+            set.add(v);
+    }
+    return set;
+}
+function isPathOwnedByDisabledTUI(rel, enabled) {
+    const normalized = String(rel || '').replace(/\\/g, '/').replace(/^\.\//, '');
+    for (const tui of BUILTIN_TUI_IDS) {
+        if (enabled.has(tui))
+            continue;
+        for (const prefix of BUILTIN_TUI_OWNED_PATH_PREFIXES[tui]) {
+            const trimmed = prefix.replace(/\/$/, '');
+            if (normalized === trimmed || normalized.startsWith(prefix))
+                return true;
+        }
+    }
+    return false;
+}
+export { BUILTIN_TUI_IDS, BUILTIN_TUI_DISPLAY, BUILTIN_TUI_OWNED_PATH_PREFIXES, isBuiltinTUIId, resolveEnabledTUIs, isPathOwnedByDisabledTUI };
+//# sourceMappingURL=builtin-tuis.js.map

package/dist/lib/defaults.json

@@ -21,6 +21,9 @@
       "disk": null
     }
   },
+  "task": {
+    "shortIdLength": 2
+  },
   "labels": {
     "in": {}
   },

package/dist/lib/init.js

@@ -3,11 +3,12 @@ import path from 'node:path';
 import { execSync } from 'node:child_process';
 import { platform } from 'node:os';
 import { info, ok, err } from "./log.js";
-import { prompt, select, closePrompt } from "./prompt.js";
+import { prompt, select, multiSelect, closePrompt } from "./prompt.js";
 import { resolveTemplateDir } from "./paths.js";
 import { renderFile, copySkillDir, KNOWN_PLATFORMS } from "./render.js";
 import { enginesForPlatform } from "./sandbox/engines/index.js";
 import { VERSION } from "./version.js";
+import { BUILTIN_TUI_IDS, BUILTIN_TUI_DISPLAY, isPathOwnedByDisabledTUI, resolveEnabledTUIs } from "./builtin-tuis.js";
 const defaults = JSON.parse(fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8'));
 const PLATFORM_DEFAULT_ENGINES = Object.freeze({
     linux: 'native',
@@ -23,10 +24,11 @@ function isPathOwnedByOtherPlatform(relativePath, platformType) {
         return false;
     return candidate !== platformType;
 }
-function buildDefaultFiles(platformType) {
+function buildDefaultFiles(platformType, enabledTUIs) {
+    const ownedByDisabled = (entry) => isPathOwnedByDisabledTUI(entry, enabledTUIs);
     return {
-        managed: (defaults.files.managed || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType)),
-        merged: (defaults.files.merged || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType)),
+        managed: (defaults.files.managed || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType) && !ownedByDisabled(entry)),
+        merged: (defaults.files.merged || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType) && !ownedByDisabled(entry)),
         ejected: structuredClone(defaults.files.ejected || [])
     };
 }
@@ -158,6 +160,17 @@ async function cmdInit() {
     }
     const requiresPRChoice = await select('Require Pull Request flow?', ['yes', 'no'], 'yes');
     const requiresPullRequest = requiresPRChoice !== 'no';
+    let enabledTUIs;
+    try {
+        enabledTUIs = await multiSelect('Built-in TUI command files to install/manage', BUILTIN_TUI_IDS.map((id) => ({ id, label: BUILTIN_TUI_DISPLAY[id] })));
+    }
+    catch (e) {
+        err(e instanceof Error ? e.message : String(e));
+        closePrompt();
+        process.exitCode = 1;
+        return;
+    }
+    const enabledTUISet = resolveEnabledTUIs(enabledTUIs);
     const templateSources = parseLocalSources(await prompt('Template sources (optional, comma-separated local paths, e.g. ~/my-templates; Enter to skip)', ''));
     const skillSources = parseLocalSources(await prompt('Skill sources (optional, comma-separated local paths, e.g. ~/my-skills; Enter to skip)', ''));
     closePrompt();
@@ -186,15 +199,21 @@ async function cmdInit() {
     // install skill
     copySkillDir(path.join(templateDir, '.agents', 'skills', 'update-agent-infra'), path.join('.agents', 'skills', 'update-agent-infra'), replacements, language, platformType);
     ok('Installed .agents/skills/update-agent-infra/');
-    // install Claude command
-    renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
-    ok('Installed .claude/commands/update-agent-infra.md');
-    // install Gemini command
-    renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
-    ok(`Installed .gemini/commands/${project}/update-agent-infra.toml`);
-    // install OpenCode command
-    renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
-    ok('Installed .opencode/commands/update-agent-infra.md');
+    // install Claude command (only if enabled)
+    if (enabledTUISet.has('claude-code')) {
+        renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
+        ok('Installed .claude/commands/update-agent-infra.md');
+    }
+    // install Gemini command (only if enabled)
+    if (enabledTUISet.has('gemini-cli')) {
+        renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
+        ok(`Installed .gemini/commands/${project}/update-agent-infra.toml`);
+    }
+    // install OpenCode command (only if enabled)
+    if (enabledTUISet.has('opencode')) {
+        renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
+        ok('Installed .opencode/commands/update-agent-infra.md');
+    }
     // generate .agents/.airc.json
     const config = {
         project: projectName,
@@ -204,8 +223,10 @@ async function cmdInit() {
         requiresPullRequest,
         templateVersion: VERSION,
         sandbox: structuredClone(defaults.sandbox),
+        task: structuredClone(defaults.task),
         labels: structuredClone(defaults.labels),
-        files: buildDefaultFiles(platformType)
+        files: buildDefaultFiles(platformType, enabledTUISet),
+        tuis: enabledTUIs
     };
     if (sandboxEngine) {
         config.sandbox.engine = sandboxEngine;
@@ -227,15 +248,33 @@ async function cmdInit() {
     console.log('');
     ok('Project initialized successfully!');
     console.log('');
-    console.log('  Next step: open this project in any AI TUI and run:');
-    console.log('');
-    console.log('    Claude Code / OpenCode:  /update-agent-infra');
-    console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
-    console.log('    Codex CLI:               $update-agent-infra');
-    console.log('');
-    console.log('  This will render all templates and set up the full');
-    console.log('  AI collaboration infrastructure.');
-    console.log('');
+    if (enabledTUISet.size === 0) {
+        console.log('  No built-in TUI selected.');
+        console.log(`  Configure "customTUIs" in ${configPath} before running update-agent-infra.`);
+        console.log('');
+    }
+    else {
+        console.log('  Next step: open this project in any AI TUI and run:');
+        console.log('');
+        const claudeOrOpencode = [];
+        if (enabledTUISet.has('claude-code'))
+            claudeOrOpencode.push('Claude Code');
+        if (enabledTUISet.has('opencode'))
+            claudeOrOpencode.push('OpenCode');
+        if (claudeOrOpencode.length > 0) {
+            console.log(`    ${claudeOrOpencode.join(' / ')}:  /update-agent-infra`);
+        }
+        if (enabledTUISet.has('gemini-cli')) {
+            console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
+        }
+        if (enabledTUISet.has('codex')) {
+            console.log('    Codex CLI:               $update-agent-infra');
+        }
+        console.log('');
+        console.log('  This will render all templates and set up the full');
+        console.log('  AI collaboration infrastructure.');
+        console.log('');
+    }
 }
 export { cmdInit };
 //# sourceMappingURL=init.js.map

package/dist/lib/prompt.js

@@ -74,6 +74,54 @@ async function select(question, choices, defaultValue) {
     }
     return trimmed;
 }
+async function multiSelect(question, choices) {
+    process.stdout.write(`  ${question}:\n`);
+    const idWidth = Math.max(...choices.map((c) => c.id.length));
+    choices.forEach((c, i) => {
+        process.stdout.write(`      ${i + 1}) ${c.id.padEnd(idWidth)}  (${c.label})\n`);
+    });
+    ask('Enter comma-separated numbers or ids to keep, or "none" to select nothing [default: all]: ');
+    setupInterface();
+    const line = await nextLine();
+    // Strictly distinguish bare Enter (null/empty string) from whitespace input.
+    if (line === null || line === '')
+        return choices.map((c) => c.id);
+    // Explicit empty selection: "none" means deliberately zero built-in choices.
+    if (line.trim().toLowerCase() === 'none')
+        return [];
+    const tokens = line.split(',').map((t) => t.trim());
+    if (tokens.some((t) => t === '')) {
+        throw new Error(`Invalid selection input: "${line}" (empty token)`);
+    }
+    const idSet = new Set(choices.map((c) => c.id));
+    const seenIds = new Set();
+    for (const t of tokens) {
+        let resolvedId;
+        if (/^[0-9]+$/.test(t)) {
+            const n = Number.parseInt(t, 10);
+            if (n < 1 || n > choices.length) {
+                throw new Error(`Selection out of range: "${t}" (expected 1..${choices.length})`);
+            }
+            resolvedId = choices[n - 1].id;
+        }
+        else if (idSet.has(t)) {
+            resolvedId = t;
+        }
+        else {
+            throw new Error(`Unknown TUI selection token: "${t}"`);
+        }
+        if (seenIds.has(resolvedId)) {
+            throw new Error(`Duplicate selection: "${t}" resolves to already-selected "${resolvedId}"`);
+        }
+        seenIds.add(resolvedId);
+    }
+    // Normalize to prompt order: users can type tokens in any order, but the
+    // persisted array follows the canonical choices order to keep .airc.json
+    // diffs stable. An empty result here is impossible (tokens.length > 0 and
+    // every token resolves to an id), so no separate empty guard is needed —
+    // explicit "none" handled above.
+    return choices.map((c) => c.id).filter((id) => seenIds.has(id));
+}
 function closePrompt() {
     if (_rl) {
         _rl.close();
@@ -81,5 +129,5 @@ function closePrompt() {
         _stdinDone = true;
     }
 }
-export { prompt, select, closePrompt };
+export { prompt, select, multiSelect, closePrompt };
 //# sourceMappingURL=prompt.js.map

package/dist/lib/sandbox/commands/create.js

@@ -630,13 +630,21 @@ export function ensureCodexModelInheritance(toolDir, hostHomeDir) {
             return;
         }
     }
+    const inheritSpecs = [
+        ['model', 'string'],
+        ['model_reasoning_effort', 'string'],
+        ['model_auto_compact_token_limit', 'number']
+    ];
     let changed = false;
-    for (const key of ['model', 'model_reasoning_effort']) {
+    for (const [key, type] of inheritSpecs) {
         if (Object.hasOwn(sandboxParsed, key)) {
             continue;
         }
         const value = hostParsed[key];
-        if (typeof value !== 'string' || value === '') {
+        if (type === 'string' && (typeof value !== 'string' || value === '')) {
+            continue;
+        }
+        if (type === 'number' && (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
             continue;
         }
         sandboxParsed[key] = value;

package/dist/lib/sandbox/commands/enter.js

@@ -1,5 +1,5 @@
 import { loadConfig } from "../config.js";
-import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel } from "../constants.js";
+import { assertValidBranchName, containerNameCandidates } from "../constants.js";
 import { detectEngine } from "../engine.js";
 import { formatCredentialWarnings, formatRemaining, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from "../credentials.js";
 import { runInteractiveEngine, runSafeEngine } from "../shell.js";
@@ -7,11 +7,13 @@ import { resolveTaskBranch } from "../task-resolver.js";
 import { dotfilesCacheDir, materializeDotfiles } from "../dotfiles.js";
 import { runInteractiveWithClipboardBridge } from "../clipboard/bridge.js";
 import { detectHostTimezone } from "../host-timezone.js";
-import { fetchSandboxRows, isTaskShortRef, resolveTaskShortRef } from "./list-running.js";
-const USAGE = `Usage: ai sandbox exec <branch | TASK-id | '#N'> [cmd...]
+import { isTaskShortRef, resolveTaskShortRef } from "./list-running.js";
+const USAGE = `Usage: ai sandbox exec <branch | TASK-id | N | '#N'> [cmd...]
 
-'#N' references the N-th running sandbox in 'ai sandbox ls' order (1-based).
-Quote it as '#N' to avoid shell '#' comment handling.`;
+N (bare) and '#N' both reference the same 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.`;
 const TMUX_ENTRY_PATH = '/usr/local/bin/sandbox-tmux-entry';
 // Terminal-detection variables that interactive TUIs (e.g. claude-code)
 // inspect to enable progressive enhancements such as the kitty keyboard
@@ -86,8 +88,7 @@ export async function enter(args) {
     const [firstArg = '', ...cmd] = args;
     let branch;
     if (isTaskShortRef(firstArg)) {
-        const { running } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
-        branch = resolveTaskShortRef(firstArg, { running });
+        branch = resolveTaskShortRef(firstArg, { repoRoot: config.repoRoot });
     }
     else {
         branch = resolveTaskBranch(firstArg, config.repoRoot);

package/dist/lib/sandbox/commands/list-running.js

@@ -1,3 +1,6 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import { runSafeEngine } from "../shell.js";
 export function containerListFormat() {
     return '{{.Names}}\t{{.Status}}\t{{.Labels}}';
@@ -65,44 +68,75 @@ export function fetchSandboxRows(engine, label, branchKey) {
     return sortAndIndexSandboxRows(parseSandboxRows(raw, branchKey));
 }
 /**
- * Returns true iff `arg` is a syntactically valid task short reference ('#N').
+ * Returns true iff `arg` is a syntactically valid task short reference.
+ * Accepts both bare numeric ('11') and '#'-prefixed ('#11') forms.
  * 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) {
-    return /^#\d+$/.test(arg);
+    return /^#?\d+$/.test(arg);
 }
 /**
- * Resolve a task short reference ('#N') to a branch name.
+ * Try to resolve a short ref against the global task-short-id registry.
  *
- * Current implementation: treats the digits as a 1-based index into the
- * supplied running-sandbox list (ls view order). This is the *only*
- * resolution path until the global task-short-id registry lands in a
- * follow-up task; do NOT read task.md or scan .agents/workspace/ from this
- * helper here.
- *
- * Precondition: callers MUST gate on isTaskShortRef(arg) === true before
- * constructing ctx and calling this function. Throws when arg is a valid
- * short ref but cannot be resolved (out of range, no running sandboxes,
- * etc.); the caller surfaces the error to the user.
+ * Tri-state semantics (review-code Round 1 M-1 fix):
+ *   - 'miss'     → script reports no entry (or registry script missing). Caller may fall back.
+ *   - 'hit'      → registry resolved to a task id and branch is found in task.md.
+ *   - throws     → registry hit but task.md is missing or branch metadata is unparseable;
+ *                   surfacing this error is critical — never silently fall back to running index.
  */
-export function resolveTaskShortRef(arg, ctx) {
-    const n = Number(arg.slice(1));
-    if (n < 1) {
-        throw new Error(`Invalid sandbox index '${arg}': must be >= 1`);
-    }
-    const { running } = ctx;
-    if (running.length === 0) {
-        throw new Error(`No running sandbox to reference with '${arg}'`);
-    }
-    if (n > running.length) {
-        throw new Error(`No running sandbox at index '${arg}' (only ${running.length} running)`);
+function tryResolveFromRegistry(arg, repoRoot) {
+    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.)
+    const result = spawnSync('node', [scriptPath, 'resolve', arg], { encoding: 'utf8', cwd: repoRoot });
+    if (result.status !== 0)
+        return { status: 'miss' };
+    const taskId = (result.stdout || '').trim();
+    if (!/^TASK-\d{8}-\d{6}$/.test(taskId)) {
+        throw new Error(`Registry returned malformed task id for '${arg}': ${JSON.stringify(taskId)}`);
     }
-    const row = running[n - 1];
-    if (!row.branch) {
-        throw new Error(`Cannot resolve branch for sandbox '${arg}' (container '${row.name}' missing branch label)`);
+    for (const sub of ['active', 'completed', 'blocked', 'archive']) {
+        const taskMdPath = path.join(repoRoot, '.agents', 'workspace', sub, taskId, 'task.md');
+        if (!fs.existsSync(taskMdPath))
+            continue;
+        const content = fs.readFileSync(taskMdPath, 'utf8');
+        const fm = content.match(/^branch:\s*(.+)$/m);
+        if (fm?.[1]?.trim()) {
+            return { status: 'hit', branch: fm[1].trim().replace(/^(["'])(.*)\1$/, '$2') };
+        }
+        const ctx = content.match(/^- \*\*(?:分支|Branch)\*\*：[ \t]*`?([^`\n]+)`?$/m);
+        if (ctx?.[1]?.trim()) {
+            return { status: 'hit', branch: ctx[1].trim().replace(/^(["'])(.*)\1$/, '$2') };
+        }
+        throw new Error(`Short ref '${arg}' resolved to task ${taskId} but task.md has no branch field`);
     }
-    return row.branch;
+    throw new Error(`Short ref '${arg}' resolved to task ${taskId} but task.md was not found under any workspace dir`);
+}
+/**
+/**
+ * Resolve a task short reference (bare 'N' or '#N') to a branch name for the
+ * sandbox entrypoint.
+ *
+ * Resolution: registry-only. Look up the short id in the global task-short-id
+ * registry under repoRoot; if hit, read the branch from the matching task.md.
+ * On miss (registry empty or short id absent), throw with an actionable
+ * message instead of falling back to a container's row position in
+ * 'ai sandbox ls' output — that fallback would make the same syntax mean
+ * different things depending on `docker ps` state.
+ *
+ * Precondition: callers MUST gate on isTaskShortRef(arg) === true.
+ */
+export function resolveTaskShortRef(arg, ctx) {
+    const lookup = tryResolveFromRegistry(arg, ctx.repoRoot);
+    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'); ` +
+        `use a task short id (e.g. 'ai sandbox exec 11'), a TASK-id, or a branch name.`);
 }
 //# sourceMappingURL=list-running.js.map

package/dist/lib/sandbox/commands/ls.js

@@ -6,27 +6,20 @@ import { loadConfig } from "../config.js";
 import { sandboxBranchLabel, sandboxLabel } from "../constants.js";
 import { detectEngine } from "../engine.js";
 import { resolveTools, toolProjectDirCandidates } from "../tools.js";
+import { formatTable } from "../../table.js";
+import { lookupShortIdByBranch } from "../../task/short-id.js";
 import { fetchSandboxRows } from "./list-running.js";
 export { containerListFormat, parseLabels } from "./list-running.js";
 const USAGE = `Usage: ai sandbox ls
 
-Lists all containers for the current project. The leftmost '#' column
-numbers running sandboxes; use it as "ai sandbox exec '#N'" to enter one.
-Quote '#N' to avoid shell '#' comment handling.`;
-const CONTAINER_TABLE_HEADERS = ['#', 'NAMES', 'STATUS', 'BRANCH'];
+Lists all containers for the current project. The '#' column is a
+display-only row number; the 'SHORT' column shows the active task short
+id bound to each container's branch (via
+.agents/workspace/active/.short-ids.json), or '-' if no active task is
+bound. Pass the SHORT value to "ai sandbox exec" (e.g. 'ai sandbox exec 11').`;
+const CONTAINER_TABLE_HEADERS = ['#', 'SHORT', 'NAMES', 'STATUS', 'BRANCH'];
 export function formatContainerTable(rows) {
-    const columns = rows.map((row) => [row.index, row.name, row.status, row.branch]);
-    const widths = [
-        Math.max(CONTAINER_TABLE_HEADERS[0].length, ...rows.map((row) => row.index.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[1].length, ...rows.map((row) => row.name.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[2].length, ...rows.map((row) => row.status.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[3].length, ...rows.map((row) => row.branch.length))
-    ];
-    const renderRow = (values) => `${values[0].padEnd(widths[0])}  ${values[1].padEnd(widths[1])}  ${values[2].padEnd(widths[2])}  ${values[3]}`.trimEnd();
-    return [
-        renderRow(CONTAINER_TABLE_HEADERS),
-        ...columns.map((column) => renderRow(column))
-    ];
+    return formatTable(CONTAINER_TABLE_HEADERS, rows.map((r) => [r.row, r.shortId, r.name, r.status, r.branch]));
 }
 function listChildren(dir) {
     if (!fs.existsSync(dir)) {
@@ -51,15 +44,20 @@ export function ls(args = []) {
         p.log.warn('  No sandbox containers');
     }
     else {
-        const tableRows = ordered.map((row) => ({
-            index: row.index === null ? '' : String(row.index),
-            name: row.name,
-            status: row.status,
-            branch: row.branch
-        }));
+        const tableRows = ordered.map((container, i) => {
+            const shortId = container.branch ? lookupShortIdByBranch(container.branch, config.repoRoot) : null;
+            return {
+                row: String(i + 1),
+                shortId: shortId ?? '-',
+                name: container.name,
+                status: container.status,
+                branch: container.branch
+            };
+        });
         for (const line of formatContainerTable(tableRows)) {
             process.stdout.write(`  ${line}\n`);
         }
+        process.stdout.write(`  Total: ${ordered.length} containers\n`);
     }
     p.log.step('Worktrees');
     const worktrees = listChildren(config.worktreeBase);

package/dist/lib/sandbox/commands/rebuild.js

@@ -6,7 +6,8 @@ import { loadConfig } from "../config.js";
 import { prepareDockerfile } from "../dockerfile.js";
 import { sandboxImageConfigLabel, sandboxLabel } from "../constants.js";
 import { detectEngine, ensureDocker } from "../engine.js";
-import { runEngine, runOkEngine, runSafeEngine, runVerboseEngine } from "../shell.js";
+import { runEngine, runSafeEngine, runVerboseEngine } from "../shell.js";
+import { pruneSandboxDanglingImages } from "../image-prune.js";
 import { imageSignatureFields, resolveTools, toolNpmPackagesArg, toolShellInstallScriptBase64 } from "../tools.js";
 import { toEnginePath } from "../engines/wsl2-paths.js";
 import { resolveBuildUid } from "../engines/native.js";
@@ -53,11 +54,6 @@ export function buildArgs(config, tools, dockerfilePath, imageSignature, { engin
     }
     return args;
 }
-function removeImageIfPresent(imageName, engine) {
-    if (runOkEngine(engine, 'docker', ['image', 'inspect', imageName])) {
-        runEngine(engine, 'docker', ['rmi', imageName]);
-    }
-}
 export async function rebuild(args) {
     const { values } = parseArgs({
         args,
@@ -85,9 +81,6 @@ export async function rebuild(args) {
     try {
         if (quiet) {
             const spinner = p.spinner();
-            spinner.start(`Removing old image ${config.imageName}...`);
-            removeImageIfPresent(config.imageName, engine);
-            spinner.stop('Old image removed');
             spinner.start('Building image...');
             runEngine(engine, 'docker', buildArgs(config, tools, preparedDockerfile.path, imageSignature, { engine, refresh }), {
                 cwd: config.repoRoot
@@ -95,12 +88,11 @@ export async function rebuild(args) {
             spinner.stop(pc.green('Sandbox image rebuilt'));
         }
         else {
-            p.log.step(`Removing old image ${config.imageName}`);
-            removeImageIfPresent(config.imageName, engine);
             p.log.step('Building image');
             runVerboseEngine(engine, 'docker', buildArgs(config, tools, preparedDockerfile.path, imageSignature, { engine, refresh }), { cwd: config.repoRoot });
             p.log.success(pc.green('Sandbox image rebuilt'));
         }
+        pruneSandboxDanglingImages(config, engine);
     }
     finally {
         preparedDockerfile.cleanup();

package/dist/lib/sandbox/commands/rm.js

@@ -6,6 +6,7 @@ import pc from 'picocolors';
 import { loadConfig } from "../config.js";
 import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel, shareBranchDir, shellConfigDirCandidates, worktreeDirCandidates } from "../constants.js";
 import { ENGINES, detectEngine, engineDisplayName, isManagedEngine, stopManagedVm } from "../engine.js";
+import { pruneSandboxDanglingImages } from "../image-prune.js";
 import { removeManagedDir, removeWorktreeDir } from "../managed-fs.js";
 import { runOk, runSafe, runSafeEngine } from "../shell.js";
 import { resolveTaskBranch } from "../task-resolver.js";
@@ -174,6 +175,7 @@ async function rmAll(config, tools) {
     if (!p.isCancel(shouldRemoveImage) && shouldRemoveImage) {
         runSafeEngine(engine, 'docker', ['rmi', config.imageName]);
     }
+    pruneSandboxDanglingImages(config, engine);
     if (isManagedEngine(engine)) {
         if (engine === ENGINES.WSL2) {
             p.log.warn('Windows uses Docker Desktop with WSL2. Stop it from Docker Desktop or run "wsl --shutdown" manually.');

package/dist/lib/sandbox/image-prune.js

@@ -0,0 +1,18 @@
+import * as p from '@clack/prompts';
+import { sandboxLabel } from "./constants.js";
+import { runEngine } from "./shell.js";
+export function pruneSandboxDanglingImages(config, engine) {
+    try {
+        runEngine(engine, 'docker', [
+            'image',
+            'prune',
+            '-f',
+            '--filter',
+            `label=${sandboxLabel(config)}`
+        ]);
+    }
+    catch {
+        p.log.warn(`Failed to prune dangling sandbox images (label=${sandboxLabel(config)}); leaving them in place.`);
+    }
+}
+//# sourceMappingURL=image-prune.js.map