@kylecheng3146/agent-ops 0.5.3 → 0.7.0

package/README.md

@@ -12,6 +12,86 @@ 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.
+
+Office is a Preview feature, disabled by default. Enable it in the init/update
+selector (update keeps your current choice), or use explicit flags:
+
+```sh
+agent-ops update --office on
+agent-ops office
+# Disable later: agent-ops update --office off
+```
+
+It prints a tokened `http://127.0.0.1:<port>/` URL (also shown by `run start` and
+`run status`) to a read-only pixel office with cream walls, oak floors
+and sage furniture. The overview fits the viewport without scrolling: each run
+team shares a room, and each ordinary session has its own room, including sessions
+without a task or worktree. The furnished floorplan fills the page below the
+header, with a shared hallway between rooms. You control the Supervisor using
+arrow keys or WASD and can walk into each room; clicking a room also opens its
+larger detail view, with a return control. Characters move between planning, development,
+verification, review and integration areas. Short nameplates show their current
+work; room whiteboards show criteria progress, verification and review results,
+and questions waiting for an answer. Clicking a character shows task details,
+changed files and copyable commands. Chinese and English can be switched in the
+header; the viewer badge reads “You” in English and “你” in Chinese. The page remembers the choice and respects reduced-motion preferences.
+Supervisor movement and character animation run locally without model requests.
+Completed rooms move to Recently completed and remain for at most two hours.
+The page reads agent-ops state and `git diff` paths only, never transcripts or file
+contents. When enabled, managed ordinary sessions start the shared repository server
+automatically; a newly started Office opens the browser once, and subsequent
+sessions reuse it. The server exits after ten minutes without active runs or
+ordinary sessions. Ordinary-session presence follows hook activity; a crashed
+or silent session expires after 30 minutes without an event. Office failures
+remain advisory and never block session work.
+
+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:
@@ -35,7 +115,7 @@ installation plan.
 
 The interactive multi-select screens start with no harness or profile selected.
 Choose at least one of `agy`, `codex`, `claude`, and `opencode`, and at least one of
-the `core`, `advisory`, `guardrails`, and `loop` profiles before confirming. For
+the `core`, `advisory`, `guardrails`, `loop`, and `run` profiles before confirming. For
 scripted use, `--harness all` selects all four harnesses; comma-separated
 selections such as `codex,opencode` are also supported. The legacy `both` value
 remains an alias for `codex,claude`.
@@ -152,6 +232,28 @@ agent-ops update \
   --dry-run --json
 ```
 
+### Automatic runs (`run` profile)
+
+`run` is an opt-in profile that also selects `core` and `loop`. With it, the
+Claude Code and Codex rules hand a change that needs more than five acceptance
+criteria to `agent-ops run` instead of splitting it into subtasks; five or fewer
+stay in the session. The agent writes the prompt verbatim plus its proposed
+criteria to the gitignored `.agent-ops/state/run-goal.md` from the main checkout
+(the worktree guard lets exactly that write through), then starts
+`agent-ops run --goal-file .agent-ops/state/run-goal.md --host claude --wait`
+(or `--host codex`, escalated like review) in the background and relays any
+question through `agent-ops run respond`. A start refused with
+`RUN_TARGET_REQUIRED`, `RUN_BACKGROUND_UNSUPPORTED`, `RUN_TARGET_DIRTY`, or
+`WORKTREE_NESTED` falls back to the subtask flow; `RUN_REPO_UNTRUSTED` stops and
+asks you. A run that ends without completing is reported with its status, last
+log events, and the `agent-ops run resume <id>` / `agent-ops run stop <id>`
+commands; it is never resumed automatically. agy keeps the subtask flow.
+Init and update pre-authorize `agent-ops run` for Claude Code and Codex.
+
+```bash
+agent-ops init --scope project --harness codex,claude --profile run --yes
+```
+
 ## Quick start from a source checkout
 
 For development or to run the repository version directly, use a source

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

@@ -11,11 +11,13 @@ export const COMMAND_NAMES = [
     "review",
     "batch",
     "allow-stop",
-    "worktree"
+    "worktree",
+    "run",
+    "office"
 ];
 const COMMAND_SET = new Set(COMMAND_NAMES);
 const SCOPES = new Set(["project", "user"]);
-const PROFILES = new Set(["advisory", "core", "guardrails", "loop"]);
+const PROFILES = new Set(["advisory", "core", "guardrails", "loop", "run"]);
 // 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", "commit", "finish", "list", "resume", "remove"];
@@ -61,6 +63,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;
@@ -78,10 +82,19 @@ 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 = [];
     let completionGate;
+    let office;
     let dryRun = false;
     let json = false;
     let yes = false;
@@ -202,6 +215,39 @@ export function parseArgs(argv) {
                 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;
@@ -272,6 +318,16 @@ export function parseArgs(argv) {
                 }
                 completionGate = true;
                 break;
+            case "--office": {
+                if (office !== undefined)
+                    duplicate(token);
+                const value = readOptionValue(argv, index, token);
+                if (value !== "on" && value !== "off")
+                    invalidValue(token, value);
+                office = value;
+                index += 1;
+                break;
+            }
             case "--worktree": {
                 if (worktree !== undefined) {
                     duplicate(token);
@@ -386,7 +442,7 @@ export function parseArgs(argv) {
                         "complete",
                         "create",
                         "export",
-                        "status"
+                        "status", "revise", "replan", "pin-finding"
                     ].includes(token)) {
                     action = token;
                     break;
@@ -409,6 +465,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}`);
                 }
