@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/lib/sandbox/runtimes/node20.dockerfile

@@ -1,3 +1,10 @@
-RUN bash -o pipefail -c 'curl -fsSL --retry 5 --retry-delay 2 --retry-all-errors https://deb.nodesource.com/setup_20.x | bash -' && \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    bash -o pipefail -c 'curl -fsSL --retry 5 --retry-delay 2 --retry-all-errors https://deb.nodesource.com/setup_20.x | bash -' && \
     apt-get install -y nodejs && \
     rm -rf /var/lib/apt/lists/*

package/lib/sandbox/runtimes/node22.dockerfile

@@ -1,3 +1,10 @@
-RUN bash -o pipefail -c 'curl -fsSL --retry 5 --retry-delay 2 --retry-all-errors https://deb.nodesource.com/setup_22.x | bash -' && \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    bash -o pipefail -c 'curl -fsSL --retry 5 --retry-delay 2 --retry-all-errors https://deb.nodesource.com/setup_22.x | bash -' && \
     apt-get install -y nodejs && \
     rm -rf /var/lib/apt/lists/*

package/lib/sandbox/runtimes/python3.dockerfile

@@ -1,3 +1,10 @@
-RUN apt-get update && apt-get install -y \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    apt-get update && apt-get install -y \
     python3 python3-pip python3-venv \
     && rm -rf /var/lib/apt/lists/*

package/lib/sandbox/shell.ts

@@ -12,6 +12,7 @@ type CommandOptions = {
   stdio?: StdioOptions;
   timeout?: number;
   shell?: boolean;
+  env?: NodeJS.ProcessEnv;
 };
 
 type RunProbeOptions = CommandOptions & {
@@ -23,7 +24,8 @@ function normalizeOptions(opts: CommandOptions = {}, stdio: StdioOptions): Comma
     cwd: opts.cwd,
     encoding: opts.encoding,
     stdio,
-    timeout: opts.timeout ?? DEFAULT_TIMEOUT_MS
+    timeout: opts.timeout ?? DEFAULT_TIMEOUT_MS,
+    env: opts.env
   };
 }
 
@@ -141,7 +143,7 @@ export function runSafe(cmd: string, args: string[], opts: CommandOptions = {}):
 export function commandForEngine(engine: string, cmd: string, args: string[] = []): { cmd: string; args: string[] } {
   if (engine === 'wsl2') {
     const resolvedWrapper = resolveCommand('wsl.exe');
-    return { cmd: resolvedWrapper, args: ['--', cmd, ...args] };
+    return { cmd: resolvedWrapper, args: ['--exec', cmd, ...args] };
   }
 
   if (cmd === 'docker') {

package/lib/sandbox/tool-types.ts

@@ -0,0 +1,143 @@
+type SandboxToolInstall =
+  | Readonly<{ type: 'npm'; cmd: string }>
+  | Readonly<{ type: 'shell'; cmd: string }>;
+
+type SandboxTool = {
+  id: string;
+  name: string;
+  install: SandboxToolInstall;
+  sandboxBase: string;
+  containerMount: string;
+  versionCmd: string;
+  setupHint: string;
+  envVars?: Record<string, string>;
+  hostPreSeedFiles?: Array<{ hostPath: string; sandboxName: string }>;
+  hostPreSeedDirs?: Array<{ hostDir: string; sandboxSubdir: string }>;
+  pathRewriteFiles?: string[];
+  hostLiveMounts?: Array<{ hostPath: string; containerSubpath: string }>;
+  postSetupCmds?: string[];
+  tmpfs?: { size?: string; seed?: string[] };
+};
+
+type SandboxAlias = Readonly<{
+  name: string;
+  command: string;
+}>;
+
+const SANDBOX_HOOK_PHASES = [
+  'prepare',
+  'before-container-create',
+  'after-container-start',
+  'before-enter'
+] as const;
+
+type SandboxHookPhase = (typeof SANDBOX_HOOK_PHASES)[number];
+
+type SandboxHookStatus =
+  | 'ready'
+  | 'skip-client-runtime'
+  | 'warning'
+  | 'fatal'
+  | 'healthy'
+  | 'hard-failure';
+
+type SandboxHookCommand = Readonly<{
+  command: string;
+  args?: readonly string[];
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+}>;
+
+type SandboxHookCommandResult = Readonly<{
+  stdout: string;
+}>;
+
+type AgentClientSandboxHookResult = Readonly<{
+  status: SandboxHookStatus;
+  message?: string;
+}>;
+
+type SandboxResolvedToolState = Readonly<{
+  tool: SandboxTool;
+  dir: string;
+}>;
+
+type SandboxHookCreateContext = Readonly<{
+  hostHome: string;
+  resolvedTools: readonly SandboxResolvedToolState[];
+}>;
+
+type AgentClientSandboxHookContext = Readonly<{
+  signal: AbortSignal;
+  runCommand(command: SandboxHookCommand): Promise<SandboxHookCommandResult>;
+  config?: Readonly<Record<string, unknown>>;
+  plan?: Readonly<Record<string, unknown>>;
+  create?: SandboxHookCreateContext;
+}>;
+
+type AgentClientSandboxHook = Readonly<{
+  id: string;
+  phase: SandboxHookPhase;
+  timeoutMs?: number;
+  run(context: AgentClientSandboxHookContext): Promise<AgentClientSandboxHookResult>;
+}>;
+
+type SandboxToolContext = Readonly<{
+  home: string;
+  project: string;
+}>;
+
+type SandboxRecoveryProbe = Readonly<{
+  script: string;
+  args: readonly string[];
+  user?: string;
+}>;
+
+type SandboxRecoveryFindingDescriptor = Readonly<{
+  repairKind: 'permissions' | 'builtin-link' | 'hard-failure';
+  message: string;
+  path?: string;
+}>;
+
+type SandboxRecoveryRepair = Readonly<{
+  user: string;
+  command: string;
+  args: readonly string[];
+}>;
+
+type AgentClientSandboxRecoveryCheck = Readonly<{
+  id: string;
+  when?: SandboxRecoveryProbe;
+  probe: SandboxRecoveryProbe;
+  finding: SandboxRecoveryFindingDescriptor;
+  repair?: SandboxRecoveryRepair;
+}>;
+
+type AgentClientSandboxDescriptor = Readonly<{
+  createTool(context: SandboxToolContext): SandboxTool;
+  aliases: readonly SandboxAlias[];
+  hooks: readonly AgentClientSandboxHook[];
+  recoveryChecks?: readonly AgentClientSandboxRecoveryCheck[];
+}>;
+
+export { SANDBOX_HOOK_PHASES };
+export type {
+  AgentClientSandboxDescriptor,
+  AgentClientSandboxHook,
+  AgentClientSandboxHookContext,
+  AgentClientSandboxHookResult,
+  AgentClientSandboxRecoveryCheck,
+  SandboxAlias,
+  SandboxHookCommand,
+  SandboxHookCommandResult,
+  SandboxHookPhase,
+  SandboxHookStatus,
+  SandboxHookCreateContext,
+  SandboxRecoveryFindingDescriptor,
+  SandboxRecoveryProbe,
+  SandboxRecoveryRepair,
+  SandboxResolvedToolState,
+  SandboxTool,
+  SandboxToolContext,
+  SandboxToolInstall
+};

package/lib/sandbox/tools.ts

@@ -1,33 +1,10 @@
 import path from 'node:path';
+import { createSandboxCapabilityPlan } from './agent-client-reconciler.ts';
 import { safeNameCandidates, sanitizeBranchName } from './constants.ts';
 import { hostJoin } from './engines/wsl2-paths.ts';
+import type { SandboxTool, SandboxToolInstall } from './tool-types.ts';
 
-export type SandboxToolInstall =
-  | { type: 'npm'; cmd: string }
-  | { type: 'shell'; cmd: string };
-
-export type SandboxTool = {
-  id: string;
-  name: string;
-  install: SandboxToolInstall;
-  sandboxBase: string;
-  containerMount: string;
-  versionCmd: string;
-  setupHint: string;
-  envVars?: Record<string, string>;
-  hostPreSeedFiles?: Array<{ hostPath: string; sandboxName: string }>;
-  hostPreSeedDirs?: Array<{ hostDir: string; sandboxSubdir: string }>;
-  pathRewriteFiles?: string[];
-  hostLiveMounts?: Array<{ hostPath: string; containerSubpath: string }>;
-  postSetupCmds?: string[];
-  // When set, containerMount is mounted as an in-container tmpfs (RAM) instead
-  // of bind-mounting the host config dir, keeping high-churn tool logs off the
-  // host disk. `seed` lists the host-dir entries (relative to the tool's config
-  // dir) to copy into the tmpfs when the container starts. It is an explicit
-  // allowlist so runtime files (e.g. logs_2.sqlite, sessions) left in the host
-  // dir stay out of the container and seeded config cannot write back.
-  tmpfs?: { size?: string; seed?: string[] };
-};
+export type { SandboxTool, SandboxToolInstall } from './tool-types.ts';
 
 export type TmpfsSeedEntry = {
   toolId: string;
@@ -64,114 +41,11 @@ type ToolsConfig = {
   project: string;
   tools: string[];
   customTools?: SandboxTool[];
+  agentClientState?: import('../agent-clients/types.ts').AgentClientState;
 };
 
 const TOOL_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 
-function createBuiltinTools(home: string, project: string): Record<string, SandboxTool> {
-  return {
-    'claude-code': {
-      id: 'claude-code',
-      name: 'Claude Code',
-      install: { type: 'npm', cmd: '@anthropic-ai/claude-code@latest' },
-      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'claude-code'),
-      containerMount: '/home/devuser/.claude',
-      versionCmd: 'claude --version',
-      setupHint: 'Authenticates via host credentials live-mounted at ~/.claude/.credentials.json',
-      // Claude Code stores user data (.claude.json — onboarding state, theme,
-      // workspace trust) at $HOME/.claude.json by default, which sits OUTSIDE
-      // the bind-mounted /home/devuser/.claude tree, so our preseeded
-      // .claude.json never gets read and the theme picker re-runs on every
-      // container start. Pinning CLAUDE_CONFIG_DIR to the tool mount relocates
-      // .claude.json into the same directory as .credentials.json/settings.json,
-      // letting ensureClaudeOnboarding actually take effect.
-      envVars: { CLAUDE_CONFIG_DIR: '/home/devuser/.claude' },
-      hostPreSeedDirs: [
-        { hostDir: hostJoin(home, '.claude', 'plugins'), sandboxSubdir: 'plugins' }
-      ],
-      pathRewriteFiles: [
-        'plugins/installed_plugins.json',
-        'plugins/known_marketplaces.json'
-      ],
-      hostLiveMounts: [
-        {
-          hostPath: hostJoin(home, '.agent-infra', 'credentials', project, 'claude-code', '.credentials.json'),
-          containerSubpath: '.credentials.json'
-        }
-      ]
-    },
-    codex: {
-      id: 'codex',
-      name: 'Codex',
-      install: { type: 'npm', cmd: '@openai/codex' },
-      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'codex'),
-      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.
-      // Seeded config (config.toml, model-catalogs) is copied into the tmpfs at
-      // startup; runtime files like logs_2.sqlite stay in RAM.
-      tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
-      hostLiveMounts: [
-        { hostPath: hostJoin(home, '.codex', 'auth.json'), containerSubpath: 'auth.json' }
-      ],
-      postSetupCmds: [
-        'test -d /workspace/.codex/commands && ln -sfn /workspace/.codex/commands /home/devuser/.codex/prompts || true'
-      ]
-    },
-    opencode: {
-      id: 'opencode',
-      name: 'OpenCode',
-      install: { type: 'npm', cmd: 'opencode-ai' },
-      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'opencode'),
-      containerMount: '/home/devuser/.local/share/opencode',
-      versionCmd: 'opencode version',
-      setupHint: 'Configure OpenCode credentials inside the container before first use.',
-      // OpenCode reads opencode.json from $XDG_CONFIG_HOME/opencode by default,
-      // outside this tool mount. Pin the config file path so the inherited
-      // sandbox opencode.json is the one the TUI actually reads.
-      envVars: { OPENCODE_CONFIG: '/home/devuser/.local/share/opencode/opencode.json' },
-      hostLiveMounts: [
-        {
-          hostPath: hostJoin(home, '.local', 'share', 'opencode', 'auth.json'),
-          containerSubpath: 'auth.json'
-        }
-      ]
-    },
-    'gemini-cli': {
-      id: 'gemini-cli',
-      name: 'Gemini CLI',
-      install: { type: 'npm', cmd: '@google/gemini-cli' },
-      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'gemini-cli'),
-      containerMount: '/home/devuser/.gemini',
-      versionCmd: 'gemini --version',
-      setupHint: 'Run gemini inside the container to finish authentication.',
-      hostLiveMounts: [
-        { hostPath: hostJoin(home, '.gemini', 'oauth_creds.json'), containerSubpath: 'oauth_creds.json' }
-      ],
-      hostPreSeedFiles: [
-        { hostPath: hostJoin(home, '.gemini', 'settings.json'), sandboxName: 'settings.json' },
-        { hostPath: hostJoin(home, '.gemini', 'google_accounts.json'), sandboxName: 'google_accounts.json' }
-      ]
-    },
-    'agent-infra': {
-      id: 'agent-infra',
-      name: 'agent-infra CLI',
-      install: { type: 'npm', cmd: '@fitlab-ai/agent-infra@latest' },
-      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'agent-infra'),
-      containerMount: '/home/devuser/.agent-infra-cli',
-      versionCmd: 'ai version --raw',
-      setupHint: 'Provides the ai and agent-infra CLI commands inside the sandbox.'
-    }
-  };
-}
-
-export function builtinToolIds(): string[] {
-  return Object.keys(createBuiltinTools('', ''));
-}
-
 function validateTool(tool: SandboxTool): void {
   if (!tool.id || !TOOL_ID_PATTERN.test(tool.id)) {
     throw new Error(`Invalid sandbox tool id: ${String(tool.id)}`);
@@ -379,33 +253,7 @@ export function parseCustomTools(value: unknown, options: { home: string }): San
 }
 
 export function resolveTools(config: ToolsConfig): SandboxTool[] {
-  const builtins = createBuiltinTools(config.home, config.project);
-  const customs = config.customTools ?? [];
-
-  const seen = new Set<string>();
-  for (const tool of customs) {
-    if (builtins[tool.id]) {
-      throw new Error(`Custom sandbox tool id "${tool.id}" collides with a built-in tool`);
-    }
-    if (seen.has(tool.id)) {
-      throw new Error(`Duplicate sandbox tool id "${tool.id}" in customTools`);
-    }
-    seen.add(tool.id);
-  }
-
-  const merged: Record<string, SandboxTool> = { ...builtins };
-  for (const tool of customs) {
-    merged[tool.id] = tool;
-  }
-
-  return config.tools.map((id) => {
-    const tool = merged[id];
-    if (!tool) {
-      throw new Error(`Unknown sandbox tool: ${id}`);
-    }
-    validateTool(tool);
-    return tool;
-  });
+  return [...createSandboxCapabilityPlan(config).tools];
 }
 
 export function toolConfigDir(tool: SandboxTool, project: string, branch: string): string {

package/lib/task/artifact-lifecycle.ts

@@ -5,6 +5,7 @@ import { resolveTaskRef } from './resolve-ref.ts';
 import type { ResolveTaskRefErrorCode, TaskWorkspaceState } from './resolve-ref.ts';
 import { locateActivityLog } from './activity-log.ts';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.ts';
+import { parseVerdict } from './review-artifacts.ts';
 import { extractSection, findSectionHeading } from './sections.ts';
 
 const artifactFamilyCatalog = [
@@ -239,21 +240,6 @@ function resolveReviewedInput(
   }
 }
 
-function extractMarkdownSection(content: string, names: readonly string[]): string {
-  const lines = content.split(/\r?\n/);
-  const allowed = new Set(names);
-  const start = lines.findIndex((line) => {
-    const match = /^##\s+(.+?)\s*$/.exec(line.trim());
-    return Boolean(match?.[1] && allowed.has(match[1]));
-  });
-  if (start === -1) return '';
-  let end = lines.length;
-  for (let index = start + 1; index < lines.length; index += 1) {
-    if (/^##\s+/.test(lines[index]!)) { end = index; break; }
-  }
-  return lines.slice(start + 1, end).join('\n');
-}
-
 function assertWritableInventory(inventory: ArtifactInventoryResult): ArtifactError | null {
   if (inventory.status === 'failed') return inventory.error;
   const blockers = inventory.diagnostics.filter((item) => BLOCKING_DIAGNOSTICS.has(item.code));
@@ -398,29 +384,6 @@ function resolveDecisionImplementationInput(
   catch (error) { return { error: error instanceof Error ? error.message : String(error) }; }
 }
 
-function normalizeVerdict(value: string): 'Approved' | 'Changes Requested' | 'Rejected' | null {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === '通过' || normalized === 'approved') return 'Approved';
-  if (normalized === '需要修改' || normalized === 'changes requested') return 'Changes Requested';
-  if (normalized === '拒绝' || normalized === 'rejected') return 'Rejected';
-  return null;
-}
-
-function parseVerdict(file: string): { ok: true; verdict: string } | { ok: false; message: string } {
-  let content: string;
-  try { content = fs.readFileSync(file, 'utf8'); }
-  catch (error) { return { ok: false, message: String(error) }; }
-  const summary = extractMarkdownSection(content, ['审查摘要', 'Review Summary']);
-  const verdictMatch = /^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.+?)\s*$/im.exec(summary);
-  const verdict = verdictMatch?.[1] ? normalizeVerdict(verdictMatch[1]) : null;
-  if (!verdict) return { ok: false, message: `cannot parse verdict in ${path.basename(file)}` };
-  if (verdict !== 'Approved') return { ok: true, verdict };
-  const findings = /^[-*]?\s*\*\*(?:发现（AI 可处理）|Findings \(AI-actionable\))\*\*[:：]\s*(.+?)\s*$/im.exec(summary)?.[1];
-  const counts = findings?.match(/(\d+)\s*(?:阻塞项|blockers?).*?(\d+)\s*(?:主要|majors?).*?(\d+)\s*(?:次要|minors?)/i);
-  if (!counts) return { ok: false, message: `cannot parse findings count in ${path.basename(file)}` };
-  return { ok: true, verdict: counts.slice(1).some((value) => Number(value) > 0) ? 'Approved-with-issues' : 'Approved' };
-}
-
 function validateCompletedArtifact(taskDir: string, family: ArtifactFamily, name: string, round?: number): { ok: true; artifact: ArtifactIdentity } | { ok: false; error: ArtifactError } {
   if (path.basename(name) !== name) return { ok: false, error: { code: 'ARTIFACT_PATH_INVALID', message: 'artifact must be a top-level basename' } };
   const parsed = parseArtifactName(name);

package/lib/task/commands/decisions.ts

@@ -10,8 +10,9 @@ import { extractSubSection } from '../sections.ts';
 const USAGE = `Usage: ai task decisions [--task <ref> | -t <ref>] [--item <selector> | -i <selector>] [options]
        ai task decisions <ref> [selector] [options]
 
-Lists decision items recorded in a task's review disagreement
-ledger, or prints the full detail block for a single item. Read-only.
+Shows what still needs a maintainer's decision. Without a selector, it lists
+the choices. With a selector, it shows the explanation and how to respond.
+Read-only.
 
   Omit <ref>     Resolve the unique active task for the current branch.
   <ref>          Legacy positional task ref.
@@ -150,29 +151,31 @@ function findDecisionRecord(id: string, content: string): string[] {
 function titleOf(row: LedgerRow, taskDir: string): string {
   const block = findDetailBlock(row, taskDir);
   if (block) {
-    return block
+    const title = block
       .split('\n')[0]!
       .replace(/^###\s+/, '')
       .replace(/\s*\[needs-human-decision\]\s*$/, '')
       .trim();
+    return title.replace(new RegExp(`^${row.id}\\s*[:：]\\s*`, 'i'), '').trim();
   }
-  return row.evidence || '(无详情)';
+  return '(explanation unavailable)';
+}
+
+function trackingOf(row: LedgerRow): string {
+  return `stage=${row.stage} · severity=${row.severity} · status=${row.status} · evidence=${row.evidence}`;
 }
 
 function renderList(rows: LedgerRow[], format: string, taskDir: string): void {
   if (rows.length === 0) {
-    process.stdout.write('无待裁决项。\n');
+    process.stdout.write('No pending decisions.\n');
     return;
   }
-  const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+  const headers = ['#', 'CHOICE', 'WHAT NEEDS A DECISION', 'TRACKING'];
   const data = rows.map((r, i) => [
     String(i + 1),
     r.id,
-    r.stage,
-    r.severity,
-    r.status,
-    r.evidence,
-    titleOf(r, taskDir)
+    titleOf(r, taskDir),
+    trackingOf(r)
   ]);
   if (format === 'markdown') {
     const sep = headers.map(() => '---');
@@ -181,10 +184,29 @@ function renderList(rows: LedgerRow[], format: string, taskDir: string): void {
       `| ${sep.join(' | ')} |`,
       ...data.map((row) => `| ${row.join(' | ')} |`)
     ];
-    process.stdout.write(`${md.join('\n')}\n`);
+    process.stdout.write(`${md.join('\n')}\n\nView one item: ai task decisions <task-ref> <ordinal|ledger-id>\n`);
     return;
   }
-  process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+  process.stdout.write(`${formatTable(headers, data).join('\n')}\n\nView one item: ai task decisions <task-ref> <ordinal|ledger-id>\n`);
+}
+
+function renderTracking(row: LedgerRow, format: string): string[] {
+  if (format === 'markdown') {
+    return [
+      '**Tracking**',
+      `- stage: \`${row.stage}\``,
+      `- severity: \`${row.severity}\``,
+      `- status: \`${row.status}\``,
+      `- evidence: \`${row.evidence}\``
+    ];
+  }
+  return [
+    'Tracking:',
+    `stage: ${row.stage}`,
+    `severity: ${row.severity}`,
+    `status: ${row.status}`,
+    `evidence: ${row.evidence}`
+  ];
 }
 
 function renderDetail(
@@ -201,25 +223,36 @@ function renderDetail(
   }
   const r = selected.row;
   const block = findDetailBlock(r, taskDir);
+  const title = titleOf(r, taskDir);
   const lines: string[] = [];
+  const decided = r.status === 'human-decided';
   if (format === 'markdown') {
-    lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+    lines.push(`## ${decided ? 'Decision already recorded' : 'Decision needed'}: ${title}`, '');
+    if (!decided) {
+      lines.push('**How to record your choice**', `\`ai decide <task-ref> ${r.id} <your choice and rationale>\``, '');
+    }
+    lines.push('**Original context**', '');
   } else {
-    lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+    lines.push(`${decided ? 'Decision already recorded' : 'Decision needed'}: ${title}`, '');
+    if (!decided) {
+      lines.push('How to record your choice:', `ai decide <task-ref> ${r.id} <your choice and rationale>`, '');
+    }
+    lines.push('Original context:');
   }
   if (block) {
     lines.push(block);
   } else {
     lines.push(
-      `（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`
+      `This older task does not include a full explanation for ${r.id}.`,
+      'Use the tracking reference below to find the original context.'
     );
   }
-  if (r.status === 'human-decided') {
+  if (decided) {
     const record = findDecisionRecord(r.id, content);
-    if (record.length) {
-      lines.push('', '人工裁定：', ...record);
-    }
+    lines.push('', format === 'markdown' ? '**Recorded choice**' : 'Recorded choice:');
+    lines.push(...(record.length ? record : ['No separate ruling record was found.']));
   }
+  lines.push('', ...renderTracking(r, format));
   process.stdout.write(`${lines.join('\n')}\n`);
 }
 

package/lib/task/commands/issue-body.ts

@@ -12,12 +12,13 @@ Print a deterministic Issue body extracted from a task's task.md.
   Omit <ref>           Resolve the unique active task for the current branch.
   <ref>               Bare numeric 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).
+                      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.
+Only the task title, '## 任务输入', '## 描述' and '## 需求' sections are ever
+emitted; the rest of task.md is never written to the body.
 `;
 
+const TASK_INPUT_ALIASES = ['任务输入', 'Task Input'];
 const DESCRIPTION_ALIASES = ['描述', 'Description'];
 const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
 
@@ -26,18 +27,22 @@ const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
  * task.md actually uses, with empty sections falling back to `N/A`.
  */
 function buildDefaultBody(content: string): string {
+  const taskInputHeading = findSectionHeading(content, TASK_INPUT_ALIASES);
   const descHeading = findSectionHeading(content, DESCRIPTION_ALIASES);
   const reqHeading = findSectionHeading(content, REQUIREMENTS_ALIASES);
+  const taskInput = extractSection(content, TASK_INPUT_ALIASES) || PLACEHOLDER;
   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`;
+  return `## ${taskInputHeading}\n\n${taskInput}\n\n## ${descHeading}\n\n${description}\n\n## ${reqHeading}\n\n${requirements}\n`;
 }
 
 function readTaskFields(content: string): TaskFields {
   return {
     title: extractTitle(content),
     description: extractSection(content, DESCRIPTION_ALIASES),
-    requirements: extractSection(content, REQUIREMENTS_ALIASES)
+    requirements: extractSection(content, REQUIREMENTS_ALIASES),
+    taskInput: extractSection(content, TASK_INPUT_ALIASES),
+    taskInputHeading: findSectionHeading(content, TASK_INPUT_ALIASES)
   };
 }