@kylecheng3146/agent-ops 0.10.0 → 0.11.0

package/README.md

@@ -32,7 +32,7 @@ timeouts produce UNKNOWN. Review examines the checks themselves and every fallba
 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 "Implement the requested behavior" --host codex --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"
@@ -49,7 +49,8 @@ verification, two fresh reviews, completed tasks and a receipt bound to the targ
 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;
+policy request. New runs have no total time cap; manual resume upgrades legacy finite runs while keeping accounting.
+This finite authorization is bound to the run, runtime and lease;
 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;

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

@@ -66,6 +66,10 @@ function parseHookTarget(option, value) {
 export function parseArgs(argv) {
     if (argv[0] === "run")
         return parseRunArgs(argv.slice(1));
+    if (argv[0] === "task" && argv[1] === "debug")
+        throw new CliArgumentError("TASK_DEBUG_REMOVED", "task debug was removed in 0.11.0. A DEBUG task is task create --debug with a behavioral " +
+            "criterion whose redCheckIds fail at the baseline and pass on the candidate; then verify, review and finish as usual. " +
+            "Declare an escape origin, if known, with task revise --escape-of.");
     let command;
     let action;
     let scope;
@@ -78,10 +82,6 @@ export function parseArgs(argv) {
     let intent;
     let taskGoal;
     let debug = false;
-    let debugAction;
-    let payloadFile;
-    let commandId;
-    let eventId;
     let sessionId;
     let base;
     let parentBase;
@@ -233,30 +233,6 @@ export function parseArgs(argv) {
                     duplicate(token);
                 debug = true;
                 break;
-            case "--debug-action": {
-                if (debugAction !== undefined)
-                    duplicate(token);
-                const value = readOptionValue(argv, index++, token);
-                if (!["status", "hypothesis", "strategy", "investigate", "checkpoint", "resume", "extend", "origin"].includes(value))
-                    invalidValue(token, value);
-                debugAction = value;
-                break;
-            }
-            case "--payload-file":
-                if (payloadFile !== undefined)
-                    duplicate(token);
-                payloadFile = readOptionValue(argv, index++, token);
-                break;
-            case "--command-id":
-                if (commandId !== undefined)
-                    duplicate(token);
-                commandId = readOptionValue(argv, index++, token);
-                break;
-            case "--event-id":
-                if (eventId !== undefined)
-                    duplicate(token);
-                eventId = readOptionValue(argv, index++, token);
-                break;
             case "--tree": {
                 if (tree)
                     duplicate(token);
@@ -530,7 +506,7 @@ export function parseArgs(argv) {
                         "complete",
                         "create",
                         "export",
-                        "status", "revise", "replan", "pin-finding", "debug"
+                        "status", "revise", "replan", "pin-finding"
                     ].includes(token)) {
                     action = token;
                     break;
@@ -674,8 +650,8 @@ export function parseArgs(argv) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--target-version may be used only with update.");
     }
     if (base !== undefined && command !== "verify" && command !== "review" &&
-        command !== "batch" && !(command === "task" && (action === "complete" || action === "debug"))) {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--base may be used only with verify, review, batch, task complete or task debug.");
+        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.`);
@@ -714,13 +690,6 @@ export function parseArgs(argv) {
     const revisionAction = command === "task" && ["revise", "replan", "pin-finding"].includes(action ?? "");
     if ((taskGoal !== undefined || debug) && !(command === "task" && action === "create"))
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--goal and --debug apply only to task create.");
-    if ((debugAction !== undefined || commandId !== undefined || eventId !== undefined || payloadFile !== undefined) && !(command === "task" && action === "debug"))
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Debug operation options apply only to task debug.");
-    if (command === "task" && action === "debug" && (taskId === undefined || debugAction === undefined || title !== undefined || intent !== undefined ||
-        parentTaskId !== undefined || criteria.length > 0 || evidence.length > 0 ||
-        ((debugAction === "hypothesis" || debugAction === "strategy" || debugAction === "origin") !== (payloadFile !== undefined)) ||
-        ((debugAction === "investigate") !== (commandId !== undefined)) || ((debugAction === "extend") !== (eventId !== undefined))))
-        throw new CliArgumentError("CLI_MISSING_VALUE", "Task debug requires --task, --debug-action and the operation's exact payload/command/event options.");
     if ((criterionFiles.length > 0 && !(command === "task" && (action === "create" || action === "pin-finding"))) ||
         (criteriaFile !== undefined && !(command === "task" && action === "revise")) ||
         (surfaceFile !== undefined && !(command === "task" && (action === "create" || action === "revise"))) ||
@@ -739,7 +708,7 @@ export function parseArgs(argv) {
     if (command === "escapes" && argv.some(token => token !== "escapes" && token !== "--json"))
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "escapes accepts only --json; it is a read-only report.");
     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 && surfaceFile === undefined && escapeOf === undefined) || reason === undefined)) ||
+        (action === "revise" && (expectedContract === undefined || (criteriaFile === undefined && surfaceFile === undefined && escapeOf === undefined && baseline === 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.");
@@ -902,10 +871,6 @@ export function parseArgs(argv) {
         ...(intent === undefined ? {} : { intent }),
         ...(taskGoal === undefined ? {} : { goal: taskGoal }),
         ...(debug ? { debug: true } : {}),
-        ...(debugAction === undefined ? {} : { debugAction }),
-        ...(payloadFile === undefined ? {} : { payloadFile }),
-        ...(commandId === undefined ? {} : { commandId }),
-        ...(eventId === undefined ? {} : { eventId }),
         ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
         ...(completionGate === undefined ? {} : { completionGate }),
         ...(office === undefined ? {} : { office }),
@@ -960,7 +925,7 @@ function parseRunArgs(argv) {
             positional = token;
             continue;
         }
-        if (seen.has(token))
+        if (seen.has(token) && token !== "--retry-approval")
             duplicate(token);
         seen.add(token);
         if (token === "--json") {
@@ -971,10 +936,15 @@ function parseRunArgs(argv) {
             args.wait = true;
             continue;
         }
-        if (!["--host", "--goal-file", "--time-budget", "--jobs", "--question-id", "--answer", "--answer-file"].includes(token))
+        if (!["--host", "--goal-file", "--time-budget", "--jobs", "--question-id", "--answer", "--answer-file", "--retry-approval"].includes(token))
             throw new CliArgumentError("CLI_UNKNOWN_OPTION", `Unknown run option: ${token}`, token);
         const value = readOptionValue(argv, i++, token);
         switch (token) {
+            case "--retry-approval":
+                if (!/^auth-[a-f0-9]{64}$/u.test(value) || args.retryApprovalIds?.includes(value))
+                    invalidValue(token, value);
+                args.retryApprovalIds = [...(args.retryApprovalIds ?? []), value];
+                break;
             case "--host":
                 if (value !== "claude" && value !== "codex")
                     invalidValue(token, value);
@@ -998,17 +968,12 @@ function parseRunArgs(argv) {
                 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;
+                throw new CliArgumentError("RUN_TIME_BUDGET_UNSUPPORTED", "New runs have no total time cap; omit --time-budget. Command and review timeouts remain effective.", token);
             }
         }
     }
+    if (args.retryApprovalIds !== undefined && action !== "resume")
+        throw new CliArgumentError("CLI_INVALID_OPTION", "--retry-approval requires run resume.");
     if (action === "start") {
         args.goal = positional;
         if ((args.goal === undefined) === (args.goalFile === undefined))

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

@@ -47,9 +47,11 @@ import { memoizePreflight } from "../../../runtime/src/review/batch.js";
 import { createReviewExecutor, ReviewInterruptedError } from "../../../runtime/src/review/execute.js";
 import { probeReviewTargetDetailed } from "../../../runtime/src/review/probe.js";
 import { resolveReviewScope } from "../../../runtime/src/review/scope.js";
+import { runSurfaceGate } from "../../../runtime/src/surface/discovery.js";
 import { resolveReviewRole } from "../../../runtime/src/review/roles.js";
 import { runTrustCommand } from "./commands/trust.js";
 import { runVerifyCommand } from "./commands/verify.js";
+import { defaultBase } from "./default-base.js";
 import { runAdvanceCommand } from "./commands/advance.js";
 import { runReviewShowCommand } from "./commands/review-show.js";
 import { runEscapesCommand } from "./commands/escapes.js";
@@ -255,6 +257,16 @@ else {
                 const root = args.scope === "user"
                     ? process.env.AGENT_OPS_HOME ?? homedir()
                     : process.cwd();
+                // Committed work is judged as a range by default; see defaultBase.
+                if ((args.command === "verify" || (args.command === "review" && args.action !== "show")) && args.base === undefined && args.scope !== "user") {
+                    const taskId = args.taskId;
+                    const base = await defaultBase(root, gitRunner(root), async () => taskId === undefined ? undefined :
+                        (await new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)).status({ taskId })).createdSourceCommit)
+                        // Only a default: any failure leaves the command's own scope handling and errors in charge.
+                        .catch(() => undefined);
+                    if (base !== undefined)
+                        args = { ...args, base };
+                }
                 const isTTY = !args.json &&
                     process.stdin.isTTY === true &&
                     process.stdout.isTTY === true;
@@ -495,7 +507,6 @@ else {
                     return await runTaskCommand({
                         args,
                         service: taskService,
-                        ...(args.action !== "debug" ? {} : { trusted: await (async () => { const binding = await plannedTrustBinding(root, (await loadEffectiveConfig(root, "project")).config); return binding !== null && (await trustStore().status(binding)).status === "TRUSTED"; })() }),
                         ...(policyConfigHash === undefined ? {} : { policyConfigHash }),
                         ...(sessionId === undefined ? {} : { sessionId }),
                         ...(fromMain
@@ -553,41 +564,16 @@ else {
                             reviewActivity = undefined;
                         }
                     });
-                    const debugRecord = reviewArgs.taskId === undefined ? undefined : await taskService.status({ taskId: reviewArgs.taskId });
-                    const inDebug = (executor) => debugRecord?.task.debug === undefined ? executor : async (request) => await taskService.debugService().review(debugRecord.task.id, () => executor(request));
                     const inSlot = (executor) => slotDir === undefined
-                        ? inDebug(executor)
+                        ? executor
                         : async (request) => await withReviewSlot({
                             dir: slotDir,
                             signal,
                             holder: { root, ...(reviewArgs.taskId === undefined ? {} : { taskId: reviewArgs.taskId }) },
-                            ...(debugRecord?.task.debug === undefined || reviewSessionId === undefined
-                                ? {}
-                                : (() => {
-                                    let paused = false;
-                                    const debug = taskService.debugService();
-                                    return {
-                                        onWaitStart: async () => {
-                                            if (paused)
-                                                return;
-                                            const current = await debug.root(debugRecord.task.id).catch(() => null);
-                                            if (current?.debug.foreground?.sessionId !== reviewSessionId)
-                                                return;
-                                            await debug.foregroundStop(debugRecord.task.id, reviewSessionId);
-                                            paused = true;
-                                        },
-                                        onWaitEnd: async () => {
-                                            if (!paused)
-                                                return;
-                                            await debug.foregroundStart(debugRecord.task.id, reviewSessionId);
-                                            paused = false;
-                                        }
-                                    };
-                                })()),
                             onWait: (line) => {
                                 process.stderr.write(`${progressPrefix}${line}\n`);
                             }
-                        }, async () => await inDebug(executor)(request));
+                        }, async () => await executor(request));
                     return {
                         args: reviewArgs,
                         authorized: reviewArgs.yes,
@@ -607,7 +593,6 @@ else {
                         config: reviewConfig,
                         evidenceStore: new FileEvidenceStore(root, root),
                         execute: inActivity(inSlot(createReviewExecutor({
-                            ...(debugRecord?.task.debug === undefined ? {} : { remainingBudgetMs: () => taskService.debugService().remaining(debugRecord.task.id) }),
                             runner: registeredRunProofRunner(),
                             targets: configuredReviewTargets,
                             cwd: root,
@@ -749,6 +734,20 @@ else {
                     return await runVerifyCommand({
                         args,
                         taskService,
+                        surface: async (taskId) => {
+                            const record = await taskService.status({ taskId });
+                            // A subtask's surface is its parent's; review checks the tree, so verify stays quiet here.
+                            if (record.task.parentTaskId !== undefined)
+                                return [];
+                            const scope = await resolveReviewScope({ root, runner: gitRunner(root), ...(args.base === undefined ? {} : { base: args.base }) });
+                            const gate = await runSurfaceGate({ root, taskId, surface: record.task.surface, required: record.task.surfaceRequired === true,
+                                ...(scope.mode === "base" ? { base: scope.resolvedBase } : {}), changedFiles: scope.changedFiles, configHash: calculateConfigHash(config) });
+                            if (gate.status === "PASS")
+                                return ["Surface: PASS"];
+                            const paths = gate.details.flatMap(d => typeof d === "object" && d !== null && "path" in d ? [String(d.path)] : []);
+                            return [`Surface (advisory; review would stop with ${gate.code}): ${gate.message}`,
+                                ...paths.slice(0, 20).map(path => `  - ${path}`), ...(paths.length > 20 ? [`  ... ${paths.length - 20} more`] : [])];
+                        },
                         activity: { commonDir: await officeCommonDir(root), root, ...(verifySessionId === undefined ? {} : { sessionId: verifySessionId }) },
                         service: { verify: async (taskId) => {
                                 const run = await runPolicyContext(root);

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

@@ -25,7 +25,7 @@ Commands:
   doctor     Diagnose an installation
   update     Update managed artifacts
   uninstall  Remove managed artifacts
-  task <create|status|attach|revise|replan|pin-finding|debug|advance|complete|archive|export>
+  task <create|status|attach|revise|replan|pin-finding|advance|complete|archive|export>
              Manage independent task acceptance state
   verify     Run configured verification
   review     Run an independent review or show recorded reports
@@ -98,13 +98,22 @@ browser once; later sessions reuse it. It exits after 10 minutes without active
 runs or sessions. Recently completed rooms remain for at most 2 hours.
 The URL carries an access token; do not share it.
 `,
-    run: `Usage: agent-ops run [start] "<goal>" --host <claude|codex> [--jobs <1|2>] [--time-budget <60m>] [--wait] [--json]
+    run: `Usage: agent-ops run [start] "<goal>" --host <claude|codex> [--jobs <1|2>] [--wait] [--json]
        agent-ops run [start] --goal-file <path> --host <claude|codex>
        agent-ops run <status|logs|resume|stop> <run-id> [--json]
+       agent-ops run resume <run-id> [--retry-approval <auth-event-id>]... [--json]
        agent-ops run respond <run-id> --question-id <id> <--answer <text>|--answer-file <path>> [--json]
 
+New runs have no total time cap. Manual resume upgrades legacy finite runs and keeps accounting.
+Command/review timeouts, provider limits and stop controls remain effective.
 Native goal state is observational. Completion requires current verification,
 two fresh reviews, task completion and a target-bound integration receipt.
+--retry-approval explicitly retries an intact Codex approval-review usage-limit
+failure. Original denials remain recorded; every command needs fresh approval.
+Status includes phase, original cause, recorded sealed proof, cleanup state,
+resumability and remediation. Resume revalidates authority and sealed artifacts;
+receipt-bound recovery executes only missing cleanup steps. Resolve the saved
+blocker before retrying: unchanged cleanup inputs are refused.
 `,
     init: `Usage: agent-ops init [options]
 
@@ -179,7 +188,7 @@ Options:
   --json
   --yes
 `,
-    task: `Usage: agent-ops task <create|status|attach|revise|replan|pin-finding|debug|advance|complete|archive|export> [options]
+    task: `Usage: agent-ops task <create|status|attach|revise|replan|pin-finding|advance|complete|archive|export> [options]
 
 Manage independent task acceptance state. Task commands accept none of
 --harness, --profile or --dry-run. Only advance accepts --yes.
@@ -187,16 +196,12 @@ Manage independent task acceptance state. Task commands accept none of
 Options:
   --title <text>                        create
   --goal <text>                         create: immutable original issue/goal
-  --debug                               create: task-level investigation tag
-  --debug-action <status|hypothesis|strategy|investigate|checkpoint|resume|extend|origin>
-  --payload-file <path>                 debug hypothesis/strategy/origin: bounded JSON
-  --command-id <id>                     debug investigate: trusted configured command
-  --event-id <native-event-id|latest>    debug extend: authentic human continue event
+  --debug                               create: bug fix; needs --goal and a behavioral criterion with redCheckIds
   --intent <text>                       create: intended behavior and constraints before editing
   --criterion <json>                    create, repeatable, two to five total
   --criterion-file <path>               create: one criterion object, repeatable; pin-finding: exactly one
   --criteria-file <path>                revise: replacement criterion array
-  --surface-file <path>                 create (required unless --debug), revise: EVIDENCE-SURFACE-001
+  --surface-file <path>                 create (required), revise: EVIDENCE-SURFACE-001
                                         audit JSON, or {"covers":[surface-id]} under a surfaced parent
   --escape-of <commit>                  create, revise: the commit this bug escaped from (Escape Loop)
   --escape-label <label>                with --escape-of: requirement|surface|scenario|criteria|verify|review|flagged|out-of-model
@@ -207,12 +212,12 @@ Options:
   --expected-contract <hash>            revise, pin-finding: current task contract from status
   --expected-tree-contract <hash>       replan: current tree contract from status
   --reason <text>                       required for revise/replan; optional for pin-finding
-  --baseline <git-ref>                  create/revise: baseline for new mechanical requirements
+  --baseline <git-ref>                  create: baseline for typed criteria; revise: move every typed baseline
   --parent <task-id>                    create: record a subtask; status: list subtasks
   --task <id>                           status, attach, revise, replan, pin-finding, complete, archive, export, advance
-  --session <id>                        create, attach, status, advance, debug
+  --session <id>                        create, attach, status, advance
   --evidence <criterion-id=reference>   complete, repeatable
-  --base <git-ref>                      complete, debug: a clean committed range
+  --base <git-ref>                      complete: a clean committed range
   --yes                                 advance: authorize the two review sessions
   --json
 
@@ -224,7 +229,8 @@ Each legacy criterion needs at least one verifierIds entry naming a verification
 command id configured in .agent-ops/config.json. Typed criteria additionally
 accept an acceptance object: mode (behavioral, invariant or review-only),
 bindings and optional baselineCommit/reviewOnlyReason. Mechanical bindings name
-configured acceptance runner IDs, checkIds, committed materials and optional
+configured acceptance runner IDs, checkIds (the checks this criterion needs;
+other runner output is ignored), committed materials and optional
 redCheckIds; tasks cannot supply commands. Creation freezes the baseline.
 Review-only example (mandatory repository policy commands still run):
 
@@ -232,7 +238,8 @@ Review-only example (mandatory repository policy commands still run):
 
 Pin a saved finding with task pin-finding --task <id> <report-digest:index>
 --expected-contract <hash> --criterion-file <path>. Revise/replan preserve the
-original goal and immutable existing baselines; obtain new verify and review.
+original goal and existing baselines unless revise --baseline moves them all.
+A revise that keeps the criteria keeps verification; every revise needs review.
 `,
     verify: `Usage: agent-ops verify [options]
 
@@ -308,9 +315,10 @@ voiding each other's verification and review. Run it from the main checkout.
                before Git runs; see agent-ops worktree list.
   finish <name>
                Once its task is complete, fast-forward the main checkout's
-               branch to the worktree's (after a clean rebase and
-               re-verification if the branch moved), record the task in
-               git notes, and remove the worktree. One finish runs at a time.
+               branch to the worktree's, record the task in git notes, and
+               remove the worktree. If the branch moved, it rebases the
+               worktree and stops: verify and review again with the printed
+               --base, then finish again. One finish runs at a time.
   commit       Stage every change in the current worktree and commit it with
                --message. Refuses the main checkout and a worktree another
                session owns, and needs no Git in the shell.

package/dist/packages/cli/src/codex-loop-process.js

@@ -1,6 +1,5 @@
 import { PROJECT_LOOP_EVENTS, resolveProjectLoopRoot, runProjectLoop } from "../../../runtime/src/hooks/codex-loop.js";
 import { officeEnabled, officeLoopPhaseHint } from "./office-entry.js";
-import { routeDebugPrompt } from "./debug-intake.js";
 const MAX_LOOP_INPUT_BYTES = 64 * 1024;
 function isLoopHarness(value) {
     return value === "claude" || value === "codex";
@@ -74,11 +73,6 @@ export async function runLoopProcess(argv, io, dependencies = {}) {
                 ? {}
                 : { telemetryMaxBytes: dependencies.telemetryMaxBytes })
         });
-        if (event === "UserPromptSubmit" && managedRoot !== null && result.exitCode === 0 && result.stdout === "" && result.stderr === "") {
-            const context = await routeDebugPrompt(managedRoot, input, harness).catch(error => `DEBUG intake unavailable: ${error instanceof Error ? error.message : "preserve current state"}`);
-            if (context !== null)
-                io.writeStdout(harness === "claude" ? JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: context } }) : context + "\n");
-        }
         if (result.stdout.length > 0) {
             io.writeStdout(result.stdout);
         }

package/dist/packages/cli/src/commands/advance.js

@@ -90,7 +90,8 @@ export async function runAdvanceCommand(options) {
         throw new AgentOpsError("ADVANCE_WORKTREE_MISSING", `No coordinator worktree for session ${options.sessionId}.`);
     }
     const savedProof = await readRunIntegrationProof(commonDir, record);
-    if (savedProof !== null && await git(deps, mainRoot, ["rev-parse", `${record.targetBranch}^{commit}`]) === savedProof.head) {
+    if (savedProof !== null && (await git(deps, mainRoot, ["rev-parse", `${record.targetBranch}^{commit}`]) === savedProof.head ||
+        (await deps.git(mainRoot, ["merge-base", "--is-ancestor", savedProof.head, record.targetBranch])).exitCode === 0)) {
         const finished = await finishWorktree(deps, { cwd: mainRoot, name, finalProof: { ...savedProof, recovery: true } });
         return okEnvelope("TASK_ADVANCED", { ...finished, text: "Recovered the sealed integration without moving the target again." });
     }

package/dist/packages/cli/src/commands/parallel.js

@@ -41,7 +41,7 @@ function addText(result) {
 function finishText(result) {
     const { record } = result;
     return [
-        `Merged ${record.branch} into ${record.targetBranch} at ${result.mergedHead}${result.rebased ? " after a clean rebase and re-verification" : ""}.`,
+        `Merged ${record.branch} into ${record.targetBranch} at ${result.mergedHead}.`,
         `Completed and recorded in git notes (refs/notes/agent-ops): ${result.taskIds.join(", ")}.`,
         `Removed ${record.path}.`,
         ...(result.receipt === undefined ? [] : [`Receipt: ${result.receipt}`]),

package/dist/packages/cli/src/commands/review.js

@@ -4,7 +4,7 @@ import { renderReviewResult } from "../../../../runtime/src/review/render.js";
 import { reviewReportResults } from "../../../../runtime/src/review/report.js";
 import { findPriorFailingFindings, findReviewAttestation, invalidateReviewAttestation, readReviewReportArtifact, reviewReportDigest, saveReviewAttestation, saveReviewReportArtifact } from "../../../../runtime/src/review/attestation.js";
 import { detectHostTarget, planReviewTargets, resolveReviewRole } from "../../../../runtime/src/review/roles.js";
-import { taskContractHash, treeContractHash, goalHash } from "../../../../runtime/src/task/contract.js";
+import { evidenceMatchesContract, taskContractHash, treeContractHash, goalHash } from "../../../../runtime/src/task/contract.js";
 import { acceptanceCoverage, coverageDigest } from "../../../../runtime/src/verify/acceptance-coverage.js";
 import { resolveGitCommit } from "../../../../runtime/src/verify/change-surface.js";
 import { sha256 } from "../../../../runtime/src/fs/hash.js";
@@ -15,7 +15,6 @@ import { assertSafeSupportingPaths, isReviewerPolicyPath, resolveReviewScope, re
 import { calculateSourceFingerprint } from "../../../../runtime/src/verify/source-fingerprint.js";
 import { calculateConfigHash, isPassingVerificationEvidence } from "../../../../runtime/src/verify/evidence.js";
 import { validateEvidence } from "../../../../runtime/src/schema/validate.js";
-import { loadDebugProof, debugProofDigest } from "../../../../runtime/src/task/debug-state.js";
 import { logSurfaceResidualRisks, runSurfaceGate } from "../../../../runtime/src/surface/discovery.js";
 import { escapeReviewData } from "../../../../runtime/src/escape/link.js";
 import { logGateCatch } from "../../../../runtime/src/logging/local-log.js";
@@ -187,7 +186,7 @@ async function currentEvidence(options, context, criterionId, commandId, configH
             evidence.sourceFingerprint !== sourceFingerprint ||
             (context.records.some(r => r.task.id === (owner?.taskId ?? context.taskId) &&
                 (r.task.goal !== undefined || (r.task.contractRevision ?? 0) > 0 || r.task.criteria.some(c => c.acceptance !== undefined))) &&
-                evidence.taskContractHash !== taskContractHash(context.records.find(r => r.task.id === (owner?.taskId ?? context.taskId)).task))) {
+                !evidenceMatchesContract(evidence.taskContractHash, context.records.find(r => r.task.id === (owner?.taskId ?? context.taskId)).task))) {
             stale = true;
             continue;
         }
@@ -343,7 +342,7 @@ async function reviewEscapes(options, context, scope) {
         const origin = record.task.origin;
         if (origin === undefined)
             continue;
-        const base = record.debug?.baselineCommit ?? record.createdSourceCommit ?? (scope?.mode === "base" ? scope.resolvedBase : undefined);
+        const base = record.createdSourceCommit ?? (scope?.mode === "base" ? scope.resolvedBase : undefined);
         try {
             if (base === undefined)
                 throw new Error("no base");
@@ -770,7 +769,6 @@ export async function runReviewCommand(options) {
         }
         context.coverage = rows;
         context.binding = {
-            ...(context.records.every(r => r.task.debug === undefined) || options.root === undefined ? {} : { debugProofs: Object.fromEntries(await Promise.all(context.records.filter(r => r.task.debug !== undefined).map(async (r) => [r.task.id, debugProofDigest(await loadDebugProof(options.root, r.task.debug.rootTaskId))]))) }),
             taskContractHash: taskContractHash(context.records.find(r => r.task.id === context.taskId).task),
             taskContracts: Object.fromEntries(context.records.map(r => [r.task.id, taskContractHash(r.task)])),
             ...(context.treeTasks === undefined ? {} : { treeContractHash: treeContractHash(context.records.map(r => r.task)) }),
@@ -816,12 +814,13 @@ export async function runReviewCommand(options) {
                         contractArtifacts.push({ path: executionPath, digest: sha256(execution), content: execution });
                 }
             }
+            // Compact: indentation alone pushed a 494 KiB 0.10.2 manifest past the 512 KiB bound.
             const content = redactSecrets(JSON.stringify({ binding: context.binding, coverage: context.coverage,
                 executionPolicy: options.config,
+                ...(surfacePacket === undefined ? {} : { surface: surfacePacket }),
                 artifacts: contractArtifacts.map(({ path, digest }) => ({ path, digest })),
-                tasks: await Promise.all(context.records.map(async (r) => ({ task: r.task, revisions: r.revisions ?? [],
-                    ...(r.task.debug === undefined ? {} : { debugProof: await loadDebugProof(options.root, r.task.debug.rootTaskId) }) }))),
-                superseded: context.historyRecords ?? [] }, null, 2));
+                tasks: context.records.map(r => ({ task: r.task, revisions: r.revisions ?? [] })),
+                superseded: context.historyRecords ?? [] }));
             const digest = sha256(content);
             const path = ".agent-ops/tasks/review-contracts/" + digest + ".json";
             contractManifest = { path, digest, content };
@@ -924,9 +923,7 @@ export async function runReviewCommand(options) {
                     await options.tasks.treeContract(context.taskId) !== context.binding.treeContractHash) ||
                 (context !== undefined && options.tasks !== undefined &&
                     (await Promise.all(context.records.map(async (r) => taskContractHash((await options.tasks.status({ taskId: r.task.id })).task))))
-                        .some((hash, i) => hash !== taskContractHash(context.records[i].task))) ||
-                (context?.binding?.debugProofs !== undefined && options.root !== undefined &&
-                    (await Promise.all(context.records.filter(r => r.task.debug !== undefined).map(async (r) => debugProofDigest(await loadDebugProof(options.root, r.task.debug.rootTaskId)) !== context.binding.debugProofs[r.task.id]))).some(Boolean))) {
+                        .some((hash, i) => hash !== taskContractHash(context.records[i].task)))) {
                 const changed = await persistReviewEvidence(options, sourceChangedResult(result), sourceFingerprint, context);
                 return notRunEnvelope(changed);
             }

package/dist/packages/cli/src/commands/run.js

@@ -1,5 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { AgentOpsError, resolveContainedPath } from "../../../../runtime/src/fs/paths.js";
+import { describeRunRecovery } from "../../../../runtime/src/run/service.js";
 import { errorEnvelope, okEnvelope } from "../output.js";
 function dynamic(args) {
     return args;
@@ -19,13 +20,18 @@ function runIdOf(args) {
     return runId;
 }
 function textFor(action, state, message) {
+    const recovery = describeRunRecovery(state);
     const active = state.workers.filter((worker) => ["assigned", "starting", "running", "idle", "handing-off"].includes(worker.status)).length;
     return [
         message,
         `Status: ${state.status}`,
+        `Phase: ${recovery.phase}`,
+        `Cause: ${recovery.cause === null ? "none recorded" : recovery.cause.code + ": " + recovery.cause.detail}`,
+        `Sealed proof: ${recovery.sealedProof}; cleanup: ${recovery.cleanup}; resumable: ${recovery.resumable ? "yes, after reconciliation" : "no"}`,
+        `Remediation: ${recovery.remediation}`,
         `Host: ${state.host}`,
         `Workers: ${active}/${state.jobs}`,
-        `Budget: ${Math.max(0, state.budget.limitMs - state.budget.accumulatedMs)}ms remaining`,
+        state.budget.limitMs === null ? `Budget: unlimited; ${state.budget.accumulatedMs}ms active time recorded` : `Budget: ${Math.max(0, state.budget.limitMs - state.budget.accumulatedMs)}ms remaining (legacy; manual resume upgrades)`,
         `Usage: ${state.budget.usage.tokens ?? "unknown"} tokens; ${state.budget.usage.usd === null ? "unknown" : "$" + state.budget.usage.usd} cost (${state.budget.usage.completeness})`,
         action === "logs" ? "" : "Native goal completion is not final proof; verify, review, task state, and receipt are still required."
     ].filter((line) => line.length > 0).join("\n");
@@ -35,12 +41,15 @@ function data(action, result) {
         action,
         runId: result.state.runId,
         state: result.state,
+        recovery: describeRunRecovery(result.state),
         message: result.message,
         text: textFor(action, result.state, result.message)
     };
 }
 function stateData(action, state, message) {
-    return { action, runId: state.runId, state, message, text: textFor(action, state, message) };
+    const { events, goal: _goal, ...brief } = state;
+    return { action, runId: state.runId, state: { ...brief, eventCount: events.length }, recovery: describeRunRecovery(state), message,
+        text: textFor(action, state, message) };
 }
 async function goalFromArgs(args, root) {
     if (args.goal !== undefined && args.goalFile !== undefined)
@@ -99,7 +108,7 @@ export async function runRunCommand(options) {
             return okEnvelope("RUN_LOGS", { ...stateData(action, state, `Read ${events.length} event(s) for run ${runId}.`), events });
         }
         if (action === "resume")
-            return okEnvelope("RUN_RESUMED", data(action, await options.service.resume(runId)));
+            return okEnvelope("RUN_RESUMED", data(action, await options.service.resume(runId, options.args.retryApprovalIds)));
         if (action === "stop")
             return okEnvelope("RUN_STOP_REQUESTED", data(action, await options.service.stop(runId, options.args.answer ?? "user requested stop")));
         const questionId = options.args.questionId;