@kylecheng3146/agent-ops 0.3.7 → 0.4.1

package/README.md

@@ -345,6 +345,41 @@ agent-ops doctor              # presence only: no tokens, no network
 agent-ops doctor --check-auth # one real print call per configured target
 ```
 
+### Batch review
+
+A change split into subtasks needs one verify and one review per subtask.
+`agent-ops batch --parent <task-id> --yes` runs them together for the parent's
+active subtasks and the parent itself, instead of one `review` at a time:
+
+```bash
+agent-ops batch --parent <task-id> --yes --output batch.json
+agent-ops batch --parent <task-id> --yes --base <ref> --parent-base <ref> --width 3
+```
+
+- Each task is verified and reviewed against its own base: `--base` for the
+  subtasks and `--parent-base` for the parent, otherwise the base recorded by
+  its last PASS review, otherwise the worktree base.
+- A task that already has fresh PASS verification evidence skips verify. The
+  rest are verified one at a time, and each task's review starts as soon as its
+  own verify passes, so the next verify overlaps it. A task whose verify fails
+  gets no review; the others continue.
+- At most `--width` reviews run at once (default 2). A transient `NOT_RUN`
+  (`probe-failed`, `stalled`, `timeout`, `quota-exhausted`,
+  `network-unreachable`) lowers the width to 1 for the rest and earns that task
+  one retry, alone, after the others finish. Other results are final.
+- Each review target is probed once per batch while the probe succeeds; a
+  failed probe is forgotten so the retry probes again.
+- Nothing may commit or edit the worktree while it runs. HEAD is part of every
+  fingerprint, so a change aborts the batch and reports the unfinished tasks
+  as `aborted`.
+- Exit code 0 means every task passed, 1 means a review or verify failed, and 2
+  means the rest could not run and may be retried. The JSON envelope lists each
+  task; the full reports stay under `.agent-ops/reviews/`.
+
+`batch` is started exactly like `review`: through the trusted outer host runner
+as its first and only invocation, with `--output` instead of a shell redirect.
+`agent-ops init` and `update` pre-authorize it beside `review`.
+
 See [Configuration](docs/en/guides/configuration.md) for the full contract.
 
 ## Project principles

package/dist/packages/cli/src/args.js

@@ -9,6 +9,7 @@ export const COMMAND_NAMES = [
     "task",
     "verify",
     "review",
+    "batch",
     "allow-stop",
     "worktree"
 ];
@@ -17,7 +18,7 @@ const SCOPES = new Set(["project", "user"]);
 const PROFILES = new Set(["advisory", "core", "guardrails", "loop"]);
 // opencode is absent: it has no read-only flag, so it cannot review.
 const REVIEW_TARGETS = new Set(["agy", "claude", "codex"]);
-export const WORKTREE_ACTIONS = ["add", "finish", "list", "resume", "remove"];
+export const WORKTREE_ACTIONS = ["add", "commit", "finish", "list", "resume", "remove"];
 export class CliArgumentError extends Error {
     code;
     option;
@@ -71,6 +72,8 @@ export function parseArgs(argv) {
     let title;
     let sessionId;
     let base;
+    let parentBase;
+    let width;
     const profiles = [];
     const reviewTargets = [];
     const criteria = [];
@@ -87,6 +90,8 @@ export function parseArgs(argv) {
     let worktreeName;
     let force = false;
     let worktreeFrom;
+    let worktreeMessage;
+    let output;
     let worktreeTargetBranch;
     let worktree;
     for (let index = 0; index < argv.length; index += 1) {
@@ -208,6 +213,26 @@ export function parseArgs(argv) {
                 index += 1;
                 break;
             }
+            case "--parent-base": {
+                if (parentBase !== undefined) {
+                    duplicate(token);
+                }
+                parentBase = readOptionValue(argv, index, token);
+                index += 1;
+                break;
+            }
+            case "--width": {
+                if (width !== undefined) {
+                    duplicate(token);
+                }
+                const value = readOptionValue(argv, index, token);
+                if (!/^[1-9][0-9]{0,2}$/u.test(value)) {
+                    invalidValue(token, value);
+                }
+                width = Number(value);
+                index += 1;
+                break;
+            }
             case "--check-auth":
                 if (checkAuth) {
                     duplicate(token);
@@ -276,6 +301,23 @@ export function parseArgs(argv) {
                 index += 1;
                 break;
             }
+            case "-m":
+            case "--message": {
+                if (worktreeMessage !== undefined) {
+                    duplicate(token);
+                }
+                worktreeMessage = readOptionValue(argv, index, token);
+                index += 1;
+                break;
+            }
+            case "--output": {
+                if (output !== undefined) {
+                    duplicate(token);
+                }
+                output = readOptionValue(argv, index, token);
+                index += 1;
+                break;
+            }
             case "--target-branch": {
                 if (worktreeTargetBranch !== undefined) {
                     duplicate(token);
@@ -339,7 +381,11 @@ export function parseArgs(argv) {
                     action = token;
                     break;
                 }
-                if (command === "worktree" && action !== undefined && action !== "list" && worktreeName === undefined) {
+                if (command === "worktree" &&
+                    action !== undefined &&
+                    action !== "list" &&
+                    action !== "commit" &&
+                    worktreeName === undefined) {
                     worktreeName = token;
                     break;
                 }
@@ -393,6 +439,8 @@ export function parseArgs(argv) {
             completionGate !== undefined ||
             sessionId !== undefined ||
             base !== undefined ||
+            parentBase !== undefined ||
+            width !== undefined ||
             checkAuth ||
             checkAuthTargets.length > 0 ||
             dryRun ||
@@ -400,6 +448,8 @@ export function parseArgs(argv) {
             rerun ||
             worktree !== undefined ||
             worktreeFrom !== undefined ||
+            worktreeMessage !== undefined ||
+            output !== undefined ||
             worktreeTargetBranch !== undefined ||
             force) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Only --json may be combined with global help or version.");
@@ -415,9 +465,15 @@ export function parseArgs(argv) {
     if (command === "worktree" && action === undefined) {
         throw new CliArgumentError("CLI_ACTION_REQUIRED", `The worktree command requires one of: ${WORKTREE_ACTIONS.join(", ")}.`);
     }
-    if (command === "worktree" && action !== "list" && worktreeName === undefined) {
+    if (command === "worktree" && action !== "list" && action !== "commit" && worktreeName === undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", `worktree ${action} requires a worktree name.`);
     }
+    if (command === "worktree" && action === "commit" && (worktreeMessage === undefined || worktreeMessage.trim() === "")) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "worktree commit requires --message (-m).", "--message");
+    }
+    if (worktreeMessage !== undefined && !(command === "worktree" && action === "commit")) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--message may be used only with worktree commit.", "--message");
+    }
     if (command === "task" && action === undefined) {
         throw new CliArgumentError("CLI_ACTION_REQUIRED", "The task command requires one of: create, status, attach, complete, archive, export.");
     }
@@ -434,15 +490,18 @@ export function parseArgs(argv) {
         (hasTaskTargetOptions || hasTaskMutationOptions)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Task target options may be used only with task or verify.");
     }
-    if (command !== "task" && parentTaskId !== undefined) {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--parent may be used only with task create or task status.");
+    if (command !== "task" && command !== "batch" && parentTaskId !== undefined) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--parent may be used only with task create, task status or batch.");
     }
     if (command !== "update" && targetVersion !== undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--target-version may be used only with update.");
     }
     if (base !== undefined && command !== "verify" && command !== "review" &&
-        !(command === "task" && action === "complete")) {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--base may be used only with verify, review or task complete.");
+        command !== "batch" && !(command === "task" && action === "complete")) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--base may be used only with verify, review, batch or task complete.");
+    }
+    if ((parentBase !== undefined || width !== undefined) && command !== "batch") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", `${parentBase !== undefined ? "--parent-base" : "--width"} may be used only with batch.`);
     }
     if (hookTargets.length > 0 &&
         command !== "init" &&
@@ -535,6 +594,16 @@ export function parseArgs(argv) {
     if (command === "review" && (criteria.length > 0 || evidence.length > 0)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Complete review covers every task criterion; omit --criterion and --evidence.");
     }
+    if (command === "batch" && parentTaskId === undefined) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Batch requires --parent to name the task whose subtasks it covers.");
+    }
+    if (command === "batch" && !yes) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Batch requires --yes to authorize the reviewer sessions.");
+    }
+    if (command === "batch" &&
+        (harness !== undefined || profiles.length > 0 || dryRun || rerun)) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Batch accepts parent, base, parent-base, width, json, output and yes options.");
+    }
     if (command === "allow-stop" &&
         (sessionId === undefined ||
             scope !== undefined ||
@@ -556,7 +625,13 @@ export function parseArgs(argv) {
             dryRun ||
             yes ||
             rerun)) {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "worktree accepts only a name, --session, --from, --target-branch and --json.");
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "worktree accepts only a name, --session, --from, --target-branch, --message and --json.");
+    }
+    if (output !== undefined && command !== "review" && command !== "batch" && command !== "doctor") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--output may be used only with review, batch or doctor.", "--output");
+    }
+    if (output !== undefined && (output.trim() === "" || output.includes("\0"))) {
+        throw new CliArgumentError("CLI_INVALID_VALUE", "Invalid value for --output.", "--output");
     }
     if (force && !(command === "worktree" && action === "remove")) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--force may be used only with worktree remove.");
@@ -572,7 +647,12 @@ export function parseArgs(argv) {
         !/^[A-Za-z0-9._/-]{1,128}$/u.test(worktreeTargetBranch)) {
         throw new CliArgumentError("CLI_INVALID_VALUE", `Invalid value for --target-branch: ${worktreeTargetBranch}`, "--target-branch");
     }
-    if (command === "worktree" && action !== "add" && action !== "resume" && sessionId !== undefined) {
+    // commit acts as a session (it refuses another's worktree), so it may be told which.
+    if (command === "worktree" &&
+        action !== "add" &&
+        action !== "resume" &&
+        action !== "commit" &&
+        sessionId !== undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", `worktree ${action} takes the session from the worktree; omit --session.`);
     }
     return {
@@ -594,7 +674,11 @@ export function parseArgs(argv) {
         ...(evidence.length === 0 ? {} : { evidence }),
         ...(sessionId === undefined ? {} : { sessionId }),
         ...(base === undefined ? {} : { base }),
+        ...(parentBase === undefined ? {} : { parentBase }),
+        ...(width === undefined ? {} : { width }),
         ...(worktreeFrom === undefined ? {} : { worktreeFrom }),
+        ...(worktreeMessage === undefined ? {} : { worktreeMessage }),
+        ...(output === undefined ? {} : { output }),
         ...(worktreeTargetBranch === undefined ? {} : { worktreeTargetBranch }),
         ...(checkAuth ? { checkAuth } : {}),
         ...(checkAuthTargets.length === 0 ? {} : { checkAuthTargets }),

package/dist/packages/cli/src/bin.js

@@ -6,9 +6,10 @@ import { join } from "node:path";
 import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { commonHarnessAdapters, harnessHookPath, HARNESS_IDS } from "../../../runtime/src/install/harness.js";
-import { agyRuntimeStatus, agyVersionSupported, hookRegistrationDrift, repositoryTrustStatus, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
+import { agyRuntimeStatus, agyVersionSupported, hookRegistrationDrift, repositoryTrustProbe, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
 import { parseInstallManifest } from "../../../runtime/src/fs/manifest.js";
-import { readRecordedSessionId } from "../../../runtime/src/hooks/codex-loop.js";
+import { readRecordedSessionId, resolveCommandSessionId, sessionIdFromEnvironment } from "../../../runtime/src/hooks/codex-loop.js";
+import { codexHomeDirectory } from "../../../runtime/src/install/preauth.js";
 import { NpmRegistryClient } from "../../../runtime/src/registry/npm.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
@@ -17,6 +18,7 @@ import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
 import { calculateSourceFingerprint } from "../../../runtime/src/verify/source-fingerprint.js";
 import { VerificationService } from "../../../runtime/src/verify/service.js";
 import { NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn.js";
+import { COMMAND_NAMES, parseArgs } from "./args.js";
 import { runCli } from "./cli.js";
 import { loadEffectiveConfig, repositoryTrust, repositoryTrustBinding } from "./context.js";
 import { runHookProcess } from "./hook-process.js";
@@ -29,9 +31,12 @@ import { runDoctorCommand } from "./commands/doctor.js";
 import { formatInstallPlan, runInitCommand } from "./commands/init.js";
 import { formatUninstallPlan, runUninstallCommand } from "./commands/uninstall.js";
 import { runTaskCommand } from "./commands/task.js";
-import { runReviewCommand } from "./commands/review.js";
+import { hasFreshVerification, runReviewCommand } from "./commands/review.js";
+import { runBatchCommand } from "./commands/batch.js";
+import { createSourceGuard } from "../../../runtime/src/review/batch-guard.js";
+import { memoizePreflight } from "../../../runtime/src/review/batch.js";
 import { createReviewExecutor, ReviewInterruptedError } from "../../../runtime/src/review/execute.js";
-import { probeReviewTarget } from "../../../runtime/src/review/probe.js";
+import { probeReviewTargetDetailed } from "../../../runtime/src/review/probe.js";
 import { resolveReviewScope } from "../../../runtime/src/review/scope.js";
 import { resolveReviewRole } from "../../../runtime/src/review/roles.js";
 import { runTrustCommand } from "./commands/trust.js";
@@ -42,7 +47,7 @@ import { formatUpdatePlan, runUpdateCommand } from "./commands/update.js";
 import { errorEnvelope } from "./output.js";
 import { runAgyHeadless } from "./agy-headless.js";
 import { runWorktreeCommand } from "./commands/parallel.js";
-import { ensureSessionWorktree, resolveCheckouts } from "../../../runtime/src/parallel/service.js";
+import { ensureSessionWorktree, readWorktreeRecord, resolveCheckouts } from "../../../runtime/src/parallel/service.js";
 import { listWorktrees, branchLockDoctorResult, worktreeDoctorResult } from "../../../runtime/src/parallel/manage.js";
 import { detectGhostFiles, ghostFilesDoctorResult } from "../../../runtime/src/install/doctor.js";
 const HOOK_RUNTIME_PATH = fileURLToPath(new URL("./hook-entry.js", import.meta.url));
@@ -206,19 +211,10 @@ else {
         writeStderr: (value) => process.stderr.write(value)
     }, {
         version: CLI_VERSION,
-        registry: createCommandRegistry(Object.fromEntries([
-            "init",
-            "config",
-            "trust",
-            "doctor",
-            "update",
-            "uninstall",
-            "task",
-            "verify",
-            "review",
-            "allow-stop",
-            "worktree"
-        ].map((command) => [command, async (args) => {
+        registry: createCommandRegistry(Object.fromEntries(
+        // Every command the parser knows is registered: a hand-kept list here
+        // once left a parsed command answering CLI_COMMAND_UNAVAILABLE.
+        COMMAND_NAMES.map((command) => [command, async (args) => {
                 const root = args.scope === "user"
                     ? process.env.AGENT_OPS_HOME ?? homedir()
                     : process.cwd();
@@ -234,6 +230,7 @@ else {
                         isTTY,
                         toolkitVersion: CLI_VERSION,
                         hookRuntimePath: HOOK_RUNTIME_PATH,
+                        codexHome: codexHomeDirectory(),
                         agyWarning: () => {
                             try {
                                 const output = runAgy(["--version"], { timeout: 5_000 });
@@ -304,34 +301,7 @@ else {
                                     };
                             },
                             repositoryTrust: async () => {
-                                const trust = await repositoryTrust(root, config, CLI_VERSION);
-                                const status = repositoryTrustStatus(trust);
-                                if (trust === "STALE") {
-                                    return {
-                                        status,
-                                        message: "Repository trust binding is stale.",
-                                        code: "TRUST_REQUIRED",
-                                        remediation: "Run `agent-ops trust grant`."
-                                    };
-                                }
-                                if (trust === "UNTRUSTED") {
-                                    const verificationConfigured = config.verification.commands.length > 0;
-                                    return {
-                                        status,
-                                        message: verificationConfigured
-                                            ? "Repository is not trusted; Stop verification will not run."
-                                            : "Repository is not trusted.",
-                                        ...(verificationConfigured
-                                            ? {
-                                                code: "TRUST_REQUIRED",
-                                                remediation: "Run `agent-ops trust grant`."
-                                            }
-                                            : {
-                                                remediation: "No action needed; trust is only required once verification.commands is set."
-                                            })
-                                    };
-                                }
-                                return { status };
+                                return repositoryTrustProbe(await repositoryTrust(root, config, CLI_VERSION), config.verification.commands.length > 0);
                             },
                             smokeAvailability: () => {
                                 const status = smokeAvailabilityStatus(config);
@@ -343,7 +313,7 @@ else {
                                     }
                                     : { status };
                             },
-                            reviewTarget: async (target, deep) => await probeReviewTarget(target, { cwd: root, deep }),
+                            reviewTarget: async (target, deep) => await probeReviewTargetDetailed(target, { cwd: root, deep }),
                             worktrees: async () => await worktreeDoctorProbe(root),
                             worktreeBranchLock: async () => await worktreeBranchLockProbe(root),
                             rootGhostFiles: async () => await rootGhostFilesProbe(root)
@@ -362,6 +332,7 @@ else {
                         args,
                         root,
                         isTTY,
+                        codexHome: codexHomeDirectory(),
                         trustStore: store,
                         calculateTrustBinding: async () => await plannedTrustBinding(root),
                         confirm: async (plan, trust) => await confirmPlan(formatUninstallPlan(plan, trust))
@@ -387,6 +358,7 @@ else {
                         isTTY,
                         toolkitVersion: CLI_VERSION,
                         hookRuntimePath: HOOK_RUNTIME_PATH,
+                        codexHome: codexHomeDirectory(),
                         ...(updateArgs.hookTargets === undefined
                             ? {}
                             : { hookTargets: updateArgs.hookTargets }),
@@ -422,8 +394,13 @@ else {
                     // Explicit `--session` wins, then an injected identity, then the
                     // id a SessionStart hook recorded for this checkout: a command
                     // run inside a session is never told which session it is in.
-                    const sessionId = process.env.AGENT_OPS_SESSION_ID ??
-                        await readRecordedSessionId(root);
+                    // Only create, attach and status act as a session; a contested
+                    // record refuses those rather than guess, and leaves the rest.
+                    const actsAsSession = args.action === "create" ||
+                        args.action === "attach" || args.action === "status";
+                    const sessionId = args.sessionId ?? (actsAsSession
+                        ? await resolveCommandSessionId(root)
+                        : sessionIdFromEnvironment() ?? await readRecordedSessionId(root));
                     const createConfig = args.action === "create"
                         ? (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config
                         : undefined;
@@ -460,12 +437,68 @@ else {
                             : {})
                     });
                 }
-                if (args.command === "review") {
+                const probeTarget = async (target, budget) => await probeReviewTargetDetailed(target, {
+                    cwd: root,
+                    deep: true,
+                    // The probe answers within the chain's remaining budget
+                    // or not at all; its own default would outlast it.
+                    ...(budget === undefined ? {} : { timeoutMs: budget.timeoutMs })
+                });
+                // One place builds a review's options, so `review` and each task of
+                // a `batch` are reviewed identically.
+                const buildReviewOptions = async (reviewArgs, signal, preflightTarget = probeTarget, progressPrefix = "") => {
                     const reviewSessionId = process.env.AGENT_OPS_SESSION_ID;
                     const reviewGit = gitRunner(root);
-                    const reviewConfig = (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config;
+                    const reviewConfig = (await loadEffectiveConfig(root, reviewArgs.scope === "user" ? "user" : "project")).config;
                     const reviewRole = resolveReviewRole("independent-review", reviewConfig.reviewRoles ?? []);
                     const configuredReviewTargets = reviewRole?.targets ?? [];
+                    return {
+                        args: reviewArgs,
+                        authorized: reviewArgs.yes,
+                        tasks: taskService,
+                        ...(reviewArgs.taskId === undefined ? {} : { taskId: reviewArgs.taskId }),
+                        ...(reviewSessionId === undefined
+                            ? {}
+                            : { sessionId: reviewSessionId }),
+                        ...(reviewConfig.reviewRoles === undefined
+                            ? {}
+                            : { roles: reviewConfig.reviewRoles }),
+                        targets: configuredReviewTargets,
+                        root,
+                        gitRunner: reviewGit,
+                        policyConfigHash: calculateConfigHash(reviewConfig),
+                        currentPolicyConfigHash: async () => calculateConfigHash((await loadEffectiveConfig(root, reviewArgs.scope === "user" ? "user" : "project")).config),
+                        config: reviewConfig,
+                        evidenceStore: new FileEvidenceStore(root, root),
+                        execute: createReviewExecutor({
+                            targets: configuredReviewTargets,
+                            cwd: root,
+                            ...(reviewRole?.model === undefined
+                                ? {}
+                                : { model: reviewRole.model }),
+                            ...(reviewRole?.effort === undefined
+                                ? {}
+                                : { effort: reviewRole.effort }),
+                            ...(reviewRole?.timeoutMs === undefined
+                                ? {}
+                                : { timeoutMs: reviewRole.timeoutMs }),
+                            preflightTarget,
+                            verifySourceFingerprint: async (expected) => {
+                                const currentScope = await resolveReviewScope({
+                                    root,
+                                    runner: reviewGit,
+                                    ...(reviewArgs.base === undefined ? {} : { base: reviewArgs.base })
+                                });
+                                return await calculateSourceFingerprint(root, currentScope, reviewGit) === expected;
+                            },
+                            signal,
+                            onProgress: (line) => {
+                                process.stderr.write(`${progressPrefix}${line}\n`);
+                            }
+                        })
+                    };
+                };
+                if (args.command === "review") {
                     const controller = new AbortController();
                     let interruptedBy;
                     const interrupt = (signal) => {
@@ -477,59 +510,7 @@ else {
                     process.once("SIGINT", onSigint);
                     process.once("SIGTERM", onSigterm);
                     try {
-                        return await runReviewCommand({
-                            args,
-                            authorized: args.yes,
-                            tasks: taskService,
-                            ...(args.taskId === undefined ? {} : { taskId: args.taskId }),
-                            ...(reviewSessionId === undefined
-                                ? {}
-                                : { sessionId: reviewSessionId }),
-                            ...(reviewConfig.reviewRoles === undefined
-                                ? {}
-                                : { roles: reviewConfig.reviewRoles }),
-                            targets: configuredReviewTargets,
-                            root,
-                            gitRunner: reviewGit,
-                            policyConfigHash: calculateConfigHash(reviewConfig),
-                            currentPolicyConfigHash: async () => calculateConfigHash((await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config),
-                            config: reviewConfig,
-                            evidenceStore: new FileEvidenceStore(root, root),
-                            execute: createReviewExecutor({
-                                targets: configuredReviewTargets,
-                                cwd: root,
-                                ...(reviewRole?.model === undefined
-                                    ? {}
-                                    : { model: reviewRole.model }),
-                                ...(reviewRole?.effort === undefined
-                                    ? {}
-                                    : { effort: reviewRole.effort }),
-                                ...(reviewRole?.timeoutMs === undefined
-                                    ? {}
-                                    : { timeoutMs: reviewRole.timeoutMs }),
-                                preflightTarget: async (target, budget) => await probeReviewTarget(target, {
-                                    cwd: root,
-                                    deep: true,
-                                    // The probe answers within the chain's remaining budget
-                                    // or not at all; its own default would outlast it.
-                                    ...(budget === undefined
-                                        ? {}
-                                        : { timeoutMs: budget.timeoutMs })
-                                }),
-                                verifySourceFingerprint: async (expected) => {
-                                    const currentScope = await resolveReviewScope({
-                                        root,
-                                        runner: reviewGit,
-                                        ...(args.base === undefined ? {} : { base: args.base })
-                                    });
-                                    return await calculateSourceFingerprint(root, currentScope, reviewGit) === expected;
-                                },
-                                signal: controller.signal,
-                                onProgress: (line) => {
-                                    process.stderr.write(`${line}\n`);
-                                }
-                            })
-                        });
+                        return await runReviewCommand(await buildReviewOptions(args, controller.signal));
                     }
                     catch (error) {
                         if (error instanceof ReviewInterruptedError &&
@@ -543,6 +524,72 @@ else {
                         process.removeListener("SIGTERM", onSigterm);
                     }
                 }
+                if (args.command === "batch") {
+                    const controller = new AbortController();
+                    let interruptedBy;
+                    const interrupt = (signal) => {
+                        interruptedBy ??= signal;
+                        controller.abort(signal);
+                    };
+                    const onSigint = () => interrupt("SIGINT");
+                    const onSigterm = () => interrupt("SIGTERM");
+                    process.once("SIGINT", onSigint);
+                    process.once("SIGTERM", onSigterm);
+                    try {
+                        const batchScope = args.scope === "user" ? "user" : "project";
+                        const batchConfig = (await loadEffectiveConfig(root, batchScope)).config;
+                        const batchGit = gitRunner(root);
+                        const trusted = await repositoryTrust(root, batchConfig, CLI_VERSION) === "TRUSTED";
+                        const guard = await createSourceGuard(batchGit);
+                        const preflight = memoizePreflight(probeTarget);
+                        const taskArgs = (taskId, base) => parseArgs(["review", "--task", taskId, "--base", base, "--yes"]);
+                        const worktreeRecord = await readWorktreeRecord(root);
+                        const envelope = await runBatchCommand({
+                            args,
+                            tasks: taskService,
+                            ...(worktreeRecord === null ? {} : { worktreeBase: worktreeRecord.base }),
+                            guard,
+                            isVerified: async (taskId, base) => await hasFreshVerification(await buildReviewOptions(taskArgs(taskId, base), controller.signal, preflight), taskId, base),
+                            verify: async (taskId, base) => {
+                                const report = await new VerificationService({
+                                    root,
+                                    scope: batchScope,
+                                    config: batchConfig,
+                                    gitRunner: batchGit,
+                                    processRunner: new NodeVerificationProcessRunner(),
+                                    taskService,
+                                    evidenceStore: new FileEvidenceStore(root, root),
+                                    trusted,
+                                    base
+                                }).verify(taskId);
+                                return report.status === "PASS" ? "PASS" : "FAIL";
+                            },
+                            review: async (taskId, base, signal) => {
+                                const reviewed = await runReviewCommand(await buildReviewOptions(taskArgs(taskId, base), signal, preflight, `${taskId.slice(5, 13)}: `));
+                                const result = reviewed.data?.result;
+                                return result === undefined
+                                    ? { status: "NOT_RUN", reason: reviewed.errors[0]?.code ?? "review-error" }
+                                    : {
+                                        status: result.status,
+                                        ...(result.reason === undefined ? {} : { reason: result.reason }),
+                                        ...(result.reused === true ? { reused: true } : {})
+                                    };
+                            },
+                            signal: controller.signal,
+                            onProgress: (line) => {
+                                process.stderr.write(`batch: ${line}\n`);
+                            }
+                        });
+                        if (interruptedBy !== undefined) {
+                            process.exit(interruptedBy === "SIGINT" ? 130 : 143);
+                        }
+                        return envelope;
+                    }
+                    finally {
+                        process.removeListener("SIGINT", onSigint);
+                        process.removeListener("SIGTERM", onSigterm);
+                    }
+                }
                 if (args.command === "config") {
                     return explainConfigCommand(await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project"));
                 }