@fitlab-ai/agent-infra 0.7.7 → 0.8.1

package/lib/server/runner.ts

@@ -0,0 +1,95 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type RunnerResult = {
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+};
+
+export type RunnerOptions = {
+  spawn?: (file: string, args: string[], onChunk?: (chunk: string) => void | Promise<void>) => Promise<RunnerResult>;
+  onChunk?: (chunk: string) => void | Promise<void>;
+};
+
+function resolveCommand(file: string): string {
+  if (process.platform !== 'win32' || path.extname(file)) {
+    return file;
+  }
+
+  const pathValue = process.env.Path || process.env.PATH || '';
+  const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
+  for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+    for (const extension of extensions) {
+      const lowerCandidate = path.join(dir, `${file}${extension.toLowerCase()}`);
+      if (fs.existsSync(lowerCandidate)) return lowerCandidate;
+      const upperCandidate = path.join(dir, `${file}${extension.toUpperCase()}`);
+      if (fs.existsSync(upperCandidate)) return upperCandidate;
+    }
+  }
+
+  return file;
+}
+
+function needsShell(file: string): boolean {
+  return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
+}
+
+function spawnCapture(
+  file: string,
+  args: string[],
+  onChunk?: (chunk: string) => void | Promise<void>
+): Promise<RunnerResult> {
+  return new Promise((resolve, reject) => {
+    const resolvedFile = resolveCommand(file);
+    const child = spawn(resolvedFile, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: needsShell(resolvedFile)
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let pendingChunks = Promise.resolve();
+
+    const rejectOnce = (error: unknown): void => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+
+    const resolveOnce = (result: RunnerResult): void => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    const enqueueChunk = (chunk: string): void => {
+      if (!onChunk) return;
+      pendingChunks = pendingChunks.then(() => onChunk(chunk));
+      pendingChunks.catch(rejectOnce);
+    };
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+      enqueueChunk(chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+      enqueueChunk(chunk);
+    });
+    child.on('error', rejectOnce);
+    child.on('close', (exitCode, signal) => {
+      pendingChunks
+        .then(() => resolveOnce({ exitCode, signal, stdout, stderr }))
+        .catch(rejectOnce);
+    });
+  });
+}
+
+export async function runAi(args: string[], options: RunnerOptions = {}): Promise<RunnerResult> {
+  return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+}

package/lib/server/server.schema.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/fitlab-ai/agent-infra/lib/server/server.schema.json",
+  "title": "agent-infra server configuration",
+  "description": "Schema for .agents/server.json. Secrets (appSecret, tokens, passwords) must NOT be committed here — put them in .agents/server.local.json or AGENT_INFRA_SERVER_* environment variables.",
+  "type": "object",
+  "additionalProperties": true,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "log": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "path": {
+          "type": "string",
+          "description": "Log file path. Defaults to ~/.agent-infra/logs/<project>/<repo-hash>/server.log (outside the repo; the repo-hash isolates checkouts that share a project). Relative paths resolve against the repo root; absolute paths are used as-is."
+        },
+        "rotateAtBytes": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Rotate the log to <path>.1 at startup if it already exceeds this size.",
+          "default": 52428800
+        }
+      }
+    },
+    "heartbeatMs": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Interval between daemon heartbeat log lines, in milliseconds.",
+      "default": 30000
+    },
+    "adapters": {
+      "type": "object",
+      "description": "Per-adapter configuration. Only adapters with enabled=true are loaded.",
+      "properties": {
+        "feishu": {
+          "type": "object",
+          "description": "Feishu (Lark) IM adapter. The appSecret must NOT be committed here — put it in .agents/server.local.json or AGENT_INFRA_SERVER_adapters__feishu__appSecret.",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": false
+            },
+            "appId": {
+              "type": "string",
+              "description": "Feishu self-built app App ID."
+            },
+            "domain": {
+              "type": "string",
+              "enum": ["feishu", "lark"],
+              "default": "feishu",
+              "description": "Open platform domain: feishu (default) or lark."
+            }
+          },
+          "required": ["enabled"]
+        }
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "enabled": {
+            "type": "boolean",
+            "default": false
+          }
+        },
+        "required": ["enabled"]
+      }
+    },
+    "command": {
+      "type": "object",
+      "description": "Command protocol defaults and skill allow-list.",
+      "additionalProperties": false,
+      "properties": {
+        "defaultTui": {
+          "type": "string",
+          "enum": ["claude", "codex", "gemini", "opencode"],
+          "default": "codex"
+        },
+        "skillTuiDefaults": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "enum": ["claude", "codex", "gemini", "opencode"]
+          }
+        },
+        "allowedSkills": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    },
+    "auth": {
+      "type": "object",
+      "description": "Adapter-qualified user roles. Keys look like feishu:ou_xxx.",
+      "additionalProperties": false,
+      "properties": {
+        "users": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+              "role": {
+                "type": "string",
+                "enum": ["read", "write", "exec"]
+              },
+              "name": { "type": "string" }
+            },
+            "required": ["role"]
+          }
+        }
+      }
+    },
+    "stream": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "throttleMs": { "type": "integer", "minimum": 0, "default": 1500 },
+        "chunkChars": { "type": "integer", "minimum": 1, "default": 4000 },
+        "tailChars": { "type": "integer", "minimum": 1, "default": 8000 },
+        "timeoutMs": { "type": "integer", "minimum": 1, "default": 1800000 }
+      }
+    }
+  }
+}

