@kylecheng3146/agent-ops 0.10.0 → 0.10.2

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

@@ -960,7 +960,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 +971,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 +1003,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/cli.js

@@ -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, DEBUG budgets 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]
 
@@ -308,9 +317,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/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

@@ -816,12 +816,14 @@ 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));
+                superseded: context.historyRecords ?? [] }));
             const digest = sha256(content);
             const path = ".agent-ops/tasks/review-contracts/" + digest + ".json";
             contractManifest = { path, digest, content };

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,13 @@ 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) };
+    return { action, runId: state.runId, state, recovery: describeRunRecovery(state), message, text: textFor(action, state, message) };
 }
 async function goalFromArgs(args, root) {
     if (args.goal !== undefined && args.goalFile !== undefined)
@@ -99,7 +106,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;

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

@@ -9,7 +9,8 @@ import { mergeConfigLayers } from "../../../runtime/src/config/merge.js";
 import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { localStatePaths, readPrivateFile } from "../../../runtime/src/security/permissions.js";
 import { FileRunRepository } from "../../../runtime/src/run/service.js";
-import { readRunPolicy, runRuntimeHash } from "../../../runtime/src/run/policy.js";
+import { readRunPolicy, renewRunPolicy, runRuntimeHash } from "../../../runtime/src/run/policy.js";
+import { CLI_VERSION } from "./version.js";
 import { calculateTrustBinding, FileTrustStore } from "../../../runtime/src/security/trust.js";
 export const DEFAULT_CONFIG = {
     schemaVersion: 3,
@@ -83,6 +84,10 @@ export async function loadEffectiveConfig(root, scope, projectOverride) {
                     config: run.policy.config
                 }]);
     }
+    return await loadRepositoryConfig(root, scope, projectOverride);
+}
+/** Read the real config layers when checking renewal, without consulting the run overlay. */
+async function loadRepositoryConfig(root, scope, projectOverride) {
     const home = process.env.AGENT_OPS_HOME ?? homedir();
     const userPath = join(home, ".agent-ops", "config.json");
     const projectPath = join(scope === "user" ? root : projectConfigRoot(root), ".agent-ops", "config.json");
@@ -212,7 +217,7 @@ export async function repositoryTrust(root, config, cliVersion) {
     }
 }
 /** A run-private capability is usable only by its registered checkout or proof group. */
