@fitlab-ai/agent-infra 0.7.6 → 0.7.7

package/bin/cli.ts

@@ -19,8 +19,8 @@ Commands:
   help            Show this help message
   init            Initialize a new project with update-agent-infra seed command
   merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
-  sandbox         Manage Docker-based AI sandboxes
-  task            Read-only views over .agents/workspace tasks (cat / files / grep / log / ls / show / status)
+  sandbox, s      Manage Docker-based AI sandboxes
+  task, t         Read-only views over .agents/workspace tasks (cat / files / grep / log / ls / show / status)
   update          Update seed files and sync file registry for an existing project
   version         Show version
 
@@ -37,7 +37,15 @@ Examples:
   npx @fitlab-ai/agent-infra init
 `;
 
-const command = process.argv[2] || '';
+const COMMAND_ALIASES: Record<string, string> = {
+  s: 'sandbox',
+  t: 'task'
+};
+
+const rawCommand = process.argv[2] || '';
+const command = Object.hasOwn(COMMAND_ALIASES, rawCommand)
+  ? COMMAND_ALIASES[rawCommand]
+  : rawCommand;
 
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);

package/dist/bin/cli.js

@@ -23,8 +23,8 @@ Commands:
   help            Show this help message
   init            Initialize a new project with update-agent-infra seed command
   merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
-  sandbox         Manage Docker-based AI sandboxes
-  task            Read-only views over .agents/workspace tasks (cat / files / grep / log / ls / show / status)
+  sandbox, s      Manage Docker-based AI sandboxes
+  task, t         Read-only views over .agents/workspace tasks (cat / files / grep / log / ls / show / status)
   update          Update seed files and sync file registry for an existing project
   version         Show version
 
@@ -40,7 +40,14 @@ Examples:
   cd my-project && ai init
   npx @fitlab-ai/agent-infra init
 `;
-const command = process.argv[2] || '';
+const COMMAND_ALIASES = {
+    s: 'sandbox',
+    t: 'task'
+};
+const rawCommand = process.argv[2] || '';
+const command = Object.hasOwn(COMMAND_ALIASES, rawCommand)
+    ? COMMAND_ALIASES[rawCommand]
+    : rawCommand;
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

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

@@ -1,11 +1,8 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 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";
@@ -18,17 +15,14 @@ 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').
 A '-' means no active task is bound to that branch, so the sandbox is free
-to remove with "ai sandbox rm <branch>".`;
+to remove with "ai sandbox rm <branch>".
+
+Use "ai sandbox show <ref>" for a single sandbox's worktree and per-tool
+state paths.`;
 const CONTAINER_TABLE_HEADERS = ['#', 'SHORT', 'NAMES', 'STATUS', 'BRANCH'];
 export function formatContainerTable(rows, zebra = false) {
     return formatTable(CONTAINER_TABLE_HEADERS, rows.map((r) => [r.row, r.shortId, r.name, r.status, r.branch]), { zebra });
 }
-function listChildren(dir) {
-    if (!fs.existsSync(dir)) {
-        return [];
-    }
-    return fs.readdirSync(dir).sort().map((entry) => path.join(dir, entry));
-}
 export function ls(args = []) {
     if (args.length > 0 && (args[0] === '--help' || args[0] === '-h')) {
         process.stdout.write(`${USAGE}\n`);
@@ -36,7 +30,6 @@ export function ls(args = []) {
     }
     const config = loadConfig();
     const engine = detectEngine(config);
-    const tools = resolveTools(config);
     const label = sandboxLabel(config);
     const { running, nonRunning } = fetchSandboxRows(engine, label, sandboxBranchLabel(config));
     p.intro(pc.cyan(`Sandbox status for ${config.project}`));
@@ -64,27 +57,5 @@ export function ls(args = []) {
             process.stdout.write(`  SHORT '-' = no active task bound; that sandbox is free to remove with 'ai sandbox rm <branch>'.\n`);
         }
     }
-    p.log.step('Worktrees');
-    const worktrees = listChildren(config.worktreeBase);
-    if (worktrees.length === 0) {
-        p.log.warn('  No sandbox worktrees');
-    }
-    else {
-        for (const worktree of worktrees) {
-            process.stdout.write(`  ${worktree}\n`);
-        }
-    }
-    for (const tool of tools) {
-        p.log.step(`${tool.name} state`);
-        const entries = toolProjectDirCandidates(tool, config.project)
-            .flatMap((dir) => listChildren(dir));
-        if (entries.length === 0) {
-            p.log.warn(`  No ${tool.name} sandbox state`);
-            continue;
-        }
-        for (const entry of entries) {
-            process.stdout.write(`  ${entry}\n`);
-        }
-    }
 }
 //# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { loadConfig } from "../config.js";
