@kylecheng3146/agent-ops 0.11.0 → 0.11.2

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

@@ -0,0 +1,56 @@
+import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
+import { processFollowup, reconcileFollowupRepairs } from "../../../runtime/src/followup/process.js";
+import { isFollowupAssessmentCurrent } from "../../../runtime/src/review/followup.js";
+import { resolveReviewRole } from "../../../runtime/src/review/roles.js";
+import { worktreeDependencies, gitRunner } from "./parallel-deps.js";
+import { productionRunContext } from "./run-deps.js";
+import { resolveCheckouts } from "../../../runtime/src/parallel/service.js";
+import { reconcileFollowups } from "../../../runtime/src/followup/intake.js";
+export async function followupRepositoryContext(cwd) {
+    const deps = worktreeDependencies(), checkouts = await resolveCheckouts(deps, cwd);
+    return { git: deps.git, mainRoot: checkouts.mainRoot, commonDir: checkouts.commonDir,
+        config: await deps.loadConfig(checkouts.mainRoot), loadConfig: async () => await deps.loadConfig(checkouts.mainRoot) };
+}
+/** Ordinary CLI reconciliation is advisory and never launches a provider or repair. */
+export async function reconcileRepositoryFollowups(cwd) {
+    try {
+        return await reconcileFollowups(await followupRepositoryContext(cwd));
+    }
+    catch (error) {
+        const code = error instanceof AgentOpsError && /^[A-Z0-9_]{1,80}$/u.test(error.code) ? error.code : "FOLLOWUP_COLLECTION_FAILED";
+        return { added: 0, candidates: 0, observations: 0,
+            warnings: code === "WORKTREE_NOT_GIT" ? [] : [`followup: ${code}; retry with followup import.`] };
+    }
+}
+/** Uses the ordinary production authority, including its exact native/platform/trust refusals. */
+export async function productionFollowupContext(cwd) {
+    const deps = worktreeDependencies(), checkouts = await resolveCheckouts(deps, cwd);
+    const branch = await deps.git(checkouts.currentRoot, ["symbolic-ref", "--short", "HEAD"]);
+    if (branch.exitCode !== 0)
+        throw new AgentOpsError("RUN_TARGET_REQUIRED", "Followup processing requires a checked-out target branch.");
+    const loadConfig = async () => await deps.loadConfig(checkouts.currentRoot);
+    const assessmentOptions = async (itemId, reviewOnlyReason) => {
+        const config = await loadConfig(), role = resolveReviewRole("independent-review", config.reviewRoles ?? []);
+        return {
+            root: checkouts.currentRoot, commonDir: checkouts.commonDir, itemId, targetBranch: branch.stdout.trim(),
+            gitRunner: gitRunner(checkouts.currentRoot), loadConfig,
+            review: { targets: role?.targets ?? [], ...(role?.timeoutMs === undefined ? {} : { timeoutMs: role.timeoutMs }) },
+            ...(reviewOnlyReason === undefined ? {} : { reviewOnlyReason })
+        };
+    };
+    return { ...checkouts,
+        assessmentOptions,
+        process: async (itemId, host, reviewOnlyReason) => {
+            const options = await assessmentOptions(itemId, reviewOnlyReason);
+            return await processFollowup({ ...options, host, start: async (input, proof) => {
+                    const run = await productionRunContext(cwd, { beforeStart: async () => {
+                            if (!await isFollowupAssessmentCurrent(options, proof))
+                                throw new AgentOpsError("FOLLOWUP_SOURCE_CHANGED", "The finding, target, source or config changed before repair startup.");
+                        } });
+                    return (await run.service.start({ ...input, root: run.mainRoot, commonDir: run.commonDir,
+                        targetBranch: run.targetBranch, ownerSessionId: run.ownerSessionId })).state;
+                } });
+        },
+        reconcile: async () => await reconcileFollowupRepairs({ git: deps.git, mainRoot: checkouts.mainRoot,
+            commonDir: checkouts.commonDir, config: await loadConfig(), loadConfig }) };
+}

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

