@fitlab-ai/agent-infra 0.7.5 → 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/create.js

@@ -820,6 +820,12 @@ function runEngineTaskCommand(engine, cmd, args, opts = {}) {
     const command = commandForEngine(engine, cmd, args);
     return runTaskCommand(command.cmd, command.args, opts);
 }
+// `docker run` args for mounting a tool's containerMount as an in-container
+// tmpfs. containerMount is an in-container path, so it is NOT engine-converted.
+export function buildTmpfsRunArgs(containerMount, tmpfs) {
+    const size = tmpfs.size ?? '512m';
+    return ['--tmpfs', `${containerMount}:rw,size=${size}`];
+}
 export function buildImage(config, tools, dockerfilePath, imageSignature, { engine, runFn = runEngine, runSafeFn = runSafeEngine, runVerboseFn = runVerboseEngine, env = process.env } = {}) {
     const selectedEngine = engine ?? detectEngine({ engine: config.engine });
     const { uid: hostUid, gid: hostGid } = resolveBuildUid({
@@ -1076,10 +1082,8 @@ export async function create(args) {
                             // The TUI reads <toolDir>/opencode.json via OPENCODE_CONFIG pinned in tools.js.
                             ensureOpenCodeModelInheritance(opencodeEntry.dir, effectiveConfig.home);
                         }
-                        const toolVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) => [
-                            '-v',
-                            volumeArg(engine, dir, tool.containerMount)
-                        ]);
+                        const toolVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) => tool.tmpfs ? [] : ['-v', volumeArg(engine, dir, tool.containerMount)]);
+                        const tmpfsArgs = effectiveResolvedTools.flatMap(({ tool }) => tool.tmpfs ? buildTmpfsRunArgs(tool.containerMount, tool.tmpfs) : []);
                         const workspaceDir = path.join(effectiveConfig.repoRoot, '.agents', 'workspace');
                         hostShellConfig = prepareHostShellConfig({
                             home: effectiveConfig.home,
@@ -1091,6 +1095,22 @@ export async function create(args) {
                             '-v',
                             volumeArg(engine, hostPath, containerPath, ':ro')
                         ]);
+                        // A tmpfs containerMount starts empty, so the config seeded into the
+                        // host dir before launch would be invisible in-container. Bind only
+                        // the explicitly declared seed entries (config.toml, model-catalogs)
+                        // back over the tmpfs as nested mounts — the same proven mechanism as
+                        // hostLiveMounts/auth.json, established at `docker run` time (no
+                        // post-start `docker cp`, which can land under a freshly-mounted
+                        // tmpfs instead of inside it). The allowlist is deliberate: any
+                        // runtime files left in the host dir (e.g. a stale logs_2.sqlite or
+                        // sessions/ from a previous bind-mount era) must NOT be re-mounted,
+                        // or the high-churn writes would land on the host SSD again.
+                        const tmpfsSeedVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) => (tool.tmpfs?.seed ?? []).flatMap((entry) => {
+                            const hostPath = path.join(dir, entry);
+                            return fs.existsSync(hostPath)
+                                ? ['-v', volumeArg(engine, hostPath, path.posix.join(tool.containerMount, entry))]
+                                : [];
+                        }));
                         const liveMountVolumes = effectiveResolvedTools.flatMap(({ tool }) => (tool.hostLiveMounts ?? [])
                             .filter(({ hostPath }) => fs.existsSync(hostPath))
                             .flatMap(({ hostPath, containerSubpath }) => [
@@ -1133,6 +1153,8 @@ export async function create(args) {
                             volumeArg(engine, hostJoin(effectiveConfig.home, '.ssh'), '/home/devuser/.ssh', ':ro'),
                             ...dotfilesMount,
                             ...toolVolumes,
+                            ...tmpfsArgs,
+                            ...tmpfsSeedVolumes,
                             ...liveMountVolumes,
                             ...shellConfigVolumes,
                             ...envFile.dockerArgs,

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/sandbox/tools.js

@@ -41,6 +41,12 @@ function createBuiltinTools(home, project) {
             containerMount: '/home/devuser/.codex',
             versionCmd: 'codex --version',
             setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
+            // codex churns ~/.codex/logs_2.sqlite heavily (upstream openai/codex#24275);
+            // a bind-mount would write-amplify onto the host SSD via virtiofs. Mount the
+            // codex home as tmpfs so those logs stay in RAM and die with the container.
+            // Only the seeded config (config.toml, model-catalogs) is bound back over
+            // the tmpfs; runtime files like logs_2.sqlite must stay in RAM.
+            tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
             hostLiveMounts: [
                 { hostPath: hostJoin(home, '.codex', 'auth.json'), containerSubpath: 'auth.json' }
             ],
@@ -218,6 +224,18 @@ function parseHostLiveMounts(value, context) {
         };
     });
 }
+function parseTmpfs(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(value)) {
+        throw new Error(`${context}: field "tmpfs" must be an object when provided`);
+    }
+    return {
+        size: asOptionalNonEmptyString(value.size, 'tmpfs.size', context),
+        seed: asStringArray(value.seed, 'tmpfs.seed', context)
+    };
+}
 export function parseCustomTool(entry, index, options) {
     const context = `customTools[${index}]`;
     if (!isPlainObject(entry)) {
@@ -246,7 +264,8 @@ export function parseCustomTool(entry, index, options) {
         hostPreSeedDirs: parseHostPreSeedDirs(entry.hostPreSeedDirs, context),
         pathRewriteFiles: asStringArray(entry.pathRewriteFiles, 'pathRewriteFiles', context),
         hostLiveMounts: parseHostLiveMounts(entry.hostLiveMounts, context),
-        postSetupCmds: asStringArray(entry.postSetupCmds, 'postSetupCmds', context)
+        postSetupCmds: asStringArray(entry.postSetupCmds, 'postSetupCmds', context),
+        tmpfs: parseTmpfs(entry.tmpfs, context)
     };
     validateTool(tool);
     return tool;

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

@@ -3,19 +3,46 @@ import { formatTable } from "../../table.js";
 import { resolveTaskRef } from "../resolve-ref.js";
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
-Renders a task's activity log as a chronological timeline table.
+Renders a task's activity log as a per-step status table. A step's start and
+completion are paired onto one row: STARTED holds the start time, DONE the
+completion time (or '(in progress)' while still running).
   <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
 
-Columns: # (timeline position) / TIME / STEP / AGENT / NOTE
+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 = ['#', 'TIME', 'STEP', 'AGENT', 'NOTE'];
+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
 // '→' is not mis-split; NOTE greedily takes the rest of the line.
 const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*\*(.+?)\*\* by (.+?) — (.*)$/;
+// A start marker reuses the normal entry grammar and only suffixes its action
+// with ` [started]`; the matching done entry carries the identical base action
+// 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;
@@ -40,6 +67,101 @@ function parseActivityLog(content) {
     parsed.sort((a, b) => a.epoch - b.epoch || a.order - b.order);
     return { sectionFound: true, entries: parsed.map((p) => p.entry) };
 }
+// Collapse a chronological entry list into per-step rows: a `[started]` marker
+// opens a row, the next matching done entry fills it in place (FIFO per base
+// action). Started-only rows stay in flight; done-only entries (legacy logs with
+// no start marker) render as standalone rows. Result order = first-seen order,
+// which is already ascending because `entries` is sorted ascending.
+function pairEntries(entries) {
+    const rows = [];
+    const open = new Map();
+    for (const e of entries) {
+        const isStarted = STARTED_SUFFIX_RE.test(e.step);
+        const base = e.step.replace(STARTED_SUFFIX_RE, '');
+        if (isStarted) {
+            const row = { step: base, agent: e.agent, started: e.time, done: '', note: e.note };
+            rows.push(row);
+            const queue = open.get(base);
+            if (queue)
+                queue.push(row);
+            else
+                open.set(base, [row]);
+        }
+        else {
+            const pending = open.get(base)?.shift();
+            if (pending) {
+                // Done fills the open row; the done entry carries the meaningful note.
+                pending.done = e.time;
+                pending.agent = e.agent;
+                pending.note = e.note;
+            }
+            else {
+                rows.push({ step: base, agent: e.agent, started: '', done: e.time, note: e.note });
+            }
+        }
+    }
+    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);
@@ -65,11 +187,22 @@ function log(args = []) {
         process.exitCode = 1;
         return;
     }
-    const rows = entries.map((e, idx) => [String(idx + 1), e.time, e.step, e.agent, e.note]);
+    const steps = pairEntries(entries);
+    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: ${entries.length} entries\n`);
+    process.stdout.write(`Total: ${steps.length} steps\n`);
 }
-export { log, parseActivityLog };
+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);