package/lib/server/streamer.ts

@@ -0,0 +1,57 @@
+import { redactSecrets } from './redact.ts';
+import type { RunnerResult } from './runner.ts';
+
+export type StreamOptions = {
+  title: string;
+  chunkChars?: number;
+  throttleMs?: number;
+};
+
+function chunks(text: string, size: number): string[] {
+  if (text.length === 0) return [];
+  const out: string[] = [];
+  for (let i = 0; i < text.length; i += size) {
+    out.push(text.slice(i, i + size));
+  }
+  return out;
+}
+
+export async function streamCommand(
+  options: StreamOptions,
+  run: (emit?: (chunk: string) => Promise<void>) => Promise<RunnerResult>,
+  send: (text: string) => Promise<void>
+): Promise<RunnerResult> {
+  await send(`started ${options.title}`);
+  const size = options.chunkChars ?? 4000;
+  const throttleMs = options.throttleMs ?? 0;
+  let streamed = false;
+  let buffer = '';
+  let lastFlush = 0;
+
+  const flush = async (): Promise<void> => {
+    if (!buffer) return;
+    const text = redactSecrets(buffer);
+    buffer = '';
+    lastFlush = Date.now();
+    for (const chunk of chunks(text, size)) {
+      await send(chunk);
+    }
+  };
+
+  const emit = async (chunk: string): Promise<void> => {
+    streamed = true;
+    buffer += chunk;
+    const due = throttleMs === 0 || Date.now() - lastFlush >= throttleMs;
+    if (buffer.length >= size || due) {
+      await flush();
+    }
+  };
+
+  const result = await run(emit);
+  if (!streamed) {
+    buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
+  }
+  await flush();
+  await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+  return result;
+}

package/lib/task/commands/decisions.ts