@@ -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 = remainingRunTimeMs(state);
+    const remaining = argv[0] === "review" && argv.includes("--criteria") ? Infinity : 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));

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

@@ -7,9 +7,9 @@ import { fileURLToPath } from "node:url";
 import { setTimeout as delay } from "node:timers/promises";
 import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { sha256 } from "../../../runtime/src/fs/hash.js";
-import { resolveCheckouts, sessionWorktreeName } from "../../../runtime/src/parallel/service.js";
+import { resolveCheckouts, readWorktreeRecord, sessionWorktreeName } from "../../../runtime/src/parallel/service.js";
 import { createLaunchdDescriptor, LaunchdController, readBootIdentity, readGuiLoginIdentity } from "../../../runtime/src/run/macOS.js";
-import { FileRunRepository, RunService } from "../../../runtime/src/run/service.js";
+import { FileRunRepository, RunService, validateDeliveryRetry } from "../../../runtime/src/run/service.js";
 import { readPrivateFile, writePrivateFile } from "../../../runtime/src/security/permissions.js";
 import { collectChangeSurface } from "../../../runtime/src/verify/change-surface.js";
 import { worktreeDependencies, gitRunner, trustStore } from "./parallel-deps.js";
@@ -182,8 +182,10 @@ export async function productionRunContext(cwd, options = {}) {
         if (await deps.trust.status(checkouts.mainRoot, config) !== "TRUSTED")
             throw new AgentOpsError("RUN_REPO_UNTRUSTED", "The run requires current repository verifier trust.");
         const ownerSessionId = randomUUID();
+        const bootIdentity = await readBootIdentity(), loginDomain = await readGuiLoginIdentity();
+        await options.beforeStart?.();
         const result = await service.start({ ...input, root: checkouts.mainRoot, commonDir: checkouts.commonDir,
-            targetBranch: target.stdout.trim(), ownerSessionId, bootIdentity: await readBootIdentity(), loginDomain: await readGuiLoginIdentity() });
+            targetBranch: target.stdout.trim(), ownerSessionId, bootIdentity, loginDomain });
         try {
             await bindRunPolicy(repository, result.state.runId, { config,
                 baseTrustBinding: await repositoryTrustBinding(checkouts.mainRoot, config, CLI_VERSION), runtimeHash: await runRuntimeHash() });
@@ -209,8 +211,9 @@ export async function productionRunContext(cwd, options = {}) {
             throw cause;
         }
     };
-    const resume = async (runId, retryApprovalIds = [], upgradeBudget = true) => {
+    const resume = async (runId, retryApprovalIds = [], upgradeBudget = true, retryDeliveryTaskId) => {
         const before = await service.status(runId);
+        const retry = retryDeliveryTaskId === undefined ? null : validateDeliveryRetry(before, retryDeliveryTaskId);
         const runtimeHash = await runRuntimeHash();
         const policy = await readRunPolicy(before, before.policyBinding?.runtimeHash ?? runtimeHash, Date.now(), true);
         if (policy !== null && await deps.trust.status(checkouts.mainRoot, policy.baseConfig) !== "TRUSTED")
@@ -236,7 +239,15 @@ 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, retryApprovalIds, upgradeBudget);
+        if (retry !== null) {
+            const record = retry.worktree === null ? null : await readWorktreeRecord(retry.worktree);
+            const head = retry.worktree === null ? null : await deps.git(retry.worktree, ["rev-parse", "HEAD"]);
+            if (record === null || record.runId !== runId || record.workerId !== retry.workerId ||
+                record.ownerSessionId !== retry.ownerSessionId || record.workerGeneration !== retry.generation ||
+                head?.exitCode !== 0 || head.stdout.trim() !== retry.stopIntent.sourceCommit)
+                throw new AgentOpsError("RUN_DELIVERY_RETRY_INVALID", "Interrupted checkout ownership or source changed; preserve it and reconcile before retrying.");
+        }
+        const result = await service.resume(runId, retryApprovalIds, upgradeBudget, retryDeliveryTaskId, retry?.lastFailure?.id);
         try {
             if (pending !== null)
                 await renewPendingRunPolicy(repository, runId, pending);