-export async function runPolicyContext(root) {
+export async function runPolicyContext(root, renew = false) {
     let common;
     try {
         common = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
@@ -250,10 +255,23 @@ export async function runPolicyContext(root) {
         throw new AgentOpsError("RUN_WORKER_STALE", "Run policy requires the current registered worker generation or proof process.");
     if (saved.status !== "active" || saved.disableRestart || saved.awaitingResume)
         throw new AgentOpsError("RUN_POLICY_DISABLED", "Run execution policy is inactive; explicit resume is required.");
-    const policy = await readRunPolicy(saved, await runRuntimeHash());
+    const state = renew ? await ensureRunPolicy(repository, saved) : saved;
+    const policy = await readRunPolicy(state, await runRuntimeHash());
     if (policy === null)
         return null;
-    return { repository, state: saved, policy, worker };
+    return { repository, state, policy, worker };
+}
+/** Only active execution paths call this; status, installation and recovery reads never renew. */
+export async function ensureRunPolicy(repository, state) {
+    if (state.policyBinding === undefined || Date.parse(state.policyBinding.expiresAt) > Date.now())
+        return state;
+    return await renewRunPolicy(repository, state.runId, { authority: async () => {
+            const config = (await loadRepositoryConfig(state.root, "project")).config;
+            const baseTrustBinding = await repositoryTrustBinding(state.root, config, CLI_VERSION);
+            const paths = localStatePaths(process.env.AGENT_OPS_HOME ?? homedir());
+            const trusted = (await new FileTrustStore(paths.trustStore, paths.anchorDirectory).status(baseTrustBinding)).status === "TRUSTED";
+            return { config, baseTrustBinding, trusted, runtimeHash: await runRuntimeHash() };
+        } });
 }
 export async function repositoryTrustBinding(root, config, cliVersion) {
     return await calculateTrustBinding({

package/dist/packages/cli/src/office-entry.js

@@ -5,7 +5,7 @@ import { rm } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { collectOfficeBuilding } from "../../../runtime/src/office/collect.js";
-import { claimOffice, createOfficeServer, ensureOffice, legacyOfficeHome, officeRecordPath, readLiveOffice, officeUrl, releaseOffice, userOfficeHome } from "../../../runtime/src/office/server.js";
+import { claimOffice, createOfficeServer, ensureOffice, legacyOfficeHome, officeRecordPath, readLiveOffice, readOfficeRecord, officeUrl, userOfficeHome } from "../../../runtime/src/office/server.js";
 import { registerOfficeRepo } from "../../../runtime/src/office/repos.js";
 import { recordOfficeSession, recordOfficeSessionPhase } from "../../../runtime/src/office/sessions.js";
 import { resolveCheckouts } from "../../../runtime/src/parallel/service.js";
@@ -254,7 +254,6 @@ export async function serveOffice(cwd, onUrl = () => { }, openBrowser) {
     }, 15_000);
     await idle;
     clearInterval(timer);
-    await releaseOffice(home, record);
     await office.close();
 }
 /** Reuse the user's live server or start one under launchd; null where launchd is unavailable. */
@@ -267,10 +266,13 @@ export async function ensureBackgroundOffice(cwd, launchd = new LaunchdControlle
     const live = await readLiveOffice(home);
     if (live !== null)
         return officeUrl(live);
+    let previousUrl = null;
     let started = false;
     const args = [entry, mainRoot];
     if (!launchd.supported) {
         const url = await ensureOffice(home, async () => {
+            const previous = await readOfficeRecord(home);
+            previousUrl = previous === null ? null : officeUrl(previous);
             started = true;
             await new Promise((resolve, reject) => {
                 const child = spawn(process.execPath, args, { cwd: mainRoot, detached: true, stdio: "ignore", windowsHide: true });
@@ -278,7 +280,7 @@ export async function ensureBackgroundOffice(cwd, launchd = new LaunchdControlle
                 child.once("spawn", () => { child.unref(); resolve(); });
             });
         });
-        if (started && openBrowser !== undefined)
+        if (started && url !== previousUrl && openBrowser !== undefined)
             void openBrowser(url).catch(() => undefined);
         return url;
     }
@@ -289,6 +291,8 @@ export async function ensureBackgroundOffice(cwd, launchd = new LaunchdControlle
         cwd: mainRoot, pathEnvironment: process.env.PATH
     });
     const url = await ensureOffice(home, async () => {
+        const previous = await readOfficeRecord(home);
+        previousUrl = previous === null ? null : officeUrl(previous);
         started = true;
         // The descriptor write anchors on this directory, so it must exist first.
         await ensurePrivateDirectory(privateDirectory, home.anchor);
@@ -297,7 +301,7 @@ export async function ensureBackgroundOffice(cwd, launchd = new LaunchdControlle
         await launchd.bootout(descriptor).catch(() => { });
         await launchd.bootstrap(descriptor);
     });
-    if (started && openBrowser !== undefined)
+    if (started && url !== previousUrl && openBrowser !== undefined)
         void openBrowser(url).catch(() => undefined);
     return url;
 }

package/dist/packages/cli/src/owned-run-step.js

@@ -4,13 +4,13 @@ import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { nativeProcessIdentity, NativeRunTransport } from "../../../runtime/src/run/transport.js";
 import { ClaudeGoalHost } from "../../../runtime/src/run/hosts/claude.js";
 import { CodexGoalHost } from "../../../runtime/src/run/hosts/codex.js";
-import { activeWallTimeMs } from "../../../runtime/src/run/scheduler.js";
+import { remainingRunTimeMs } from "../../../runtime/src/run/scheduler.js";
 import { runPolicyContext } from "./context.js";
 /** Native-issued proof commands use the same dormant group as final evidence. */
 export async function runOwnedLocalProof(argv) {
     if (!["verify", "review", "batch"].includes(argv[0] ?? "") || argv.includes("--help") || process.env.AGENT_OPS_RUN_PROOF_PID !== undefined)
         return null;
-    const context = await runPolicyContext(process.cwd());
+    const context = await runPolicyContext(process.cwd(), true);
     if (context === null)
         return null;
     const { repository, state, worker } = context;
@@ -22,7 +22,7 @@ export async function runOwnedLocalProof(argv) {
         if (existing.processAlive)
             throw new AgentOpsError("RUN_WORKER_PROOF_ACTIVE", "A registered proof command is already running for this worker.");
     }
-    const remaining = state.budget.limitMs - activeWallTimeMs(state.budget.activeIntervals, Date.now());
+    const remaining = remainingRunTimeMs(state);
     if (remaining <= 0)
         throw new AgentOpsError("RUN_BUDGET_EXHAUSTED", "No active run time remains for local proof.");
     const cli = fileURLToPath(new URL("./bin.js", import.meta.url));
@@ -34,7 +34,7 @@ export async function runOwnedLocalProof(argv) {
             process.kill(process.platform === "win32" ? child.pid : -child.pid, "SIGKILL");
         }
         catch { } };
-    const deadline = setTimeout(kill, remaining);
+    const deadline = Number.isFinite(remaining) ? setTimeout(kill, remaining) : undefined;
     try {
         const identity = child.pid === undefined ? null : await nativeProcessIdentity(child.pid);
         if (identity === null)

package/dist/packages/cli/src/parallel-deps.js

@@ -9,7 +9,6 @@ import { FileTrustStore } from "../../../runtime/src/security/trust.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
 import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
-import { registeredRunProofRunner } from "../../../runtime/src/verify/spawn.js";
 import { loadEffectiveConfig, repositoryTrust, runPolicyContext, repositoryTrustBinding } from "./context.js";
 import { CLI_VERSION } from "./version.js";
 // Shared by the CLI and the hook entry point: Claude Code runs hooks through
@@ -84,7 +83,6 @@ export function worktreeDependencies() {
                 ...(noChangePaths === undefined ? {} : { noChangePaths }),
                 loadConfig: async () => (await loadEffectiveConfig(root, "project")).config
             } }),
-        processRunner: registeredRunProofRunner(),
         runSetup: async (cwd, step) => await new Promise((resolve) => {
             execFile(step.command, [...step.args], {
                 cwd,

package/dist/packages/cli/src/run-deps.js

@@ -18,9 +18,9 @@ import { NativeRunTransport } from "../../../runtime/src/run/transport.js";
 import { ClaudeGoalHost } from "../../../runtime/src/run/hosts/claude.js";
 import { CodexGoalHost } from "../../../runtime/src/run/hosts/codex.js";
 import { RunSupervisor } from "../../../runtime/src/run/supervisor.js";
-import { activeWallTimeMs } from "../../../runtime/src/run/scheduler.js";
+import { activeWallTimeMs, remainingRunTimeMs } from "../../../runtime/src/run/scheduler.js";
 import { bindRunPolicy, readRunPolicy, runRuntimeHash, runPolicyAssessment } from "../../../runtime/src/run/policy.js";
-import { repositoryTrustBinding } from "./context.js";
+import { repositoryTrustBinding, ensureRunPolicy } from "./context.js";
 import { CLI_VERSION } from "./version.js";
 import { calculateConfigHash, canonicalJson } from "../../../runtime/src/config/hash.js";
 import { discoverPendingPolicyTransition, renewBoundPolicyTransition, currentPolicyArtifact } from "../../../runtime/src/run/policy-transition.js";
@@ -30,6 +30,7 @@ import { RunControlService } from "../../../runtime/src/run/controls.js";
 import { recordRunPhase } from "../../../runtime/src/run/phase.js";
 /** Worktree construction happens before a native lease exists; it must never write global trust. */
 export async function runWorktreeDependencies(deps, state) {
+    state = await ensureRunPolicy(new FileRunRepository(join(state.commonDir, "agent-ops/runs"), state.commonDir), state);
     const policy = await readRunPolicy(state, await runRuntimeHash());
     if (policy === null || (await trustStore().status(policy.baseTrustBinding)).status !== "TRUSTED")
         throw new AgentOpsError("RUN_REPO_UNTRUSTED", "Run worktree setup requires the original trusted repository and current scoped policy.");
@@ -40,7 +41,9 @@ export async function runWorktreeDependencies(deps, state) {
             if (index < 0)
                 throw new AgentOpsError("RUN_SETUP_UNAUTHORIZED", "Setup must select an exact fixed policy capability.");
             const repository = new FileRunRepository(join(state.commonDir, "agent-ops/runs"), state.commonDir);
-            const current = (await repository.read(state.runId));
+            const current = await ensureRunPolicy(repository, (await repository.read(state.runId)));
+            if (current.policyBinding?.configHash !== state.policyBinding.configHash)
+                throw new AgentOpsError("RUN_SETUP_STALE", "Policy capability changed after setup was selected.");
             const coordinator = current.workers.find(w => w.workerId === current.coordinatorId);
             const command = canonicalJson(step), resource = canonicalJson({ checkout: root, capabilityId: "setup:" + index });
             const approved = await runPolicyAssessment(current, policy, "setup:" + index);
@@ -49,11 +52,11 @@ export async function runWorktreeDependencies(deps, state) {
                 command, resource, commandDigest: sha256(command), resourceDigest: sha256(resource), reason: approved?.reason ?? "The original user trust authorizes this fixed repository setup capability in an isolated checkout.",
                 result: "auto-approved", source: approved === null ? "repo-trust" : "coordinator-policy-review", policyArtifactDigest: current.policyBinding.artifactDigest,
                 policyConfigHash: current.policyBinding.configHash, runtimeHash: current.policyBinding.runtimeHash, expiresAt: current.policyBinding.expiresAt });
-            const remaining = current.budget.limitMs - activeWallTimeMs(current.budget.activeIntervals, Date.now());
+            const remaining = remainingRunTimeMs(current);
             if (remaining <= 0)
                 throw new AgentOpsError("RUN_BUDGET_EXHAUSTED", "No active time remains for setup.");
             const child = spawn(process.execPath, [fileURLToPath(new URL("./run-step-entry.js", import.meta.url)),
-                fileURLToPath(new URL("./run-setup-entry.js", import.meta.url)), state.commonDir, state.runId, root, String(index), state.policyBinding.artifactDigest], { cwd: root, env: process.env, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
+                fileURLToPath(new URL("./run-setup-entry.js", import.meta.url)), state.commonDir, state.runId, root, String(index), current.policyBinding.artifactDigest], { cwd: root, env: process.env, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
             let output = "";
             const completion = new Promise((resolve, reject) => { child.once("error", reject); child.once("close", resolve); });
             const kill = () => { if (child.pid !== undefined)
@@ -70,7 +73,7 @@ export async function runWorktreeDependencies(deps, state) {
                 if (identity === null)
                     throw new AgentOpsError("RUN_PROCESS_IDENTITY_REQUIRED", "Cannot register setup process identity.");
                 await repository.mutate(state.runId, saved => {
-                    if (saved.status !== "active" || saved.disableRestart || saved.proofProcess != null || saved.policyBinding?.artifactDigest !== state.policyBinding.artifactDigest)
+                    if (saved.status !== "active" || saved.disableRestart || saved.proofProcess != null || saved.policyBinding?.artifactDigest !== current.policyBinding.artifactDigest)
                         throw new AgentOpsError("RUN_SETUP_STALE", "Stop or another proof process raced setup registration.");
                     return { ...saved, proofProcess: { processId: child.pid, processIdentity: identity } };
                 });
@@ -206,7 +209,7 @@ export async function productionRunContext(cwd, options = {}) {
             throw cause;
         }
     };
-    const resume = async (runId) => {
+    const resume = async (runId, retryApprovalIds = [], upgradeBudget = true) => {
         const before = await service.status(runId);
         const runtimeHash = await runRuntimeHash();
         const policy = await readRunPolicy(before, before.policyBinding?.runtimeHash ?? runtimeHash, Date.now(), true);
@@ -233,7 +236,7 @@ export async function productionRunContext(cwd, options = {}) {
                 if (exists === null || (await collectChangeSurface(gitRunner(worker.worktree))).paths.length > 0)
                     throw new AgentOpsError("RUN_RECOVERY_DIRTY", "Commit or preserve every writer checkout before explicit resume.");
             }
-        const result = await service.resume(runId);
+        const result = await service.resume(runId, retryApprovalIds, upgradeBudget);
         try {
             if (pending !== null)
                 await renewPendingRunPolicy(repository, runId, pending);
@@ -308,7 +311,7 @@ export async function productionRunContext(cwd, options = {}) {
         await writePrivateFile(join(state.commonDir, "agent-ops", "runs", state.runId, "answers", sha256(questionId) + ".json"), JSON.stringify({ questionId, answer: answer.trim() }), state.commonDir);
         const result = await service.respond(runId, questionId, answer);
         try {
-            const resumed = await resume(runId);
+            const resumed = await resume(runId, [], false);
             return { ...result, state: resumed.state };
         }
         catch (cause) {