@kylecheng3146/agent-ops 0.5.2 → 0.6.0

package/README.md

@@ -12,6 +12,54 @@ pre-1.0 interface.
 The CLI is published as `@kylecheng3146/agent-ops` as a pre-1.0 interface;
 command behavior may change before 1.0.
 
+## Executable acceptance and native goal runs (0.6.0)
+
+Criteria can use `behavioral`, `invariant` or `review-only` acceptance contracts.
+Behavioral proof requires each designated red check to fail by assertion on its
+immutable baseline and every required check to pass on the candidate. Invariants
+can pass on both versions. Review-only requirements still need two fresh reviews
+against the original goal and an explicit `reviewOnlyReason` in the acceptance
+contract. Legacy criteria keep their existing verifier behavior.
+
+Configure and trust `verification.acceptanceRunners` in the repository. Tasks bind
+stable check IDs and explicit committed test/fixture/helper materials; they cannot
+override runner executables or arguments. Each version installs and builds its own
+declared dependencies. Fixture errors, skipped/retried checks, incomplete output and
+timeouts produce UNKNOWN. Review examines the checks themselves and every fallback.
+`task revise`, `task replan` and `task pin-finding` preserve goal and evidence history;
+`task status` and `doctor` distinguish mechanical coverage from review-only coverage.
+
+On macOS, a trusted clean main checkout can start an isolated native goal run:
+
+```sh
+agent-ops run "Implement the requested behavior" --host codex --time-budget 60m --jobs 2
+agent-ops run status <run-id>
+agent-ops run logs <run-id>
+agent-ops run respond <run-id> --question-id <id> --answer "Clarification"
+agent-ops run stop <run-id>
+agent-ops run resume <run-id>
+```
+
+`--host claude` uses Claude Code; `--wait` waits for a terminal or input state.
+The coordinator counts toward the two writer slots. Native processes write only
+under current leases in separate worktrees. Active time counts once across parallel
+workers and continues through proof and integration; resume retains earlier usage
+epochs. Missing token or cost counters remain unknown. Completion requires current
+verification, two fresh reviews, completed tasks and a receipt bound to the target.
+Setup runs in the background under registered process groups. Stop cancels native
+writers, local verification and setup; interrupted setup requires explicit resume.
+The coordinator can assess additional non-dangerous fixed commands through a
+policy request. This authorization is bound to the run, runtime, lease and budget;
+it creates no permanent repository trust. Policy transitions fence writers and
+journal delivery imports and contract synchronization before starting new leases.
+Native authorization decisions retain redacted command scope and rationale;
+missing provider decisions remain unknown. Repair compares actual check outcomes
+and outstanding finding pins rather than source fingerprints.
+
+Native lifecycle reachability and framework probe conditions are recorded in
+[the capability probe](docs/harness/native-goal-probe.md); these observations do not
+establish external adoption or a reduction in review cost.
+
 ## Quick start from npm
 
 Requires Node.js `>=22.14.0`. Install the published CLI globally:
@@ -347,6 +395,22 @@ agent-ops doctor --check-auth # one real print call per configured target
 
 ### Batch review
 
+For writing subagents in separate worktrees, record each child's complete
+modification intent at task creation (`--intent`), then commit and run its
+local verifier. The coordinator runs `agent-ops task advance --task <parent-id>
+--session <session-id> --yes` from the main checkout through the same trusted
+outer host runner used for review. Advance integrates the committed children,
+verifies every parent and child criterion on the integrated candidate, and
+runs one two-round tree review. Only `NOT_RUN / scope-too-large` falls back to
+per-task two-round reviews; FAIL requires a fix and a fresh final gate. A
+passing gate saves the complete local receipt in `.git/agent-ops/receipts/`
+before finish. A moved target gets at most one automatic rebase and repeat.
+Run `agent-ops review show --task <parent-id>` from the main checkout to read
+both full recorded reports for the latest candidate without invoking a reviewer.
+`task advance` prints a short summary of nonblocking findings and residual risks.
+
+`batch` remains the per-task review command for tasks already in one worktree.
+
 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:

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

