@fitlab-ai/agent-infra 0.6.5 → 0.7.1

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

@@ -13,7 +13,7 @@ import { prepareDockerfile } from "../dockerfile.js";
 import { detectEngine, ensureDocker } from "../engine.js";
 import { commandForEngine, execEngine, run, runEngine, runOk, runOkEngine, runSafe, runSafeEngine, runVerboseEngine } from "../shell.js";
 import { resolveTaskBranch } from "../task-resolver.js";
-import { resolveTools, toolConfigDirCandidates, toolNpmPackagesArg } from "../tools.js";
+import { imageSignatureFields, resolveTools, toolConfigDirCandidates, toolNpmPackagesArg, toolShellInstallScriptBase64 } from "../tools.js";
 import { hostJoin, toEnginePath, volumeArg } from "../engines/wsl2-paths.js";
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from "../clipboard/paths.js";
 import { validateSelinuxDisableEnv } from "../engines/selinux.js";
@@ -58,7 +58,7 @@ function buildSignature(preparedDockerfile, tools) {
     return createHash('sha256')
         .update(JSON.stringify({
         dockerfile: preparedDockerfile.signature,
-        tools: tools.map((tool) => tool.npmPackage)
+        tools: imageSignatureFields(tools)
     }))
         .digest('hex')
         .slice(0, 12);
@@ -789,6 +789,8 @@ export function buildImage(config, tools, dockerfilePath, imageSignature, { engi
         `HOST_GID=${hostGid}`,
         '--build-arg',
         `AI_TOOL_PACKAGES=${toolNpmPackagesArg(tools)}`,
+        '--build-arg',
+        `AI_TOOLS_SHELL_INSTALL_B64=${toolShellInstallScriptBase64(tools)}`,
         '--label',
         sandboxLabel(config),
         '--label',

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

@@ -1,5 +1,5 @@
 import { loadConfig } from "../config.js";
-import { assertValidBranchName, containerNameCandidates } from "../constants.js";
+import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel } from "../constants.js";
 import { detectEngine } from "../engine.js";
 import { formatCredentialWarnings, formatRemaining, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from "../credentials.js";
 import { runInteractiveEngine, runSafeEngine } from "../shell.js";
@@ -7,7 +7,11 @@ import { resolveTaskBranch } from "../task-resolver.js";
 import { dotfilesCacheDir, materializeDotfiles } from "../dotfiles.js";
 import { runInteractiveWithClipboardBridge } from "../clipboard/bridge.js";
 import { detectHostTimezone } from "../host-timezone.js";
-const USAGE = `Usage: ai sandbox exec <branch> [cmd...]`;
+import { fetchSandboxRows, isTaskShortRef, resolveTaskShortRef } from "./list-running.js";
+const USAGE = `Usage: ai sandbox exec <branch | TASK-id | '#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.`;
 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
@@ -79,8 +83,15 @@ export async function enter(args) {
     const config = loadConfig();
     validateClaudeCredentialsEnvOverride();
     const engine = detectEngine(config);
-    const [branchOrTaskId = '', ...cmd] = args;
-    const branch = resolveTaskBranch(branchOrTaskId, config.repoRoot);
+    const [firstArg = '', ...cmd] = args;
+    let branch;
+    if (isTaskShortRef(firstArg)) {
+        const { running } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
+        branch = resolveTaskShortRef(firstArg, { running, repoRoot: config.repoRoot });
+    }
+    else {
+        branch = resolveTaskBranch(firstArg, config.repoRoot);
+    }
     assertValidBranchName(branch);
     const running = runSafeEngine(engine, 'docker', ['ps', '--format', '{{.Names}}']).split('\n');
     const container = containerNameCandidates(config, branch).find((name) => running.includes(name));

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

@@ -0,0 +1,153 @@
+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}}';
+}
+export function parseLabels(csv) {
+    if (!csv) {
+        return {};
+    }
+    const labels = {};
+    for (const pair of csv.split(',')) {
+        if (!pair) {
+            continue;
+        }
+        const eq = pair.indexOf('=');
+        if (eq < 0) {
+            continue;
+        }
+        labels[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    return labels;
+}
+export function parseSandboxRows(rawOutput, branchKey) {
+    if (!rawOutput) {
+        return [];
+    }
+    return rawOutput.split('\n').map((line) => {
+        const [name = '', status = '', labelsCsv = ''] = line.split('\t');
+        const branch = parseLabels(labelsCsv)[branchKey] ?? '';
+        return {
+            name,
+            status,
+            branch,
+            running: status.startsWith('Up '),
+            index: null
+        };
+    });
+}
+export function sortAndIndexSandboxRows(rows) {
+    const byName = (a, b) => {
+        if (a.name < b.name)
+            return -1;
+        if (a.name > b.name)
+            return 1;
+        return 0;
+    };
+    const running = rows.filter((row) => row.running).sort(byName).map((row, i) => ({
+        ...row,
+        index: i + 1
+    }));
+    const nonRunning = rows.filter((row) => !row.running).sort(byName).map((row) => ({
+        ...row,
+        index: null
+    }));
+    return { running, nonRunning };
+}
+export function fetchSandboxRows(engine, label, branchKey) {
+    const raw = runSafeEngine(engine, 'docker', [
+        'ps',
+        '-a',
+        '--filter',
+        `label=${label}`,
+        '--format',
+        containerListFormat()
+    ]);
+    return sortAndIndexSandboxRows(parseSandboxRows(raw, branchKey));
+}
+/**
+ * Returns true iff `arg` is a syntactically valid task short reference ('#N').
+ * 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);
+}
+/**
+ * Try to resolve a short ref against the global task-short-id registry.
+ *
+ * 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.
+ */
+function tryResolveFromRegistry(arg, repoRoot) {
+    const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
+    if (!fs.existsSync(scriptPath))
+        return { status: 'miss' };
+    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)}`);
+    }
+    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`);
+    }
+    throw new Error(`Short ref '${arg}' resolved to task ${taskId} but task.md was not found under any workspace dir`);
+}
+function resolveByRunningIndex(arg, running) {
+    const n = Number(arg.slice(1));
+    if (n < 1) {
+        throw new Error(`Invalid sandbox index '${arg}': must be >= 1`);
+    }
+    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)`);
+    }
+    const row = running[n - 1];
+    if (!row.branch) {
+        throw new Error(`Cannot resolve branch for sandbox '${arg}' (container '${row.name}' missing branch label)`);
+    }
+    return row.branch;
+}
+/**
+ * Resolve a task short reference ('#N') to a branch name for the sandbox entrypoint.
+ *
+ * Resolution order (sandbox fallback mode, plan-r7 C2):
+ *   1. Try the global task-short-id registry under repoRoot. If hit, look up the
+ *      branch from the matching task.md.
+ *   2. Fallback to the running-sandbox list index (preserves the #414 ls-index
+ *      behaviour; long-term contract per analysis-r5).
+ *
+ * Precondition: callers MUST gate on isTaskShortRef(arg) === true.
+ */
+export function resolveTaskShortRef(arg, ctx) {
+    if (ctx.repoRoot) {
+        const lookup = tryResolveFromRegistry(arg, ctx.repoRoot);
+        if (lookup.status === 'hit')
+            return lookup.branch;
+        // 'miss' falls through to ls-index fallback (preserves #414 behaviour); 'hit-but-invalid' already threw above.
+    }
+    return resolveByRunningIndex(arg, ctx.running);
+}
+//# sourceMappingURL=list-running.js.map

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

@@ -5,39 +5,24 @@ import pc from 'picocolors';
 import { loadConfig } from "../config.js";
 import { sandboxBranchLabel, sandboxLabel } from "../constants.js";
 import { detectEngine } from "../engine.js";
-import { runSafeEngine } from "../shell.js";
 import { resolveTools, toolProjectDirCandidates } from "../tools.js";
-const USAGE = 'Usage: ai sandbox ls';
-const CONTAINER_TABLE_HEADERS = ['NAMES', 'STATUS', 'BRANCH'];
-// Exported to lock the docker/podman-compatible format in unit tests.
-export function containerListFormat() {
-    return '{{.Names}}\t{{.Status}}\t{{.Labels}}';
-}
-export function parseLabels(csv) {
-    if (!csv) {
-        return {};
-    }
-    const labels = {};
-    for (const pair of csv.split(',')) {
-        if (!pair) {
-            continue;
-        }
-        const eq = pair.indexOf('=');
-        if (eq < 0) {
-            continue;
-        }
-        labels[pair.slice(0, eq)] = pair.slice(eq + 1);
-    }
-    return labels;
-}
+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'];
 export function formatContainerTable(rows) {
-    const columns = rows.map((row) => [row.name, row.status, row.branch]);
+    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.name.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[1].length, ...rows.map((row) => row.status.length)),
-        Math.max(CONTAINER_TABLE_HEADERS[2].length, ...rows.map((row) => row.branch.length))
+        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]}`.trimEnd();
+    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))
@@ -58,27 +43,21 @@ export function ls(args = []) {
     const engine = detectEngine(config);
     const tools = resolveTools(config);
     const label = sandboxLabel(config);
-    const containers = runSafeEngine(engine, 'docker', [
-        'ps',
-        '-a',
-        '--filter',
-        `label=${label}`,
-        '--format',
-        containerListFormat()
-    ]);
+    const { running, nonRunning } = fetchSandboxRows(engine, label, sandboxBranchLabel(config));
     p.intro(pc.cyan(`Sandbox status for ${config.project}`));
     p.log.step('Containers');
-    if (!containers) {
+    const ordered = [...running, ...nonRunning];
+    if (ordered.length === 0) {
         p.log.warn('  No sandbox containers');
     }
     else {
-        const branchKey = sandboxBranchLabel(config);
-        const rows = containers.split('\n').map((line) => {
-            const [name = '', status = '', labelsCsv = ''] = line.split('\t');
-            const branch = parseLabels(labelsCsv)[branchKey] ?? '';
-            return { name, status, branch };
-        });
-        for (const line of formatContainerTable(rows)) {
+        const tableRows = ordered.map((row) => ({
+            index: row.index === null ? '' : String(row.index),
+            name: row.name,
+            status: row.status,
+            branch: row.branch
+        }));
+        for (const line of formatContainerTable(tableRows)) {
             process.stdout.write(`  ${line}\n`);
         }
     }

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

@@ -6,8 +6,9 @@ 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 { resolveTools, toolNpmPackagesArg } from "../tools.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";
 const USAGE = `Usage: ai sandbox rebuild [--quiet] [--refresh]`;
@@ -15,7 +16,7 @@ function buildSignature(preparedDockerfile, tools) {
     return createHash('sha256')
         .update(JSON.stringify({
         dockerfile: preparedDockerfile.signature,
-        tools: tools.map((tool) => tool.npmPackage)
+        tools: imageSignatureFields(tools)
     }))
         .digest('hex')
         .slice(0, 12);
@@ -38,6 +39,8 @@ export function buildArgs(config, tools, dockerfilePath, imageSignature, { engin
         `HOST_GID=${hostGid}`,
         '--build-arg',
         `AI_TOOL_PACKAGES=${toolNpmPackagesArg(tools)}`,
+        '--build-arg',
+        `AI_TOOLS_SHELL_INSTALL_B64=${toolShellInstallScriptBase64(tools)}`,
         '--label',
         sandboxLabel(config),
         '--label',
@@ -51,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,
@@ -83,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
@@ -93,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/config.js

@@ -6,6 +6,7 @@ import pc from 'picocolors';
 import { validateSandboxEngine } from "./engine.js";
 import { hostJoin } from "./engines/wsl2-paths.js";
 import { findRuntimeEngineMismatches } from "./runtime-engines.js";
+import { parseCustomTools } from "./tools.js";
 const DEFAULTS = Object.freeze({
     engine: null,
     runtimes: ['node22'],
@@ -76,6 +77,7 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
                 '  Update "sandbox.runtimes" in .agents/.airc.json (e.g. "node22"), or relax "engines.node".\n'));
         }
     }
+    const customTools = parseCustomTools(sandbox.customTools, { home });
     return {
         repoRoot,
         configPath,
@@ -93,6 +95,7 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         tools: Array.isArray(sandbox.tools) && sandbox.tools.length > 0
             ? [...sandbox.tools]
             : defaults.tools,
+        customTools,
         dockerfile,
         vm: {
             cpu: asPositiveNumberOrNull(sandbox.vm?.cpu) ?? defaults.vm.cpu,

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

package/dist/lib/sandbox/index.js

@@ -2,7 +2,8 @@ const USAGE = `Usage: ai sandbox <command> [options]
 
 Commands:
   create <branch> [base]       Create a sandbox (VM + image + worktree + container)
-  exec <branch> [cmd...]       Enter sandbox or run a command
+  exec <branch | '#N'> [cmd...]
+                               Enter sandbox or run a command (use leftmost '#' column from 'ls')
   ls                           List sandboxes for the current project
   prune [--dry-run]            Remove orphaned per-branch state dirs
   rebuild [--quiet] [--refresh]

package/dist/lib/sandbox/runtimes/ai-tools.dockerfile

@@ -4,16 +4,20 @@ ENV OPENCODE_DISABLE_AUTOUPDATE=1
 ENV NPM_CONFIG_PREFIX=/home/devuser/.npm-global
 ENV PATH="/home/devuser/.npm-global/bin:${PATH}"
 
-ARG AI_TOOL_PACKAGES
-RUN if [ -z "${AI_TOOL_PACKAGES}" ]; then \
-      echo "AI_TOOL_PACKAGES build arg is required"; \
-      exit 1; \
-    fi && \
-    set -e && \
+ARG AI_TOOL_PACKAGES=
+RUN set -e && \
     for pkg in ${AI_TOOL_PACKAGES}; do \
       npm install -g "$pkg"; \
     done
 
+ARG AI_TOOLS_SHELL_INSTALL_B64=
+RUN if [ -n "${AI_TOOLS_SHELL_INSTALL_B64}" ]; then \
+      set -e && \
+      echo "${AI_TOOLS_SHELL_INSTALL_B64}" | base64 -d > /tmp/ai-tools-install.sh && \
+      bash /tmp/ai-tools-install.sh && \
+      rm /tmp/ai-tools-install.sh; \
+    fi
+
 RUN npm install -g pyright
 
 RUN mkdir -p /home/devuser/.local/share /home/devuser/.local/state

package/dist/lib/sandbox/task-resolver.js

@@ -1,7 +1,20 @@
+import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+const SHORT_ID_RE = /^#\d+$/;
 const WORKSPACE_DIRS = ['active', 'completed', 'blocked', 'archive'];
+function resolveShortIdStrict(arg, repoRoot) {
+    const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
+    if (!fs.existsSync(scriptPath)) {
+        throw new Error(`Short id '${arg}' provided but task-short-id.js script is missing at ${scriptPath}`);
+    }
+    const result = spawnSync('node', [scriptPath, 'resolve', arg], { encoding: 'utf8', cwd: repoRoot });
+    if (result.status !== 0) {
+        throw new Error(`Short id '${arg}' not found in active task registry: ${(result.stderr || '').trim()}`);
+    }
+    return result.stdout.trim();
+}
 function stripQuotes(value) {
     return value.replace(/^(["'])(.*)\1$/, '$2');
 }
@@ -26,6 +39,11 @@ function resolveBranchFromTaskContent(content, taskId) {
     throw new Error(`Task ${taskId} has no branch field in task.md`);
 }
 export function resolveTaskBranch(arg, repoRoot) {
+    if (SHORT_ID_RE.test(arg)) {
+        const taskId = resolveShortIdStrict(arg, repoRoot);
+        const content = readTaskContent(repoRoot, taskId);
+        return resolveBranchFromTaskContent(content, taskId);
+    }
     if (!TASK_ID_RE.test(arg)) {
         return arg;
     }