@fitlab-ai/agent-infra 0.8.0 → 0.8.2

package/lib/sandbox/capture.ts

@@ -22,22 +22,45 @@ export type SandboxCaptureResult = {
   signal: NodeJS.Signals | null;
   stdout: string;
   stderr: string;
+  run?: SandboxRunMetadata;
+};
+
+export type SandboxRunMetadata = {
+  runId: string;
+  engine: string;
+  container: string;
+  runDir: string;
 };
 
 export type SandboxCaptureOptions = {
   engine?: string;
   repoRoot?: string;
+  runId?: string;
   containerCandidates?: string[];
   rows?: SandboxRow[];
   startContainer?: (name: string) => void;
   spawn?: (file: string, args: string[]) => Promise<SandboxCaptureResult>;
 };
 
-async function spawnCapture(file: string, args: string[]): Promise<SandboxCaptureResult> {
+async function spawnCapture(
+  file: string,
+  args: string[]
+): Promise<SandboxCaptureResult> {
   return new Promise((resolve, reject) => {
     const child = spawn(file, args, { stdio: ['ignore', 'pipe', 'pipe'] });
     let stdout = '';
     let stderr = '';
+    let settled = false;
+    const rejectOnce = (error: unknown): void => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+    const resolveOnce = (result: SandboxCaptureResult): void => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
     child.stdout.setEncoding('utf8');
     child.stderr.setEncoding('utf8');
     child.stdout.on('data', (chunk) => {
@@ -46,11 +69,106 @@ async function spawnCapture(file: string, args: string[]): Promise<SandboxCaptur
     child.stderr.on('data', (chunk) => {
       stderr += chunk;
     });
-    child.on('error', reject);
-    child.on('close', (exitCode, signal) => resolve({ exitCode, signal, stdout, stderr }));
+    child.on('error', rejectOnce);
+    child.on('close', (exitCode, signal) => {
+      resolveOnce({ exitCode, signal, stdout, stderr });
+    });
   });
 }
 
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+export function createRunId(date: Date = new Date()): string {
+  return `run-${date.toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[-:]/g, '').replace('T', '-').replace('Z', '')}-${process.pid}`;
+}
+
+function buildRunScript(params: {
+  command: string[];
+  runDir: string;
+  runId: string;
+}): string {
+  const command = params.command.map(shellQuote).join(' ');
+  const runDir = shellQuote(params.runDir);
+  const runId = shellQuote(params.runId);
+  return `#!/bin/sh
+set -u
+cd /workspace
+date "+%Y-%m-%d %H:%M:%S%:z" > ${runDir}/started_at
+printf '%s\\n' running > ${runDir}/status
+${command}
+code=$?
+printf '%s\\n' "$code" > ${runDir}/exit_code
+date "+%Y-%m-%d %H:%M:%S%:z" > ${runDir}/finished_at
+if [ "$code" -eq 0 ]; then
+  printf '%s\\n' completed > ${runDir}/status
+else
+  printf '%s\\n' failed > ${runDir}/status
+fi
+printf '\\n[agent-infra] run %s finished with exit code %s\\n' ${runId} "$code"
+exec bash -l
+`;
+}
+
+function buildTmuxLauncher(params: {
+  request: SandboxCaptureRequest;
+  runId: string;
+}): string {
+  const session = 'work';
+  const window = `ai-${params.runId.replace(/^run-/, '').slice(0, 18)}`;
+  const runRoot = '/tmp/agent-infra-runs';
+  const runDir = `${runRoot}/${params.runId}`;
+  const runScript = buildRunScript({ command: params.request.command, runDir, runId: params.runId });
+  const runScriptBase64 = Buffer.from(runScript, 'utf8').toString('base64');
+  const paneCommand = `cd /workspace && ${shellQuote(`${runDir}/run.sh`)}`;
+
+  return `set -eu
+session=${shellQuote(session)}
+window=${shellQuote(window)}
+run_id=${shellQuote(params.runId)}
+run_dir=${shellQuote(runDir)}
+task_ref=${shellQuote(params.request.taskRef)}
+branch=${shellQuote(params.request.branch)}
+
+sandbox-dotfiles-link >/dev/null 2>&1 || true
+mkdir -p "$run_dir"
+printf '%s\\n' pending > "$run_dir/status"
+printf '%s\\n' "$task_ref" > "$run_dir/task_ref"
+printf '%s\\n' "$branch" > "$run_dir/branch"
+printf '%s\\n' ${shellQuote(params.request.command.join(' '))} > "$run_dir/command"
+printf '%s' ${shellQuote(runScriptBase64)} | base64 -d > "$run_dir/run.sh"
+chmod +x "$run_dir/run.sh"
+
+if ! command -v tmux >/dev/null 2>&1; then
+  printf '%s\\n' "tmux is not installed in this sandbox" >&2
+  exit 127
+fi
+
+if ! tmux has-session -t "$session" 2>/dev/null; then
+  tmux new-session -d -s "$session" -n shell
+fi
+
+if [ -n "\${TZ:-}" ]; then
+  tmux set-environment -t "$session" TZ "$TZ" 2>/dev/null || true
+fi
+
+pane=$(tmux new-window -d -P -F '#{pane_id}' -t "$session" -n "$window")
+printf '%s\\n' "$session" > "$run_dir/session"
+printf '%s\\n' "$window" > "$run_dir/window"
+printf '%s\\n' "$pane" > "$run_dir/pane"
+tmux pipe-pane -o -t "$pane" "cat > $run_dir/output.log"
+tmux send-keys -t "$pane" ${shellQuote(paneCommand)} Enter
+
+cat <<EOF
+Started sandbox run $run_id in tmux session '$session', window '$window', pane '$pane'.
+Attach with: ai sandbox enter $task_ref
+Status file: $run_dir/status
+Output log: $run_dir/output.log
+EOF
+`;
+}
+
 export async function runInSandbox(
   request: SandboxCaptureRequest,
   options: SandboxCaptureOptions = {}
@@ -73,12 +191,25 @@ export async function runInSandbox(
   if (!found.running) {
     (options.startContainer ?? ((name: string) => startSandboxContainer(engine, name)))(found.name);
   }
+  const runId = options.runId ?? createRunId();
+  const runDir = `/tmp/agent-infra-runs/${runId}`;
   const dockerArgs = [
     'exec',
     ...terminalEnvFlags(),
     ...hostTimezoneEnvFlags(),
     found.name,
-    ...request.command
+    'bash',
+    '-lc',
+    buildTmuxLauncher({ request, runId })
   ];
-  return (options.spawn ?? spawnCapture)('docker', dockerArgs);
+  const result = await (options.spawn ?? spawnCapture)('docker', dockerArgs);
+  return {
+    ...result,
+    run: {
+      runId,
+      engine,
+      container: found.name,
+      runDir
+    }
+  };
 }

package/lib/sandbox/commands/create.ts

@@ -915,6 +915,42 @@ function resolveHostCatalogPath(value: unknown, hostHomeDir: string): string | n
   }
 }
 
+const CODEX_DISABLED_FEATURE_FLAGS = ['apps', 'enable_mcp_apps'] as const;
+
+function removeCodexMcpServers(sandboxParsed: JsonObject): boolean {
+  if (!Object.hasOwn(sandboxParsed, 'mcp_servers')) {
+    return false;
+  }
+  delete sandboxParsed.mcp_servers;
+  return true;
+}
+
+function inheritDisabledCodexFeatureFlags(sandboxParsed: JsonObject, hostParsed: JsonObject): boolean {
+  if (!isJsonObjectRecord(hostParsed.features)) {
+    return false;
+  }
+  if (Object.hasOwn(sandboxParsed, 'features') && !isJsonObjectRecord(sandboxParsed.features)) {
+    return false;
+  }
+
+  let sandboxFeatures = sandboxParsed.features as JsonObject | undefined;
+  let changed = false;
+  for (const key of CODEX_DISABLED_FEATURE_FLAGS) {
+    if (hostParsed.features[key] !== false) {
+      continue;
+    }
+    if (!sandboxFeatures) {
+      sandboxFeatures = {};
+      sandboxParsed.features = sandboxFeatures;
+    }
+    if (sandboxFeatures[key] !== false) {
+      sandboxFeatures[key] = false;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
 export function ensureCodexModelInheritance(
   toolDir: string,
   hostHomeDir?: string,
@@ -947,13 +983,15 @@ export function ensureCodexModelInheritance(
     }
   }
 
+  let changed = removeCodexMcpServers(sandboxParsed);
+  changed = inheritDisabledCodexFeatureFlags(sandboxParsed, hostParsed) || changed;
+
   const inheritSpecs: Array<readonly [string, 'string' | 'number']> = [
     ['model', 'string'],
     ['model_reasoning_effort', 'string'],
     ['model_auto_compact_token_limit', 'number']
   ];
 
-  let changed = false;
   for (const [key, type] of inheritSpecs) {
     if (Object.hasOwn(sandboxParsed, key)) {
       continue;
@@ -1438,9 +1476,9 @@ export async function create(args: string[]): Promise<void> {
             if (claudeCodeEntry) {
               ensureClaudeOnboarding(claudeCodeEntry.dir, effectiveConfig.home);
               ensureClaudeSettings(claudeCodeEntry.dir, effectiveConfig.home);
-              // prepareClaudeCredentials wrote the shared credentials file
-              // before this point. If credentials were missing, the
-              // claude-code entry was removed from effectiveResolvedTools.
+              // prepareClaudeCredentials wrote OAuth credentials or confirmed
+              // provider/API settings are enough for Claude Code. If no usable
+              // auth was present, the claude-code entry was removed above.
             }
             const codexEntry = effectiveResolvedTools.find(({ tool }) => tool.id === 'codex');
             if (codexEntry) {

package/lib/sandbox/commands/enter.ts

@@ -9,6 +9,7 @@ import { detectEngine } from '../engine.ts';
 import {
   formatCredentialWarnings,
   formatRemaining,
+  hasClaudeProviderAuth,
   reconcileClaudeCredentials,
   redactCommandError,
   validateClaudeCredentialsEnvOverride
@@ -93,8 +94,12 @@ export function runSandboxInteractive(params: {
 
 export function formatCredentialSyncStatus(
   result: ReturnType<typeof reconcileClaudeCredentials>,
-  isTTY = process.stderr.isTTY
+  isTTY = process.stderr.isTTY,
+  providerAuthAvailable = false
 ): string | null {
+  if (providerAuthAvailable && (result.status === 'STALE_ACCESS' || result.status === 'MISSING')) {
+    return null;
+  }
   if (result.status === 'STALE_ACCESS') {
     return 'Warning: Claude Code credentials on host appear stale. Run "ai sandbox refresh" or "claude /login" to renew.\n';
   }
@@ -158,8 +163,9 @@ export async function enter(args: string[]): Promise<number> {
   if (config.tools.includes('claude-code')) {
     try {
       // Scan all projects so a refresh from a neighbouring sandbox can still flow back to the host.
+      const providerAuthAvailable = hasClaudeProviderAuth(config.home);
       const result = reconcileClaudeCredentials(config.home);
-      const message = formatCredentialSyncStatus(result);
+      const message = formatCredentialSyncStatus(result, process.stderr.isTTY, providerAuthAvailable);
       if (message) {
         process.stderr.write(message);
       }

package/lib/sandbox/config.ts

@@ -12,7 +12,7 @@ import type { SandboxTool } from './tools.ts';
 const DEFAULTS = Object.freeze({
   engine: null,
   runtimes: ['node22'],
-  tools: ['claude-code', 'codex', 'gemini-cli', 'opencode'],
+  tools: ['agent-infra', 'claude-code', 'codex', 'gemini-cli', 'opencode'],
   dockerfile: null,
   vm: {
     cpu: null,

package/lib/sandbox/credentials.ts

@@ -55,6 +55,11 @@ type InspectOptions = {
   envFn?: EnvFn;
 };
 
+type ProviderAuthOptions = {
+  readFn?: ReadFn;
+  existsFn?: ExistsFn;
+};
+
 type WriteHostOptions = {
   execFn?: ExecFn;
   mkdirFn?: typeof fs.mkdirSync;
@@ -114,6 +119,14 @@ const REDACTION_PATTERNS = [
   { pattern: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/gi, replacement: 'Bearer [REDACTED]' }
 ];
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function hasNonEmptyString(value: unknown): boolean {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : 'unknown error';
 }
@@ -219,6 +232,35 @@ export function validateClaudeCredentialsEnvOverride(env: NodeJS.ProcessEnv = pr
   }
 }
 
+export function hasClaudeProviderAuthInSettings(settings: unknown): boolean {
+  if (!isRecord(settings)) {
+    return false;
+  }
+
+  const env = isRecord(settings.env) ? settings.env : {};
+  return hasNonEmptyString(env.ANTHROPIC_AUTH_TOKEN)
+    || hasNonEmptyString(env.ANTHROPIC_API_KEY)
+    || hasNonEmptyString(settings.apiKeyHelper);
+}
+
+export function hasClaudeProviderAuth(home: string, options: ProviderAuthOptions = {}): boolean {
+  const {
+    readFn = (targetPath) => fs.readFileSync(targetPath, 'utf8'),
+    existsFn = fs.existsSync
+  } = options;
+  const settingsPath = path.join(home, '.claude', 'settings.json');
+
+  if (!existsFn(settingsPath)) {
+    return false;
+  }
+
+  try {
+    return hasClaudeProviderAuthInSettings(JSON.parse(readFn(settingsPath)));
+  } catch {
+    return false;
+  }
+}
+
 // Reconcile treats the freshest valid endpoint as authoritative so sandbox
 // token rotations can flow back to the host credential store.
 function validateClaudeCredentialsBlob(raw: unknown, blob: string | null = null): CredentialInspection {
@@ -595,13 +637,22 @@ export function prepareClaudeCredentials(
   resolvedTools: ResolvedTool[],
   extractFn: (home: string) => string | null = extractClaudeCredentialsBlob,
   writeFn: (home: string, project: string, blob: string) => void = writeClaudeCredentialsFile,
-  inspectFn: (home: string) => CredentialInspection = inspectClaudeKeychainStatus
+  inspectFn: (home: string) => CredentialInspection = inspectClaudeKeychainStatus,
+  providerAuthFn: (home: string) => boolean = hasClaudeProviderAuth
 ): ClaudeCredentialOutcome {
   const claudeCodeEntry = resolvedTools.find(({ tool }) => tool.id === 'claude-code');
   if (!claudeCodeEntry) {
     return { status: 'NOT_APPLICABLE' };
   }
 
+  const providerAuthAvailable = () => {
+    try {
+      return providerAuthFn(home);
+    } catch {
+      return false;
+    }
+  };
+
   let blob: string | null = null;
   const hasCustomInspectFn = inspectFn !== inspectClaudeKeychainStatus;
   const hasCustomExtractFn = extractFn !== extractClaudeCredentialsBlob;
@@ -612,7 +663,7 @@ export function prepareClaudeCredentials(
         blob = inspection.blob;
         break;
       case 'MISSING':
-        return { status: 'SKIPPED' };
+        return providerAuthAvailable() ? { status: 'OK' } : { status: 'SKIPPED' };
       case 'KEYCHAIN_LOCKED':
         throw new Error([
           'Claude Code credentials are stored in the macOS keychain, but the keychain is locked.',
@@ -620,6 +671,9 @@ export function prepareClaudeCredentials(
           buildLockedGuidance()
         ].join('\n'));
       case 'STALE_ACCESS':
+        if (providerAuthAvailable()) {
+          return { status: 'OK' };
+        }
         throw new Error([
           'Claude Code credentials on host are invalid or expired.',
           '',
@@ -648,7 +702,7 @@ export function prepareClaudeCredentials(
   } else {
     blob = extractFn(home);
     if (!blob) {
-      return { status: 'SKIPPED' };
+      return providerAuthAvailable() ? { status: 'OK' } : { status: 'SKIPPED' };
     }
   }
 

package/lib/sandbox/runtimes/base.dockerfile

@@ -61,6 +61,19 @@ RUN cat > /usr/local/bin/cc-token-status <<'SCRIPT' && chmod +x /usr/local/bin/c
 #!/bin/sh
 set -eu
 
+SETTINGS_FILE="/home/devuser/.claude/settings.json"
+if [ -r "$SETTINGS_FILE" ] && jq -e '
+  def has_nonempty($v):
+    if ($v | type) == "string" then ($v | gsub("^\\s+|\\s+$"; "") | length) > 0 else false end;
+  (if type == "object" then . else {} end) as $settings
+  | (if ($settings.env | type) == "object" then $settings.env else {} end) as $env
+  | has_nonempty($env.ANTHROPIC_AUTH_TOKEN)
+    or has_nonempty($env.ANTHROPIC_API_KEY)
+    or has_nonempty($settings.apiKeyHelper)
+' "$SETTINGS_FILE" >/dev/null 2>&1; then
+  exit 0
+fi
+
 CRED_FILE="/home/devuser/.claude/.credentials.json"
 [ -r "$CRED_FILE" ] || exit 0
 

package/lib/sandbox/runtimes/node20.dockerfile

@@ -1,3 +1,3 @@
-RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
+RUN 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,3 @@
-RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+RUN 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/tools.ts

@@ -124,6 +124,15 @@ function createBuiltinTools(home: string, project: string): Record<string, Sandb
         { 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.'
     }
   };
 }

package/lib/server/adapters/feishu/index.ts

@@ -1,5 +1,5 @@
 import type { Adapter, AdapterCtx, AdapterFactory, InboundMessage } from '../_contract.ts';
-import { createFeishuTransport, normalizeMessage } from './transport.ts';
+import { cardMessage, createFeishuTransport, normalizeMessage } from './transport.ts';
 import type { FeishuTransport } from './transport.ts';
 
 // Assemble the feishu adapter. The transport is injectable so unit tests can
@@ -25,7 +25,9 @@ export function createFeishuAdapter(
             text: normalized.text,
             messageId: normalized.messageId,
             raw: normalized.raw,
-            reply: (text) => transport.send(normalized.chatId, text)
+            reply: async (text) => {
+              await transport.send(normalized.chatId, cardMessage(text));
+            }
           };
           await adapterCtx.dispatch(message);
         } catch (error) {
@@ -37,7 +39,7 @@ export function createFeishuAdapter(
       await transport.stop();
     },
     async sendMessage(target, text) {
-      await transport.send(target.chatId, text);
+      await transport.send(target.chatId, cardMessage(text));
     }
   };
 }

package/lib/server/adapters/feishu/transport.ts

@@ -1,4 +1,5 @@
 import * as lark from '@larksuiteoapi/node-sdk';
+import { stripVTControlCharacters } from 'node:util';
 
 // Transport layer for the feishu adapter. All @larksuiteoapi/node-sdk surface is
 // confined here so the adapter body (index.ts) depends only on this narrow
@@ -10,7 +11,15 @@ export type FeishuTransport = {
   // each inbound im.message.receive_v1.
   start: (onMessage: (raw: unknown) => Promise<void>) => Promise<void>;
   stop: () => Promise<void>;
-  send: (chatId: string, text: string) => Promise<void>;
+  send: (chatId: string, message: FeishuOutgoingMessage) => Promise<void>;
+};
+
+export type FeishuOutgoingMessage = { kind: 'interactive'; title: string; text: string };
+
+type FeishuCreateData = {
+  receive_id: string;
+  msg_type: 'interactive';
+  content: string;
 };
 
 export type NormalizedMessage = {
@@ -69,6 +78,26 @@ function resolveDomain(value: unknown): number {
   return value === 'lark' || value === 'Lark' ? lark.Domain.Lark : lark.Domain.Feishu;
 }
 
+export function cleanFeishuText(text: string): string {
+  return stripVTControlCharacters(text).replace(/\r\n/g, '\n');
+}
+
+export function cardMessage(text: string): FeishuOutgoingMessage {
+  return { kind: 'interactive', title: 'agent-infra', text: cleanFeishuText(text) };
+}
+
+export function toFeishuCreateData(chatId: string, message: FeishuOutgoingMessage): FeishuCreateData {
+  return {
+    receive_id: chatId,
+    msg_type: 'interactive',
+    content: JSON.stringify({
+      config: { wide_screen_mode: true },
+      header: { title: { tag: 'plain_text', content: message.title }, template: 'blue' },
+      elements: [{ tag: 'div', text: { tag: 'lark_md', content: message.text } }]
+    })
+  };
+}
+
 // Build the real SDK-backed transport from adapter config. appId/appSecret come
 // from server config (appSecret only via server.local.json / env). The WSClient
 // long connection delivers events; the Client REST call sends replies.
@@ -118,10 +147,10 @@ export function createFeishuTransport(config: Record<string, unknown>): FeishuTr
         // Ignore: the daemon is shutting down regardless.
       }
     },
-    async send(chatId, text) {
+    async send(chatId, message) {
       await client.im.message.create({
         params: { receive_id_type: 'chat_id' },
-        data: { receive_id: chatId, msg_type: 'text', content: JSON.stringify({ text }) }
+        data: toFeishuCreateData(chatId, message)
       });
     }
   };

package/lib/server/protocol.ts

@@ -23,10 +23,26 @@ function taskSubcommand(subcommand: string): string {
 export function commandHelp(): string {
   return [
     `agent-infra ${VERSION}`,
-    'Built-ins: /help, /ping, /version',
-    'Read: /sandbox ls|show|vm status, /task decisions|log|ls|show|status',
-    'Write: /sandbox create|start',
-    'Exec: /decide <task-ref> <HD-id> <decision>, /run create-task <description>, /run <skill> <task-ref> ...'
+    'Built-ins:',
+    '/help',
+    '/ping',
+    '/version',
+    'Read:',
+    '/sandbox ls',
+    '/sandbox show {ref}',
+    '/sandbox vm status',
+    '/task decisions {ref}',
+    '/task log {ref}',
+    '/task ls',
+    '/task show {ref}',
+    '/task status {ref}',
+    'Write:',
+    '/sandbox create {ref}',
+    '/sandbox start {ref}',
+    'Exec:',
+    '/decide {task-ref} {HD-id} {decision}',
+    '/run create-task {description}',
+    '/run {skill} {task-ref}'
   ].join('\n');
 }
 

package/lib/task/commands/log.ts

@@ -13,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).
 `;
 
@@ -46,10 +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 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' },
@@ -126,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
@@ -141,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 {