@@ -11,7 +11,8 @@ export const COMMAND_NAMES = [
     "review",
     "batch",
     "allow-stop",
-    "worktree"
+    "worktree",
+    "run"
 ];
 const COMMAND_SET = new Set(COMMAND_NAMES);
 const SCOPES = new Set(["project", "user"]);
@@ -61,6 +62,8 @@ function parseHookTarget(option, value) {
     return { harness: harness, surfaceId };
 }
 export function parseArgs(argv) {
+    if (argv[0] === "run")
+        return parseRunArgs(argv.slice(1));
     let command;
     let action;
     let scope;
@@ -70,6 +73,7 @@ export function parseArgs(argv) {
     let parentTaskId;
     let targetVersion;
     let title;
+    let intent;
     let sessionId;
     let base;
     let parentBase;
@@ -77,6 +81,14 @@ export function parseArgs(argv) {
     const profiles = [];
     const reviewTargets = [];
     const criteria = [];
+    const criterionFiles = [];
+    let criteriaFile;
+    let planFile;
+    let expectedContract;
+    let expectedTreeContract;
+    let reason;
+    let baseline;
+    let findingReference;
     const evidence = [];
     let checkAuth = false;
     const checkAuthTargets = [];
@@ -85,6 +97,7 @@ export function parseArgs(argv) {
     let json = false;
     let yes = false;
     let rerun = false;
+    let tree = false;
     let helpSeen = false;
     let versionSeen = false;
     let worktreeName;
@@ -187,6 +200,52 @@ export function parseArgs(argv) {
                 index += 1;
                 break;
             }
+            case "--intent": {
+                if (intent !== undefined)
+                    duplicate(token);
+                intent = readOptionValue(argv, index, token);
+                index += 1;
+                break;
+            }
+            case "--tree": {
+                if (tree)
+                    duplicate(token);
+                tree = true;
+                break;
+            }
+            case "--criterion-file":
+                criterionFiles.push(readOptionValue(argv, index++, token));
+                break;
+            case "--criteria-file":
+                if (criteriaFile !== undefined)
+                    duplicate(token);
+                criteriaFile = readOptionValue(argv, index++, token);
+                break;
+            case "--plan-file":
+                if (planFile !== undefined)
+                    duplicate(token);
+                planFile = readOptionValue(argv, index++, token);
+                break;
+            case "--expected-contract":
+                if (expectedContract !== undefined)
+                    duplicate(token);
+                expectedContract = readOptionValue(argv, index++, token);
+                break;
+            case "--expected-tree-contract":
+                if (expectedTreeContract !== undefined)
+                    duplicate(token);
+                expectedTreeContract = readOptionValue(argv, index++, token);
+                break;
+            case "--reason":
+                if (reason !== undefined)
+                    duplicate(token);
+                reason = readOptionValue(argv, index++, token);
+                break;
+            case "--baseline":
+                if (baseline !== undefined)
+                    duplicate(token);
+                baseline = readOptionValue(argv, index++, token);
+                break;
             case "--criterion": {
                 criteria.push(readOptionValue(argv, index, token));
                 index += 1;
@@ -365,16 +424,21 @@ export function parseArgs(argv) {
                 if (command === "task" &&
                     action === undefined &&
                     [
+                        "advance",
                         "archive",
                         "attach",
                         "complete",
                         "create",
                         "export",
-                        "status"
+                        "status", "revise", "replan", "pin-finding"
                     ].includes(token)) {
                     action = token;
                     break;
                 }
+                if (command === "review" && action === undefined && token === "show") {
+                    action = "show";
+                    break;
+                }
                 if (command === "worktree" &&
                     action === undefined &&
                     WORKTREE_ACTIONS.includes(token)) {
@@ -389,6 +453,14 @@ export function parseArgs(argv) {
                     worktreeName = token;
                     break;
                 }
+                if (command === "task" && ["revise", "replan", "pin-finding"].includes(action ?? "") && taskId === undefined) {
+                    taskId = token;
+                    break;
+                }
+                if (command === "task" && action === "pin-finding" && findingReference === undefined) {
+                    findingReference = token;
+                    break;
+                }
                 if (command !== undefined) {
                     throw new CliArgumentError("CLI_UNEXPECTED_ARGUMENT", `Unexpected argument: ${token}`);
                 }
@@ -433,6 +505,7 @@ export function parseArgs(argv) {
             parentTaskId !== undefined ||
             targetVersion !== undefined ||
             title !== undefined ||
+            intent !== undefined ||
             criteria.length > 0 ||
             evidence.length > 0 ||
             reviewTargets.length > 0 ||
@@ -446,6 +519,7 @@ export function parseArgs(argv) {
             dryRun ||
             yes ||
             rerun ||
+            tree ||
             worktree !== undefined ||
             worktreeFrom !== undefined ||
             worktreeMessage !== undefined ||
@@ -475,11 +549,12 @@ export function parseArgs(argv) {
         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.");
+        throw new CliArgumentError("CLI_ACTION_REQUIRED", "The task command requires one of: create, status, attach, complete, archive, export, advance.");
     }
     const hasTaskTargetOptions = taskId !== undefined ||
         sessionId !== undefined;
     const hasTaskMutationOptions = title !== undefined ||
+        intent !== undefined ||
         criteria.length > 0 ||
         evidence.length > 0;
     if (command !== "task" &&
@@ -528,11 +603,25 @@ export function parseArgs(argv) {
     if (worktree !== undefined && command !== "init" && command !== "update") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--worktree may be used only with init or update.");
     }
+    const revisionAction = command === "task" && ["revise", "replan", "pin-finding"].includes(action ?? "");
+    if ((criterionFiles.length > 0 && !(command === "task" && (action === "create" || action === "pin-finding"))) ||
+        (criteriaFile !== undefined && !(command === "task" && action === "revise")) ||
+        (planFile !== undefined && !(command === "task" && action === "replan")) ||
+        (expectedContract !== undefined && !(command === "task" && (action === "revise" || action === "pin-finding"))) ||
+        (expectedTreeContract !== undefined && !(command === "task" && action === "replan")) ||
+        (reason !== undefined && !revisionAction) ||
+        (baseline !== undefined && !(command === "task" && (action === "create" || action === "revise"))))
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Acceptance options are not supported by this command.");
+    if (revisionAction && (taskId === undefined || evidence.length > 0 || title !== undefined || intent !== undefined || parentTaskId !== undefined || sessionId !== undefined || criteria.length > 0 || base !== undefined ||
+        (action === "revise" && (expectedContract === undefined || criteriaFile === undefined || reason === undefined)) ||
+        (action === "replan" && (expectedTreeContract === undefined || planFile === undefined || reason === undefined)) ||
+        (action === "pin-finding" && (expectedContract === undefined || findingReference === undefined || criterionFiles.length !== 1))))
+        throw new CliArgumentError("CLI_MISSING_VALUE", "Acceptance revision requires task, expected contract, payload and reason.");
     if (command === "task") {
         if (harness !== undefined ||
             profiles.length > 0 ||
             dryRun ||
-            yes ||
+            (yes && action !== "advance") ||
             rerun) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Task commands do not accept harness, profile, dry-run, or yes options.");
         }
@@ -540,7 +629,7 @@ export function parseArgs(argv) {
             (taskId !== undefined ||
                 evidence.length > 0)) ||
             (action === "status" &&
-                (title !== undefined ||
+                (title !== undefined || intent !== undefined ||
                     criteria.length > 0 ||
                     evidence.length > 0 ||
                     // --parent filters the listing, so it cannot name a single target.
@@ -548,21 +637,25 @@ export function parseArgs(argv) {
                         (taskId !== undefined || sessionId !== undefined)) ||
                     (taskId !== undefined && sessionId !== undefined))) ||
             (action === "attach" &&
-                (title !== undefined ||
+                (title !== undefined || intent !== undefined ||
                     criteria.length > 0 ||
                     evidence.length > 0 ||
                     parentTaskId !== undefined)) ||
             (action === "complete" &&
-                (title !== undefined ||
+                (title !== undefined || intent !== undefined ||
                     criteria.length > 0 ||
                     sessionId !== undefined ||
                     parentTaskId !== undefined)) ||
             ((action === "archive" || action === "export") &&
-                (title !== undefined ||
+                (title !== undefined || intent !== undefined ||
                     criteria.length > 0 ||
                     evidence.length > 0 ||
                     sessionId !== undefined ||
-                    parentTaskId !== undefined));
+                    parentTaskId !== undefined)) ||
+            (action === "advance" &&
+                (taskId === undefined || title !== undefined || intent !== undefined ||
+                    criteria.length > 0 || evidence.length > 0 || parentTaskId !== undefined ||
+                    !yes));
         if (taskOptionInvalid) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", `Unsupported option for task ${action}.`);
         }
@@ -585,7 +678,19 @@ export function parseArgs(argv) {
     if (command === "review" && taskId === undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Review requires --task for the complete task-bound review.");
     }
-    if (command === "review" && !yes) {
+    if (command === "review" && action === "show" &&
+        (yes || rerun || tree || base !== undefined || output !== undefined ||
+            scope !== undefined || harness !== undefined || profiles.length > 0 ||
+            criteria.length > 0 || evidence.length > 0)) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "review show accepts only --task and optional --json; it never runs a reviewer.");
+    }
+    if (tree && command !== "review") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--tree may be used only with review.");
+    }
+    if (intent !== undefined && !(command === "task" && action === "create")) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--intent may be used only with task create.");
+    }
+    if (command === "review" && action !== "show" && !yes) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Review requires --yes to authorize both reviewer sessions.");
     }
     if (command === "review" && harness !== undefined) {
@@ -668,9 +773,18 @@ export function parseArgs(argv) {
         ...(parentTaskId === undefined ? {} : { parentTaskId }),
         ...(targetVersion === undefined ? {} : { targetVersion }),
         ...(title === undefined ? {} : { title }),
+        ...(intent === undefined ? {} : { intent }),
         ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
         ...(completionGate === undefined ? {} : { completionGate }),
         ...(criteria.length === 0 ? {} : { criteria }),
+        ...(criterionFiles.length === 0 ? {} : { criterionFiles }),
+        ...(criteriaFile === undefined ? {} : { criteriaFile }),
+        ...(planFile === undefined ? {} : { planFile }),
+        ...(expectedContract === undefined ? {} : { expectedContract }),
+        ...(expectedTreeContract === undefined ? {} : { expectedTreeContract }),
+        ...(reason === undefined ? {} : { reason }),
+        ...(baseline === undefined ? {} : { baseline }),
+        ...(findingReference === undefined ? {} : { findingReference }),
         ...(evidence.length === 0 ? {} : { evidence }),
         ...(sessionId === undefined ? {} : { sessionId }),
         ...(base === undefined ? {} : { base }),
@@ -683,9 +797,99 @@ export function parseArgs(argv) {
         ...(checkAuth ? { checkAuth } : {}),
         ...(checkAuthTargets.length === 0 ? {} : { checkAuthTargets }),
         rerun,
+        ...(tree ? { tree } : {}),
         dryRun,
         json,
         yes,
         ...(worktree === undefined ? {} : { worktree })
     };
 }
+function parseRunArgs(argv) {
+    const actions = ["start", "status", "logs", "resume", "stop", "respond"];
+    if (argv.includes("--help") || argv.includes("-h"))
+        return { command: "help", helpTopic: "run", profiles: [], dryRun: false, json: false, yes: false, rerun: false };
+    const action = actions.includes(argv[0]) ? argv[0] : "start";
+    const args = { command: "run", action, runAction: action, profiles: [], dryRun: false, json: false, yes: false, rerun: false };
+    const seen = new Set();
+    let positional;
+    for (let i = actions.includes(argv[0]) ? 1 : 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (!token.startsWith("-")) {
+            if (positional !== undefined)
+                throw new CliArgumentError("CLI_UNEXPECTED_ARGUMENT", "Quote the goal as one argument; control actions take one run ID.");
+            positional = token;
+            continue;
+        }
+        if (seen.has(token))
+            duplicate(token);
+        seen.add(token);
+        if (token === "--json") {
+            args.json = true;
+            continue;
+        }
+        if (token === "--wait") {
+            args.wait = true;
+            continue;
+        }
+        if (!["--host", "--goal-file", "--time-budget", "--jobs", "--question-id", "--answer", "--answer-file"].includes(token))
+            throw new CliArgumentError("CLI_UNKNOWN_OPTION", `Unknown run option: ${token}`, token);
+        const value = readOptionValue(argv, i++, token);
+        switch (token) {
+            case "--host":
+                if (value !== "claude" && value !== "codex")
+                    invalidValue(token, value);
+                args.host = value;
+                break;
+            case "--goal-file":
+                args.goalFile = value;
+                break;
+            case "--question-id":
+                args.questionId = value;
+                break;
+            case "--answer":
+                args.answer = value;
+                break;
+            case "--answer-file":
+                args.answerFile = value;
+                break;
+            case "--jobs":
+                if (value !== "1" && value !== "2")
+                    invalidValue(token, value);
+                args.jobs = Number(value);
+                break;
+            case "--time-budget": {
+                const match = value.match(/^([1-9][0-9]*)(s|m|h)$/u);
+                if (match === null)
+                    invalidValue(token, value);
+                const ms = Number(match[1]) * ({ s: 1000, m: 60000, h: 3600000 }[match[2]]);
+                if (!Number.isSafeInteger(ms) || ms > 86400000)
+                    invalidValue(token, value);
+                args.timeBudgetMs = ms;
+                break;
+            }
+        }
+    }
+    if (action === "start") {
+        args.goal = positional;
+        if ((args.goal === undefined) === (args.goalFile === undefined))
+            throw new CliArgumentError("RUN_GOAL_REQUIRED", "Provide exactly one quoted goal or --goal-file.");
+        if (args.host === undefined)
+            throw new CliArgumentError("RUN_HOST_REQUIRED", "Choose --host claude or --host codex.");
+        if (args.questionId !== undefined || args.answer !== undefined || args.answerFile !== undefined)
+            throw new CliArgumentError("CLI_INVALID_OPTION", "Answer options require run respond.");
+    }
+    else {
+        if (positional === undefined || !/^[a-z][a-z0-9-]{7,63}$/u.test(positional))
+            throw new CliArgumentError("RUN_ID_REQUIRED", "Control actions require a valid run ID.");
+        args.runId = positional;
+        if (args.host !== undefined || args.goalFile !== undefined || args.jobs !== undefined || args.timeBudgetMs !== undefined || args.wait)
+            throw new CliArgumentError("CLI_INVALID_OPTION", "Start options are not accepted by run control actions.");
+        if (action === "respond") {
+            if (args.questionId === undefined || (args.answer === undefined) === (args.answerFile === undefined))
+                throw new CliArgumentError("RUN_ANSWER_REQUIRED", "Respond requires --question-id and exactly one --answer or --answer-file.");
+        }
+        else if (args.questionId !== undefined || args.answer !== undefined || args.answerFile !== undefined)
+            throw new CliArgumentError("CLI_INVALID_OPTION", "Answer options require run respond.");
+    }
+    return args;
+}

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

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import { productionRunContext } from "./run-deps.js";
+import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
+import { recordRunVerification } from "../../../runtime/src/run/verification.js";
+import { runOwnedLocalProof } from "./owned-run-step.js";
+import { runRunCommand } from "./commands/run.js";
 import { readFile, readdir, stat } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
@@ -17,10 +22,10 @@ import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
 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 { registeredRunProofRunner } 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 { loadEffectiveConfig, runPolicyContext, repositoryTrust, repositoryTrustBinding } from "./context.js";
 import { runHookProcess } from "./hook-process.js";
 import { gitRunner, trustStore, worktreeDependencies } from "./parallel-deps.js";
 import { selectYesNo, writeBanner } from "./ui.js";
@@ -42,6 +47,8 @@ import { resolveReviewScope } from "../../../runtime/src/review/scope.js";
 import { resolveReviewRole } from "../../../runtime/src/review/roles.js";
 import { runTrustCommand } from "./commands/trust.js";
 import { runVerifyCommand } from "./commands/verify.js";
+import { runAdvanceCommand } from "./commands/advance.js";
+import { runReviewShowCommand } from "./commands/review-show.js";
 import { runAllowStopCommand } from "./commands/allow-stop.js";
 import { CompletionGateService } from "../../../runtime/src/hooks/completion-gate.js";
 import { formatUpdatePlan, runUpdateCommand } from "./commands/update.js";
@@ -163,7 +170,22 @@ function runAgy(args, options = {}) {
         ...(process.platform === "win32" ? { shell: true } : {})
     });
 }
-if (argv[0] === "agy-run") {
+let ownedProofExit = null;
+try {
+    ownedProofExit = await runOwnedLocalProof(argv);
+}
+catch (cause) {
+    const code = cause instanceof AgentOpsError ? cause.code : "RUN_LOCAL_PROOF_FAILED";
+    const message = cause instanceof AgentOpsError ? cause.message : "Local proof could not be registered safely.";
+    if (argv.includes("--json"))
+        process.stdout.write(JSON.stringify(errorEnvelope(code, message)) + "\n");
+    else
+        process.stderr.write(message + "\n");
+    ownedProofExit = 2;
+}
+if (ownedProofExit !== null)
+    process.exitCode = ownedProofExit;
+else if (argv[0] === "agy-run") {
     try {
         const root = process.cwd();
         const config = (await loadEffectiveConfig(root, "project")).config;
@@ -222,6 +244,13 @@ else {
                 const isTTY = !args.json &&
                     process.stdin.isTTY === true &&
                     process.stdout.isTTY === true;
+                if ((["init", "update"].includes(args.command) || (args.command === "trust" && args.action !== "status")) &&
+                    (process.env.AGENT_OPS_RUN_ID !== undefined || await runPolicyContext(process.cwd()) !== null))
+                    throw new AgentOpsError("RUN_POLICY_COORDINATOR_REQUIRED", "Run workers must request scoped policy review from the coordinator; permanent trust and host rules cannot be changed by the run.");
+                if (args.command === "run") {
+                    const context = await productionRunContext(root);
+                    return await runRunCommand({ args, ...context, root: context.mainRoot });
+                }
                 if (args.command === "init") {
                     const store = trustStore();
                     return await runInitCommand({
@@ -265,6 +294,17 @@ else {
                         root,
                         toolkitVersion: CLI_VERSION,
                         probes: {
+                            acceptanceCoverage: async () => {
+                                const service = new TaskService(new FileTaskStore(join(root, ".agent-ops/tasks/state.json"), root), { completion: { root, gitRunner: gitRunner(root), loadConfig: async () => config } });
+                                const records = (await service.list()).filter(r => r.status !== "archived");
+                                const rows = await Promise.all(records.map(r => service.coverage(r.task.id)));
+                                const criteria = rows.flatMap(row => row.rows);
+                                const mechanical = criteria.filter(c => c.mode === "behavioral" || c.mode === "invariant");
+                                return { status: "PASS", message: criteria.length + " criteria; " +
+                                        criteria.filter(c => c.mode === "legacy").length + " legacy; " + mechanical.filter(c => c.status === "proven").length + "/" + mechanical.length +
+                                        " mechanical proven; " + criteria.filter(c => c.mode === "review-only").length + " review-only; originally mechanical " + rows.reduce((n, r) => n + r.originalMechanical, 0) +
+                                        "; undischarged " + rows.reduce((n, r) => n + r.rows.filter(c => c.status !== "proven" && !r.reviewed).length, 0) };
+                            },
                             ...(doctorManifest?.harness.includes("agy") === true
                                 ? {
                                     agyRuntime: () => {
@@ -402,6 +442,14 @@ else {
                     const sessionId = args.sessionId ?? (actsAsSession
                         ? await resolveCommandSessionId(root)
                         : sessionIdFromEnvironment() ?? await readRecordedSessionId(root));
+                    if (args.action === "advance") {
+                        return await runAdvanceCommand({
+                            cwd: root,
+                            sessionId: sessionId ?? await resolveCommandSessionId(root),
+                            parentTaskId: args.taskId,
+                            deps: worktreeDependencies()
+                        });
+                    }
                     const createConfig = args.action === "create"
                         ? (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config
                         : undefined;
@@ -431,7 +479,8 @@ else {
                                     return {
                                         path: record.path,
                                         base: record.base,
-                                        service: new TaskService(new FileTaskStore(join(record.path, ".agent-ops", "tasks", "state.json"), record.path))
+                                        service: new TaskService(new FileTaskStore(join(record.path, ".agent-ops", "tasks", "state.json"), record.path), { completion: { root: record.path, gitRunner: gitRunner(record.path),
+                                                loadConfig: async () => (await loadEffectiveConfig(record.path, "project")).config } })
                                     };
                                 }
                             }
@@ -491,6 +540,7 @@ else {
                         config: reviewConfig,
                         evidenceStore: new FileEvidenceStore(root, root),
                         execute: inSlot(createReviewExecutor({
+                            runner: registeredRunProofRunner(),
                             targets: configuredReviewTargets,
                             cwd: root,
                             ...(reviewRole?.model === undefined
@@ -503,10 +553,11 @@ else {
                                 ? {}
                                 : { timeoutMs: reviewRole.timeoutMs }),
                             preflightTarget,
-                            verifySourceFingerprint: async (expected) => {
+                            verifySourceFingerprint: async (expected, scope) => {
                                 const currentScope = await resolveReviewScope({
                                     root,
                                     runner: reviewGit,
+                                    ...(scope?.mode === "base" && scope.noChange === true ? { noChangePaths: scope.changedFiles } : {}),
                                     ...(reviewArgs.base === undefined ? {} : { base: reviewArgs.base })
                                 });
                                 return await calculateSourceFingerprint(root, currentScope, reviewGit) === expected;
@@ -519,6 +570,9 @@ else {
                     };
                 };
                 if (args.command === "review") {
+                    if (args.action === "show") {
+                        return await runReviewShowCommand({ cwd: root, taskId: args.taskId, deps: worktreeDependencies() });
+                    }
                     const controller = new AbortController();
                     let interruptedBy;
                     const interrupt = (signal) => {
@@ -576,7 +630,7 @@ else {
                                     scope: batchScope,
                                     config: batchConfig,
                                     gitRunner: batchGit,
-                                    processRunner: new NodeVerificationProcessRunner(),
+                                    processRunner: registeredRunProofRunner(),
                                     taskService,
                                     evidenceStore: new FileEvidenceStore(root, root),
                                     trusted,
@@ -620,17 +674,23 @@ else {
                     return await runVerifyCommand({
                         args,
                         taskService,
-                        service: new VerificationService({
-                            root,
-                            scope: args.scope === "user" ? "user" : "project",
-                            config,
-                            gitRunner: gitRunner(root),
-                            processRunner: new NodeVerificationProcessRunner(),
-                            taskService,
-                            evidenceStore: new FileEvidenceStore(root, root),
-                            trusted: trustStatus === "TRUSTED",
-                            ...(args.base === undefined ? {} : { base: args.base })
-                        })
+                        service: { verify: async (taskId) => {
+                                const run = await runPolicyContext(root);
+                                const report = await new VerificationService({
+                                    root,
+                                    scope: args.scope === "user" ? "user" : "project",
+                                    config,
+                                    gitRunner: gitRunner(root),
+                                    processRunner: registeredRunProofRunner(),
+                                    taskService,
+                                    evidenceStore: new FileEvidenceStore(root, root),
+                                    trusted: trustStatus === "TRUSTED",
+                                    ...(args.base === undefined ? {} : { base: args.base })
+                                }).verify(taskId);
+                                if (run !== null)
+                                    await recordRunVerification(run.repository, run.state, run.worker?.workerId ?? run.state.coordinatorId, await taskService.status({ taskId }), report);
+                                return report;
+                            } }
                     });
                 }
                 if (args.command === "trust") {