@@ -0,0 +1,272 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatTable } from '../../table.ts';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { parseLedger, HUMAN_DECISION_STATUSES, type LedgerRow } from '../ledger.ts';
+import { extractSubSection } from '../sections.ts';
+
+const USAGE = `Usage: ai task decisions <N | #N | TASK-id> [selector] [options]
+
+Lists the human-decision (HD-) items recorded in a task's review disagreement
+ledger, or prints the full detail block for a single item. Read-only.
+
+  <ref>          Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  [selector]     Ordinal (1-based) or HD id (e.g. 'HD-3') to show one item's detail.
+
+Options:
+  --all              Include already-decided (human-decided) items, not just pending.
+  --stage <s>        Filter to one stage: analysis | plan | code.
+  --format <fmt>     Output format: text (default) | markdown.
+  -h, --help         Show this help.
+
+Aliased as 'ai task d'.
+`;
+
+const STAGES = new Set(['analysis', 'plan', 'code']);
+const FORMATS = new Set(['text', 'markdown']);
+const HD_ID_RE = /^HD-\d+$/;
+
+function fail(message: string): void {
+  process.stderr.write(`ai task decisions: ${message}\n`);
+  process.exitCode = 1;
+}
+
+type ParsedArgs = {
+  positionals: string[];
+  all: boolean;
+  stage?: string;
+  format: string;
+};
+
+// Returns null and sets the exit code when an option is malformed.
+function parseArgs(args: string[]): ParsedArgs | null {
+  const out: ParsedArgs = { positionals: [], all: false, format: 'text' };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i]!;
+    if (a === '--all') {
+      out.all = true;
+    } else if (a === '--stage') {
+      const v = args[i + 1];
+      if (v === undefined) {
+        fail('--stage requires a value (analysis|plan|code)');
+        return null;
+      }
+      out.stage = v;
+      i += 1;
+    } else if (a.startsWith('--stage=')) {
+      out.stage = a.slice('--stage='.length);
+    } else if (a === '--format') {
+      const v = args[i + 1];
+      if (v === undefined) {
+        fail('--format requires a value (text|markdown)');
+        return null;
+      }
+      out.format = v;
+      i += 1;
+    } else if (a.startsWith('--format=')) {
+      out.format = a.slice('--format='.length);
+    } else if (a.startsWith('-')) {
+      fail(`unknown option '${a}'`);
+      return null;
+    } else {
+      out.positionals.push(a);
+    }
+  }
+  return out;
+}
+
+// Parse `<file>.md#anchor` evidence into its filename, when present.
+function evidenceFile(evidence: string): string | null {
+  const m = /([\w.-]+\.md)#/.exec(evidence);
+  return m ? m[1]! : null;
+}
+
+function roundOf(file: string): number {
+  const m = /-r(\d+)\.md$/.exec(file);
+  return m ? Number.parseInt(m[1]!, 10) : 1;
+}
+
+// Locate the `### HD-N` detail block for a row. Prefer the artifact named by the
+// row's evidence anchor; otherwise scan analysis/plan/code artifacts and return
+// the block from the highest-round file that contains it. Returns '' when none
+// is found (caller degrades gracefully — plan B3).
+function findDetailBlock(row: LedgerRow, taskDir: string): string {
+  const hinted = evidenceFile(row.evidence);
+  if (hinted) {
+    const p = path.join(taskDir, hinted);
+    if (fs.existsSync(p)) {
+      const block = extractSubSection(fs.readFileSync(p, 'utf8'), row.id);
+      if (block) return block;
+    }
+  }
+  let best = '';
+  let bestRound = -1;
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(taskDir);
+  } catch {
+    return '';
+  }
+  for (const file of entries) {
+    if (!/^(analysis|plan|code)(-r\d+)?\.md$/.test(file)) continue;
+    const block = extractSubSection(fs.readFileSync(path.join(taskDir, file), 'utf8'), row.id);
+    if (block && roundOf(file) > bestRound) {
+      best = block;
+      bestRound = roundOf(file);
+    }
+  }
+  return best;
+}
+
+// Pull the `## 人工裁决` record lines that mention this HD id, so a decided item
+// shows the human's recorded ruling alongside its detail block.
+function findDecisionRecord(id: string, content: string): string[] {
+  const lines = content.split('\n');
+  let i = 0;
+  while (i < lines.length && !/^##\s+(人工裁决|Human Decisions?)\s*$/.test(lines[i]!)) i += 1;
+  if (i >= lines.length) return [];
+  const idRe = new RegExp(`(^|[^\\w-])${id}(?![\\w-])`);
+  const out: string[] = [];
+  for (let j = i + 1; j < lines.length; j += 1) {
+    if (/^##\s/.test(lines[j]!)) break;
+    if (lines[j]!.trim().startsWith('-') && idRe.test(lines[j]!)) out.push(lines[j]!);
+  }
+  return out;
+}
+
+function titleOf(row: LedgerRow, taskDir: string): string {
+  const block = findDetailBlock(row, taskDir);
+  if (block) {
+    return block
+      .split('\n')[0]!
+      .replace(/^###\s+/, '')
+      .replace(/\s*\[needs-human-decision\]\s*$/, '')
+      .trim();
+  }
+  return row.evidence || '(无详情)';
+}
+
+function renderList(rows: LedgerRow[], format: string, taskDir: string): void {
+  if (rows.length === 0) {
+    process.stdout.write('无待裁决项。\n');
+    return;
+  }
+  const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+  const data = rows.map((r, i) => [
+    String(i + 1),
+    r.id,
+    r.stage,
+    r.severity,
+    r.status,
+    r.evidence,
+    titleOf(r, taskDir)
+  ]);
+  if (format === 'markdown') {
+    const sep = headers.map(() => '---');
+    const md = [
+      `| ${headers.join(' | ')} |`,
+      `| ${sep.join(' | ')} |`,
+      ...data.map((row) => `| ${row.join(' | ')} |`)
+    ];
+    process.stdout.write(`${md.join('\n')}\n`);
+    return;
+  }
+  process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+}
+
+function renderDetail(
+  rows: LedgerRow[],
+  selector: string,
+  format: string,
+  taskDir: string,
+  content: string
+): void {
+  let row: LedgerRow | undefined;
+  if (/^\d+$/.test(selector)) {
+    const idx = Number.parseInt(selector, 10) - 1;
+    if (idx < 0 || idx >= rows.length) {
+      fail(`ordinal '${selector}' out of range (1..${rows.length})`);
+      return;
+    }
+    row = rows[idx];
+  } else {
+    const want = selector.toUpperCase();
+    const matches = rows.filter((r) => r.id.toUpperCase() === want);
+    if (matches.length === 0) {
+      fail(`no decision item matches '${selector}'`);
+      return;
+    }
+    if (matches.length > 1) {
+      fail(`duplicate id '${selector}' in ledger; select by ordinal instead`);
+      return;
+    }
+    row = matches[0];
+  }
+
+  const r = row!;
+  const block = findDetailBlock(r, taskDir);
+  const lines: string[] = [];
+  if (format === 'markdown') {
+    lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+  } else {
+    lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+  }
+  if (block) {
+    lines.push(block);
+  } else {
+    lines.push(
+      `（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`
+    );
+  }
+  if (r.status === 'human-decided') {
+    const record = findDecisionRecord(r.id, content);
+    if (record.length) {
+      lines.push('', '人工裁定：', ...record);
+    }
+  }
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function decisions(args: string[] = []): void {
+  if (args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    return;
+  }
+  const parsed = parseArgs(args);
+  if (!parsed) return;
+  if (parsed.positionals.length === 0) {
+    process.stdout.write(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.stage !== undefined && !STAGES.has(parsed.stage)) {
+    fail(`invalid --stage '${parsed.stage}' (expected analysis|plan|code)`);
+    return;
+  }
+  if (!FORMATS.has(parsed.format)) {
+    fail(`invalid --format '${parsed.format}' (expected text|markdown)`);
+    return;
+  }
+
+  const resolved = resolveTaskRef(parsed.positionals[0]!);
+  if (!resolved.ok) {
+    fail(resolved.message);
+    return;
+  }
+
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  let rows = parseLedger(content).filter((r) => HD_ID_RE.test(r.id));
+  rows = rows.filter((r) =>
+    parsed.all ? HUMAN_DECISION_STATUSES.has(r.status) : r.status === 'needs-human-decision'
+  );
+  if (parsed.stage !== undefined) rows = rows.filter((r) => r.stage === parsed.stage);
+
+  const selector = parsed.positionals[1];
+  if (selector === undefined) {
+    renderList(rows, parsed.format, resolved.taskDir);
+  } else {
+    renderDetail(rows, selector, parsed.format, resolved.taskDir, content);
+  }
+}
+
+export { decisions };

package/lib/task/commands/log.ts

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { formatTable } from '../../table.ts';
 import { resolveTaskRef } from '../resolve-ref.ts';
+import { parseLedger, HUMAN_DECISION_STATUSES, type LedgerRow } from '../ledger.ts';
 
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
@@ -12,7 +13,7 @@ completion time (or '(in progress)' while still running).
 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)
+  the verdict list, right after blockers/major/minor: manual-validation
   and human-decision (current ledger stage total).
 `;
 
@@ -20,7 +21,6 @@ const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'] as const
 
 // 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
@@ -30,7 +30,6 @@ const ENTRY_RE =
 
 type LogEntry = { time: string; step: string; agent: string; note: string };
 type ReviewStage = 'analysis' | 'plan' | 'code';
-type LedgerRow = { stage: string; status: string };
 
 // One rendered row = one step instance. `started`/`done` are timestamps; an empty
 // `done` with a non-empty `started` means the step is still in flight, while an
@@ -47,11 +46,6 @@ const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
 // 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: string; stage: ReviewStage }[] = [
   { prefix: 'Review Analysis', stage: 'analysis' },
   { prefix: 'Review Plan', stage: 'plan' },
@@ -111,27 +105,6 @@ function pairEntries(entries: LogEntry[]): StepRow[] {
   return rows;
 }
 
-function parseReviewLedger(content: string): LedgerRow[] {
-  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: LedgerRow[] = [];
-  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: LedgerRow[]): Map<ReviewStage, number> {
   const counts = new Map<ReviewStage, number>();
   for (const row of rows) {
@@ -149,9 +122,31 @@ function reviewStageForStep(step: string): ReviewStage | undefined {
   return REVIEW_STAGE_PREFIXES.find(({ prefix }) => step.startsWith(prefix))?.stage;
 }
 
+function splitArtifactSuffix(note: string): { verdict: string; suffix: string } {
+  const arrow = note.indexOf(' → ');
+  return arrow === -1 ? { verdict: note, suffix: '' } : { verdict: note.slice(0, arrow), suffix: note.slice(arrow) };
+}
+
+function fieldNumber(field: string, label: string): number | undefined {
+  const trimmed = field.trim();
+  const colon = trimmed.indexOf(':');
+  if (colon === -1) return undefined;
+  if (trimmed.slice(0, colon).trim().toLowerCase() !== label) return undefined;
+  const value = Number(trimmed.slice(colon + 1).trim());
+  return Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+
 function humanValidationCount(note: string): number {
-  const match = ENV_BLOCKED_RE.exec(note);
-  return match ? Number(match[1]) : 0;
+  const { verdict } = splitArtifactSuffix(note);
+  for (const field of verdict.split(',')) {
+    const value = fieldNumber(field, 'manual-validation');
+    if (value !== undefined) return value;
+  }
+  return 0;
+}
+
+function isHumanCountField(field: string): boolean {
+  return fieldNumber(field, 'manual-validation') !== undefined || fieldNumber(field, 'human-decision') !== undefined;
 }
 
 // A step is human-executed when its agent token is not a known AI token. Take
@@ -164,13 +159,17 @@ function isHumanAgent(agent: string): boolean {
 
 // 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: string, decisions: number, envBlocked: number): string {
-  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)}`;
+// the review count line. Review done notes already carry `Manual-validation` as a
+// source field, so build the final verdict field list once instead of cleaning a
+// previously rendered string.
+function foldHumanCounts(note: string, decisions: number, manualValidation: number): string {
+  const { verdict, suffix } = splitArtifactSuffix(note);
+  const fields = verdict
+    .split(',')
+    .map((field) => field.trim())
+    .filter((field) => field !== '' && !isHumanCountField(field));
+  const group = `Manual-validation: ${manualValidation}, Human-decision: ${decisions}`;
+  return `${[...fields, group].join(', ')}${suffix}`;
 }
 
 function log(args: string[] = []): void {
@@ -200,7 +199,7 @@ function log(args: string[] = []): void {
     return;
   }
   const steps = pairEntries(entries);
-  const humanDecisionCounts = countHumanDecisionsByStage(parseReviewLedger(content));
+  const humanDecisionCounts = countHumanDecisionsByStage(parseLedger(content));
   const rows = steps.map((s, idx) => {
     const stage = reviewStageForStep(s.step);
     const note = stage