+import { assertValidBranchName, worktreeDirCandidates } from "../constants.js";
+import { resolveBranchArg } from "./list-running.js";
+import { resolveTools, toolConfigDirCandidates } from "../tools.js";
+const USAGE = `Usage: ai sandbox show <branch | TASK-id | N | '#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
+branch name are also accepted. Use 'ai sandbox ls' for the container list.`;
+function existingDirs(candidates) {
+    const seen = new Set();
+    const result = [];
+    for (const candidate of candidates) {
+        if (!seen.has(candidate) && fs.existsSync(candidate)) {
+            seen.add(candidate);
+            result.push(candidate);
+        }
+    }
+    return result;
+}
+export function collectSandboxDetail(config, branch) {
+    const worktrees = existingDirs(worktreeDirCandidates(config, branch));
+    const toolStates = resolveTools(config).map((tool) => ({
+        name: tool.name,
+        entries: existingDirs(toolConfigDirCandidates(tool, config.project, branch))
+    }));
+    return { worktrees, toolStates };
+}
+export function show(args = []) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(`${USAGE}\n`);
+        if (args.length === 0) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const config = loadConfig();
+    const branch = resolveBranchArg(args[0], { repoRoot: config.repoRoot });
+    assertValidBranchName(branch);
+    const detail = collectSandboxDetail(config, branch);
+    p.intro(pc.cyan(`Sandbox detail for ${config.project} · ${branch}`));
+    p.log.step('Worktree');
+    if (detail.worktrees.length === 0) {
+        p.log.warn('  No worktree for this branch');
+    }
+    else {
+        for (const worktree of detail.worktrees) {
+            process.stdout.write(`  ${worktree}\n`);
+        }
+    }
+    for (const tool of detail.toolStates) {
+        p.log.step(`${tool.name} state`);
+        if (tool.entries.length === 0) {
+            p.log.warn(`  No ${tool.name} sandbox state`);
+            continue;
+        }
+        for (const entry of tool.entries) {
+            process.stdout.write(`  ${entry}\n`);
+        }
+    }
+}
+//# sourceMappingURL=show.js.map

package/dist/lib/sandbox/index.js

@@ -9,6 +9,8 @@ Commands:
   ls                           List sandboxes for the current project (the '#'
                                column is a display-only row number; the 'SHORT'
                                column shows the active task short id, '-' if none)
+  show <branch | TASK-id | N | '#N'>
+                               Show one sandbox's worktree and per-tool state paths
   prune [--dry-run]            Remove orphaned per-branch state dirs
   rebuild [--quiet] [--refresh]
                                Rebuild the sandbox image (--refresh pulls base + tools)
@@ -52,6 +54,11 @@ export async function runSandbox(args) {
             ls(rest);
             break;
         }