@@ -458,6 +522,7 @@ export function parseArgs(argv) {
             evidence.length > 0 ||
             reviewTargets.length > 0 ||
             completionGate !== undefined ||
+            office !== undefined ||
             sessionId !== undefined ||
             base !== undefined ||
             parentBase !== undefined ||
@@ -548,9 +613,26 @@ export function parseArgs(argv) {
     if (completionGate !== undefined && command !== "init") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--completion-gate may be used only with init.");
     }
+    if (office !== undefined && command !== "init" && command !== "update") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--office may be used only with init or update.");
+    }
     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 ||
@@ -710,7 +792,16 @@ export function parseArgs(argv) {
         ...(intent === undefined ? {} : { intent }),
         ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
         ...(completionGate === undefined ? {} : { completionGate }),
+        ...(office === undefined ? {} : { office }),
         ...(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 }),
@@ -730,3 +821,92 @@ export function parseArgs(argv) {
         ...(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,11 @@
 #!/usr/bin/env node
+import { productionRunContext, runPhaseObserver } 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 { runOfficeCommand } from "./commands/office.js";
+import { ensureBackgroundOffice, observeOfficeSession, openOfficeBrowser, serveOffice } from "./office-entry.js";
 import { readFile, readdir, stat } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
@@ -17,10 +24,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";
@@ -165,7 +172,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;
@@ -203,7 +225,7 @@ else if (argv[0] === "hook") {
         stdin: process.stdin,
         writeStdout: (value) => process.stdout.write(value),
         writeStderr: (value) => process.stderr.write(value)
-    }, CLI_VERSION, { worktree: worktreeDependencies() });
+    }, CLI_VERSION, { worktree: worktreeDependencies(), office: observeOfficeSession });
 }
 else {
     process.exitCode = await runCli(argv, {
@@ -224,6 +246,17 @@ 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, office: async () => await ensureBackgroundOffice(root, undefined, openOfficeBrowser) });
+                }
+                if (args.command === "office") {
+                    return await runOfficeCommand({ ensure: async () => await ensureBackgroundOffice(root, undefined, openOfficeBrowser),
+                        foreground: async (onUrl) => await serveOffice(root, onUrl), writeStdout: (text) => { process.stdout.write(text); } });
+                }
                 if (args.command === "init") {
                     const store = trustStore();
                     return await runInitCommand({
@@ -267,6 +300,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: () => {
@@ -368,6 +412,7 @@ else {
                         trustStore: store,
                         calculateTrustBinding: async (config) => await plannedTrustBinding(root, config),
                         confirm: async (plan, trust) => await confirmPlan(formatUpdatePlan(plan, trust)),
+                        promptOffice: async (message, enabled) => await selectYesNo(message, { input: process.stdin, output: process.stdout }, enabled),
                         promptWorktree: async (message) => await selectYesNo(message, { input: process.stdin, output: process.stdout }, true),
                         ...(updateArgs.targetVersion === undefined
                             ? {}
@@ -409,7 +454,9 @@ else {
                             cwd: root,
                             sessionId: sessionId ?? await resolveCommandSessionId(root),
                             parentTaskId: args.taskId,
-                            deps: worktreeDependencies()
+                            deps: worktreeDependencies(),
+                            ...(process.env.AGENT_OPS_RUN_ID === undefined || process.env.AGENT_OPS_WORKER_ID === undefined ? {} :
+                                { onPhase: await runPhaseObserver(root, process.env.AGENT_OPS_RUN_ID, process.env.AGENT_OPS_WORKER_ID) })
                         });
                     }
                     const createConfig = args.action === "create"
@@ -441,7 +488,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 } })
                                     };
                                 }
                             }
@@ -478,6 +526,7 @@ else {
                         : async (request) => await withReviewSlot({
                             dir: slotDir,
                             signal,
+                            holder: { root, ...(reviewArgs.taskId === undefined ? {} : { taskId: reviewArgs.taskId }) },
                             onWait: (line) => {
                                 process.stderr.write(`${progressPrefix}${line}\n`);
                             }
@@ -501,6 +550,7 @@ else {
                         config: reviewConfig,
                         evidenceStore: new FileEvidenceStore(root, root),
                         execute: inSlot(createReviewExecutor({
+                            runner: registeredRunProofRunner(),
                             targets: configuredReviewTargets,
                             cwd: root,
                             ...(reviewRole?.model === undefined
@@ -513,10 +563,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;
@@ -589,7 +640,7 @@ else {
                                     scope: batchScope,
                                     config: batchConfig,
                                     gitRunner: batchGit,
-                                    processRunner: new NodeVerificationProcessRunner(),
+                                    processRunner: registeredRunProofRunner(),
                                     taskService,
                                     evidenceStore: new FileEvidenceStore(root, root),
                                     trusted,
@@ -633,17 +684,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") {