+        case 'show': {
+            const { show } = await import("./commands/show.js");
+            show(rest);
+            break;
+        }
         case 'prune': {
             const { prune } = await import("./commands/prune.js");
             await prune(rest);

package/dist/lib/task/commands/issue-body.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import { resolveTaskRef } from "../resolve-ref.js";
+import { extractTitle } from "../frontmatter.js";
+import { extractSection, findSectionHeading } from "../sections.js";
+import { renderTemplateBody, PLACEHOLDER } from "../issue-form.js";
+const USAGE = `Usage: ai task issue-body <N | #N | TASK-id> [--template <path>]
+
+Print a deterministic Issue body extracted from a task's task.md.
+  <ref>               Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  --template <path>   Render the final body for the given GitHub Issue Form (scenario A);
+                      without it, print the default '描述 + 需求' body (scenario B).
+
+Only the task title, '## 描述' and '## 需求' sections are ever emitted; the rest of
+task.md (scaffolding sections, placeholders) is never written to the body.
+`;
+const DESCRIPTION_ALIASES = ['描述', 'Description'];
+const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
+/**
+ * Build the scenario B default body, mirroring whichever heading language the
+ * task.md actually uses, with empty sections falling back to `N/A`.
+ */
+function buildDefaultBody(content) {
+    const descHeading = findSectionHeading(content, DESCRIPTION_ALIASES);
+    const reqHeading = findSectionHeading(content, REQUIREMENTS_ALIASES);
+    const description = extractSection(content, DESCRIPTION_ALIASES) || PLACEHOLDER;
+    const requirements = extractSection(content, REQUIREMENTS_ALIASES) || PLACEHOLDER;
+    return `## ${descHeading}\n\n${description}\n\n## ${reqHeading}\n\n${requirements}\n`;
+}
+function readTaskFields(content) {
+    return {
+        title: extractTitle(content),
+        description: extractSection(content, DESCRIPTION_ALIASES),
+        requirements: extractSection(content, REQUIREMENTS_ALIASES)
+    };
+}
+function issueBody(args = []) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        if (args.length === 0)
+            process.exitCode = 1;
+        return;
+    }
+    let ref;
+    let templatePath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--template') {
+            templatePath = args[i + 1];
+            i += 1;
+        }
+        else if (ref === undefined) {
+            ref = arg;
+        }
+    }
+    if (!ref) {
+        process.stderr.write('ai task issue-body: missing task ref\n');
+        process.exitCode = 1;
+        return;
+    }
+    if (templatePath === undefined && args.includes('--template')) {
+        process.stderr.write('ai task issue-body: --template requires a path\n');
+        process.exitCode = 1;
+        return;
+    }
+    const resolved = resolveTaskRef(ref);
+    if (!resolved.ok) {
+        process.stderr.write(`ai task issue-body: ${resolved.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    if (templatePath !== undefined) {
+        let formText;
+        try {
+            formText = fs.readFileSync(templatePath, 'utf8');
+        }
+        catch (e) {
+            process.stderr.write(`ai task issue-body: cannot read template '${templatePath}': ${e.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            process.stdout.write(renderTemplateBody(formText, readTaskFields(content)));
+        }
+        catch (e) {
+            process.stderr.write(`ai task issue-body: cannot render template '${templatePath}': ${e.message}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    process.stdout.write(buildDefaultBody(content));
+}
+export { issueBody, buildDefaultBody };
+//# sourceMappingURL=issue-body.js.map

package/dist/lib/task/commands/log.js

@@ -9,10 +9,15 @@ completion time (or '(in progress)' while still running).
   <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
 
 Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
+  A human-executed step shows AGENT as 'human' and, when it has no start marker,
+  a '-' STARTED placeholder. Review-step NOTE also carries two human counts in
+  the verdict list, right after blockers/major/minor: manual-verify (env-blocked)
+  and human-decision (current ledger stage total).
 `;
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'];
 // The activity-log H2 heading is language-dependent (zh template / en template).
 const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
+const LEDGER_HEADING_RE = /^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/;
 const NEXT_H2_RE = /^##\s/;
 // `- {time} — **{step}** by {agent} — {note}` ; the separator is an em-dash
 // (U+2014). STEP/AGENT are non-greedy so a note that itself contains ' — ' or
@@ -23,6 +28,21 @@ const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*
 // without the suffix. Pairing therefore keys on the base action (including any
 // `(Round N)`), so every round and every repeated execution pairs on its own.
 const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
+// Short agent tokens that actually appear in activity logs for AI executors
+// (workflow recommended_agents claude/codex/gemini/cursor + enabled TUI opencode;
+// note these differ from the `.airc.json` long names claude-code/gemini-cli).
+// Any other executor token (a human name, possibly CJK) is treated as human.
+const KNOWN_AI_AGENTS = new Set(['claude', 'codex', 'gemini', 'opencode', 'cursor']);
+const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
+const ENV_BLOCKED_RE = /\(\+\s*(\d+)\s+env-blocked\)/i;
+// Same match plus any leading whitespace, so folding the count into the verdict
+// text drops the redundant `(+ n env-blocked)` fragment without leaving a gap.
+const ENV_BLOCKED_STRIP_RE = /\s*\(\+\s*\d+\s+env-blocked\)/i;
+const REVIEW_STAGE_PREFIXES = [
+    { prefix: 'Review Analysis', stage: 'analysis' },
+    { prefix: 'Review Plan', stage: 'plan' },
+    { prefix: 'Review Code', stage: 'code' }
+];
 function parseActivityLog(content) {
     const lines = content.split('\n');
     let i = 0;
@@ -82,6 +102,66 @@ function pairEntries(entries) {
     }
     return rows;
 }
+function parseReviewLedger(content) {
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length && !LEDGER_HEADING_RE.test(lines[i]))
+        i += 1;
+    if (i >= lines.length)
+        return [];
+    const rows = [];
+    for (let j = i + 1; j < lines.length; j += 1) {
+        if (NEXT_H2_RE.test(lines[j]))
+            break;
+        const line = lines[j].trim();
+        if (!line.startsWith('|'))
+            continue;
+        const cells = line
+            .split('|')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+        if (cells.length < 6 || cells[0] === 'id' || /^-+$/.test(cells[0] ?? ''))
+            continue;
+        rows.push({ stage: cells[1], status: cells[4] });
+    }
+    return rows;
+}
+function countHumanDecisionsByStage(rows) {
+    const counts = new Map();
+    for (const row of rows) {
+        if (!isReviewStage(row.stage) || !HUMAN_DECISION_STATUSES.has(row.status))
+            continue;
+        counts.set(row.stage, (counts.get(row.stage) ?? 0) + 1);
+    }
+    return counts;
+}
+function isReviewStage(stage) {
+    return stage === 'analysis' || stage === 'plan' || stage === 'code';
+}
+function reviewStageForStep(step) {
+    return REVIEW_STAGE_PREFIXES.find(({ prefix }) => step.startsWith(prefix))?.stage;
+}
+function humanValidationCount(note) {
+    const match = ENV_BLOCKED_RE.exec(note);
+    return match ? Number(match[1]) : 0;
+}
+// A step is human-executed when its agent token is not a known AI token. Take
+// the first whitespace-delimited token and drop any trailing parenthetical
+// annotation (e.g. `张三 (executed on host)` -> `张三`) before the lookup.
+function isHumanAgent(agent) {
+    const token = agent.trim().split(/\s+/)[0]?.replace(/\(.*$/, '') ?? '';
+    return token !== '' && !KNOWN_AI_AGENTS.has(token);
+}
+// Fold the two human counts into a review row's verdict NOTE: comma-joined, right
+// after the blockers/major/minor list and before the ` → artifact` link, mirroring
+// the review count line. The raw `(+ n env-blocked)` fragment is dropped so the
+// env-blocked number is not shown twice (it becomes the manual-verify count).
+function foldHumanCounts(note, decisions, envBlocked) {
+    const base = note.replace(ENV_BLOCKED_STRIP_RE, '');
+    const group = `Manual-verify: ${envBlocked}, Human-decision: ${decisions}`;
+    const arrow = base.indexOf(' → ');
+    return arrow === -1 ? `${base}, ${group}` : `${base.slice(0, arrow)}, ${group}${base.slice(arrow)}`;
+}
 function log(args = []) {
     if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
@@ -108,18 +188,21 @@ function log(args = []) {
         return;
     }
     const steps = pairEntries(entries);
-    const rows = steps.map((s, idx) => [
-        String(idx + 1),
-        s.step,
-        s.agent,
-        s.started,
-        s.done || (s.started ? '(in progress)' : ''),
-        s.note
-    ]);
+    const humanDecisionCounts = countHumanDecisionsByStage(parseReviewLedger(content));
+    const rows = steps.map((s, idx) => {
+        const stage = reviewStageForStep(s.step);
+        const note = stage
+            ? foldHumanCounts(s.note, humanDecisionCounts.get(stage) ?? 0, humanValidationCount(s.note))
+            : s.note;
+        const human = isHumanAgent(s.agent);
+        const agent = human ? 'human' : s.agent;
+        const started = s.started || (human ? '-' : '');
+        return [String(idx + 1), s.step, agent, started, s.done || (s.started ? '(in progress)' : ''), note];
+    });
     for (const line of formatTable(TABLE_HEADERS, rows, { zebra: Boolean(process.stdout.isTTY) })) {
         process.stdout.write(`${line}\n`);
     }
     process.stdout.write(`Total: ${steps.length} steps\n`);
 }
-export { log, parseActivityLog, pairEntries };
+export { log, parseActivityLog, pairEntries, isHumanAgent };
 //# sourceMappingURL=log.js.map

package/dist/lib/task/index.js

@@ -4,6 +4,7 @@ Commands:
   cat <ref> <artifact | N>               Print a task artifact (by name or number)
   files <ref>                            List artifacts in a task dir (numbered)
   grep <pattern> [ref] [artifact | N]    Literal search across task artifacts (omit ref to scan all)
+  issue-body <ref> [--template <path>]   Print a deterministic Issue body from task.md (描述 + 需求, or an Issue Form)
   log <ref>                              Render a task's activity log as a timeline
   ls [--all | --blocked | --completed]   List tasks (default: active)
   show <N | #N | TASK-id>                Print a task.md
@@ -15,6 +16,8 @@ Examples:
   ai task files 11
   ai task grep resolveArtifact
   ai task grep resolveArtifact 11
+  ai task issue-body 11
+  ai task issue-body 11 --template .github/ISSUE_TEMPLATE/05_other.yml
   ai task log 11
   ai task ls
   ai task show 11
@@ -49,6 +52,11 @@ export async function runTask(args) {
             grep(rest);
             break;
         }
+        case 'issue-body': {
+            const { issueBody } = await import("./commands/issue-body.js");
+            issueBody(rest);
+            break;
+        }
         case 'log': {
             const { log } = await import("./commands/log.js");
             log(rest);

package/dist/lib/task/issue-form.js

@@ -0,0 +1,66 @@
+import { parse } from 'yaml';
+// Field id -> task value mapping (single source of truth, per HD-1).
+// Only ids that map cleanly to title / description / requirements get a value;
+// every other text field gets `N/A`. This deliberately tightens the older
+// "suggested" mapping table (impact / context / alternatives / steps / expected
+// no longer flow into requirements) so the requirements checklist is never
+// pushed into an unrelated field.
+const TITLE_IDS = new Set(['summary', 'title']);
+const DESCRIPTION_IDS = new Set([
+    'description',
+    'problem',
+    'what-happened',
+    'question',
+    'current-content',
+    'issue-description',
+    'detailed-description'
+]);
+const REQUIREMENTS_IDS = new Set(['requirements', 'solution', 'suggested-content']);
+// Only free-text field types carry task content; structural / static fields are skipped.
+const TEXT_FIELD_TYPES = new Set(['input', 'textarea']);
+const PLACEHOLDER = 'N/A';
+function mapFieldValue(id, fields) {
+    if (TITLE_IDS.has(id))
+        return fields.title;
+    if (DESCRIPTION_IDS.has(id))
+        return fields.description;
+    if (REQUIREMENTS_IDS.has(id))
+        return fields.requirements;
+    return '';
+}
+/**
+ * Render the final Issue body for a GitHub Issue Form (scenario A).
+ *
+ * Walks the form's `body[]` in order, skips `markdown` / `dropdown` /
+ * `checkboxes`, and renders each `input` / `textarea` as `### {label}` followed
+ * by the deterministically-mapped task value (or `N/A` when the field has no
+ * reliable source). The template structure is preserved; the whole task.md and
+ * its scaffolding sections are never emitted.
+ *
+ * Throws on unreadable / non-object YAML or a missing `body[]` list so the
+ * caller can fall back to the default body.
+ */
+function renderTemplateBody(formText, fields) {
+    const doc = parse(formText);
+    if (!doc || typeof doc !== 'object' || !Array.isArray(doc.body)) {
+        throw new Error('Issue Form has no body[] list');
+    }
+    const sections = [];
+    for (const raw of doc.body) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const type = typeof raw.type === 'string' ? raw.type : '';
+        if (!TEXT_FIELD_TYPES.has(type))
+            continue;
+        const label = typeof raw.attributes?.label === 'string' ? raw.attributes.label.trim() : '';
+        if (!label)
+            continue;
+        const id = typeof raw.id === 'string' ? raw.id : '';
+        const mapped = mapFieldValue(id, fields);
+        const value = mapped.trim() === '' ? PLACEHOLDER : mapped;
+        sections.push(`### ${label}\n\n${value}`);
+    }
+    return `${sections.join('\n\n')}\n`;
+}
+export { renderTemplateBody, mapFieldValue, PLACEHOLDER };
+//# sourceMappingURL=issue-form.js.map

package/dist/lib/task/sections.js

@@ -0,0 +1,44 @@
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Return the body of the first `## {alias}` section (any alias matches), from
+ * the heading line to the next `## ` heading or EOF. Lines are preserved
+ * verbatim (checkbox text is never normalized); only leading/trailing blank
+ * lines are trimmed. Returns '' when no alias heading is present.
+ */
+function extractSection(content, aliases) {
+    const lines = content.split('\n');
+    let start = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i].trim();
+        if (aliases.some((alias) => new RegExp(`^##\\s+${escapeRegExp(alias)}\\s*$`).test(line))) {
+            start = i + 1;
+            break;
+        }
+    }
+    if (start === -1)
+        return '';
+    let end = lines.length;
+    for (let i = start; i < lines.length; i += 1) {
+        if (/^##\s+/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(start, end).join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
+}
+/**
+ * Return the heading alias that actually appears as a `## {alias}` line, so a
+ * rendered section can mirror the source language. Falls back to the first
+ * alias when none is present.
+ */
+function findSectionHeading(content, aliases) {
+    for (const alias of aliases) {
+        if (new RegExp(`^##\\s+${escapeRegExp(alias)}\\s*$`, 'm').test(content))
+            return alias;
+    }
+    return aliases[0];
+}
+export { extractSection, findSectionHeading };
+//# sourceMappingURL=sections.js.map

package/lib/sandbox/commands/ls.ts

@@ -1,11 +1,8 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { loadConfig } from '../config.ts';
 import { sandboxBranchLabel, sandboxLabel } from '../constants.ts';
 import { detectEngine } from '../engine.ts';
-import { resolveTools, toolProjectDirCandidates } from '../tools.ts';
 import { formatTable } from '../../table.ts';
 import { lookupShortIdByBranch } from '../../task/short-id.ts';
 import { fetchSandboxRows } from './list-running.ts';
@@ -20,7 +17,10 @@ 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').
 A '-' means no active task is bound to that branch, so the sandbox is free
-to remove with "ai sandbox rm <branch>".`;
+to remove with "ai sandbox rm <branch>".
+
+Use "ai sandbox show <ref>" for a single sandbox's worktree and per-tool
+state paths.`;
 
 const CONTAINER_TABLE_HEADERS = ['#', 'SHORT', 'NAMES', 'STATUS', 'BRANCH'] as const;
 
@@ -40,14 +40,6 @@ export function formatContainerTable(rows: ContainerTableRow[], zebra = false):
   );
 }
 
-function listChildren(dir: string): string[] {
-  if (!fs.existsSync(dir)) {
-    return [];
-  }
-
-  return fs.readdirSync(dir).sort().map((entry) => path.join(dir, entry));
-}
-
 export function ls(args: string[] = []): void {
   if (args.length > 0 && (args[0] === '--help' || args[0] === '-h')) {
     process.stdout.write(`${USAGE}\n`);
@@ -56,7 +48,6 @@ export function ls(args: string[] = []): void {
 
   const config = loadConfig();
   const engine = detectEngine(config);
-  const tools = resolveTools(config);
   const label = sandboxLabel(config);
   const { running, nonRunning } = fetchSandboxRows(engine, label, sandboxBranchLabel(config));
 
@@ -87,27 +78,4 @@ export function ls(args: string[] = []): void {
       );
     }
   }
-
-  p.log.step('Worktrees');
-  const worktrees = listChildren(config.worktreeBase);
-  if (worktrees.length === 0) {
-    p.log.warn('  No sandbox worktrees');
-  } else {
-    for (const worktree of worktrees) {
-      process.stdout.write(`  ${worktree}\n`);
-    }
-  }
-
-  for (const tool of tools) {
-    p.log.step(`${tool.name} state`);
-    const entries = toolProjectDirCandidates(tool, config.project)
-      .flatMap((dir) => listChildren(dir));
-    if (entries.length === 0) {
-      p.log.warn(`  No ${tool.name} sandbox state`);
-      continue;
-    }
-    for (const entry of entries) {
-      process.stdout.write(`  ${entry}\n`);
-    }
-  }
 }