@kylecheng3146/agent-ops 0.11.0 → 0.11.2

package/README.md

@@ -12,6 +12,19 @@ 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.
 
+## Criteria advisory before implementation
+
+Every new task, including DEBUG and native run parent/child tasks, waits for one
+independent advisory review of its goal, criteria and assigned surface before
+implementation. Read the suggestions, decide which to adopt, and record reasons
+through `task revise`. Revisions do not automatically re-review.
+
+The advisory has no time/token budget; explicit cancellation stops work. Genuine
+execution errors report NOT_RUN and allow work. Detailed reports remain private;
+`task status` shows their snapshot and whether they are historical. Explicitly
+rerun with `agent-ops review --criteria --task <id> --rerun --yes`.
+Final verification, two-round review and finish remain required.
+
 ## Executable acceptance and native goal runs (0.6.0)
 
 Criteria can use `behavioral`, `invariant` or `review-only` acceptance contracts.
@@ -508,6 +521,12 @@ as its first and only invocation, with `--output` instead of a shell redirect.
 
 See [Configuration](docs/en/guides/configuration.md) for the full contract.
 
+Retained nonblocking review findings and residual risks are collected privately
+across linked worktrees. Use `agent-ops followup list` / `show`, metadata-only
+`import`, reasoned `accept` / `defer`, and explicit `process <followup-id> --host
+codex` for current-source revalidation and bounded repair. Observations need
+`clarify`; resolution needs finding-specific proof. See [followup guidance](docs/en/guides/task-debug.md#retained-review-followups).
+
 ## Project principles
 
 - Define verifiable success before making changes.

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

@@ -14,7 +14,8 @@ export const COMMAND_NAMES = [
     "worktree",
     "run",
     "office",
-    "escapes"
+    "escapes",
+    "followup"
 ];
 const COMMAND_SET = new Set(COMMAND_NAMES);
 const SCOPES = new Set(["project", "user"]);
@@ -64,6 +65,8 @@ function parseHookTarget(option, value) {
     return { harness: harness, surfaceId };
 }
 export function parseArgs(argv) {
+    if (argv[0] === "followup")
+        return parseFollowupArgs(argv.slice(1));
     if (argv[0] === "run")
         return parseRunArgs(argv.slice(1));
     if (argv[0] === "task" && argv[1] === "debug")
@@ -113,6 +116,7 @@ export function parseArgs(argv) {
     let json = false;
     let yes = false;
     let rerun = false;
+    let criteriaReview = false;
     let tree = false;
     let helpSeen = false;
     let versionSeen = false;
@@ -461,6 +465,11 @@ export function parseArgs(argv) {
                 index += 1;
                 break;
             }
+            case "--criteria":
+                if (criteriaReview)
+                    throw new CliArgumentError("CLI_DUPLICATE_OPTION", "--criteria may appear only once.");
+                criteriaReview = true;
+                break;
             case "--rerun":
                 if (rerun) {
                     duplicate(token);
@@ -687,6 +696,8 @@ export function parseArgs(argv) {
     if (worktree !== undefined && command !== "init" && command !== "update") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--worktree may be used only with init or update.");
     }
+    if (criteriaReview && (command !== "review" || action !== undefined || tree || base !== undefined || output !== undefined))
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--criteria requires review --task <id> --yes; omit show, tree, base and output.");
     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.");
@@ -786,7 +797,7 @@ export function parseArgs(argv) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--intent may be used only with task create.");
     }
     if (command === "review" && action !== "show" && !yes) {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Review requires --yes to authorize both reviewer sessions.");
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", criteriaReview ? "Criteria advisory requires --yes to authorize one reviewer session." : "Review requires --yes to authorize both reviewer sessions.");
     }
     if (command === "review" && harness !== undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Complete review uses the configured reviewer pair; omit --harness.");
@@ -872,6 +883,7 @@ export function parseArgs(argv) {
         ...(taskGoal === undefined ? {} : { goal: taskGoal }),
         ...(debug ? { debug: true } : {}),
         ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
+        ...(criteriaReview ? { criteriaReview: true } : {}),
         ...(completionGate === undefined ? {} : { completionGate }),
         ...(office === undefined ? {} : { office }),
         ...(autoRun === undefined ? {} : { autoRun }),
@@ -936,10 +948,15 @@ function parseRunArgs(argv) {
             args.wait = true;
             continue;
         }
-        if (!["--host", "--goal-file", "--time-budget", "--jobs", "--question-id", "--answer", "--answer-file", "--retry-approval"].includes(token))
+        if (!["--host", "--goal-file", "--time-budget", "--jobs", "--question-id", "--answer", "--answer-file", "--retry-approval", "--retry-delivery"].includes(token))
             throw new CliArgumentError("CLI_UNKNOWN_OPTION", `Unknown run option: ${token}`, token);
         const value = readOptionValue(argv, i++, token);
         switch (token) {
+            case "--retry-delivery":
+                if (!/^task-[a-z0-9-]{1,128}$/u.test(value))
+                    invalidValue(token, value);
+                args.retryDeliveryTaskId = value;
+                break;
             case "--retry-approval":
                 if (!/^auth-[a-f0-9]{64}$/u.test(value) || args.retryApprovalIds?.includes(value))
                     invalidValue(token, value);
@@ -974,6 +991,8 @@ function parseRunArgs(argv) {
     }
     if (args.retryApprovalIds !== undefined && action !== "resume")
         throw new CliArgumentError("CLI_INVALID_OPTION", "--retry-approval requires run resume.");
+    if (args.retryDeliveryTaskId !== undefined && (action !== "resume" || args.retryApprovalIds !== undefined))
+        throw new CliArgumentError("CLI_INVALID_OPTION", "--retry-delivery requires run resume without --retry-approval.");
     if (action === "start") {
         args.goal = positional;
         if ((args.goal === undefined) === (args.goalFile === undefined))
@@ -998,3 +1017,59 @@ function parseRunArgs(argv) {
     }
     return args;
 }
+function parseFollowupArgs(argv) {
+    const args = { command: "followup", profiles: [], dryRun: false, json: false, yes: false, rerun: false };
+    if (argv.includes("--help") || argv.includes("-h"))
+        return { ...args, command: "help", helpTopic: "followup", json: argv.includes("--json") };
+    const actions = ["list", "show", "import", "sync", "clarify", "accept", "defer", "reopen", "process"];
+    const action = argv[0] === undefined || argv[0].startsWith("-") ? "list" : argv[0];
+    if (!actions.includes(action))
+        invalidValue("followup action", action);
+    args.action = action;
+    const seen = new Set();
+    for (let i = argv[0] === action ? 1 : 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (!token.startsWith("-")) {
+            if (args.followupId !== undefined)
+                throw new CliArgumentError("CLI_UNEXPECTED_ARGUMENT", "Select exactly one followup identity.");
+            if (!/^followup-[a-f0-9]{64}$/u.test(token))
+                invalidValue("followup identity", token);
+            args.followupId = token;
+            continue;
+        }
+        if (seen.has(token))
+            duplicate(token);
+        seen.add(token);
+        if (token === "--json") {
+            args.json = true;
+            continue;
+        }
+        if (!["--reason", "--finding-file", "--host", "--review-only-reason"].includes(token))
+            throw new CliArgumentError("CLI_UNKNOWN_OPTION", `Unknown followup option: ${token}`, token);
+        const value = readOptionValue(argv, i++, token);
+        if (value.trim() === "" || value.includes("\0"))
+            invalidValue(token, value);
+        if (token === "--reason")
+            args.reason = value;
+        if (token === "--finding-file")
+            args.findingFile = value;
+        if (token === "--review-only-reason")
+            args.reviewOnlyReason = value;
+        if (token === "--host") {
+            if (value !== "claude" && value !== "codex")
+                invalidValue(token, value);
+            args.host = value;
+        }
+    }
+    const selectsItem = !["list", "import", "sync"].includes(action);
+    if (selectsItem !== (args.followupId !== undefined))
+        throw new CliArgumentError("CLI_MISSING_VALUE", "This action requires exactly one followup identity; list/import/sync take none.");
+    if ((args.reason !== undefined && !["accept", "defer", "reopen", "clarify"].includes(action)) ||
+        (args.findingFile !== undefined && action !== "clarify") ||
+        ((args.host !== undefined || args.reviewOnlyReason !== undefined) && action !== "process"))
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Option does not apply to this followup action.");
+    if ((["accept", "defer", "clarify"].includes(action) && args.reason === undefined) ||
+        (action === "clarify" && args.findingFile === undefined) || (action === "process" && args.host === undefined))
+        throw new CliArgumentError("CLI_MISSING_VALUE", "Accept/defer/clarify need --reason; clarify needs --finding-file; process needs --host.");
+    return args;
+}

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

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
+import { reviewCreatedCriteria, criteriaReviewStatus } from "./criteria-review.js";
+import { renderCriteriaReview } from "../../../runtime/src/review/criteria.js";
 import { advancePhaseObserver, productionRunContext } from "./run-deps.js";
 import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { recordRunVerification } from "../../../runtime/src/run/verification.js";
 import { runOwnedLocalProof } from "./owned-run-step.js";
 import { runRunCommand } from "./commands/run.js";
+import { runFollowupCommand } from "./commands/followup.js";
+import { reconcileRepositoryFollowups } from "./followup-deps.js";
 import { runOfficeCommand } from "./commands/office.js";
 import { ensureBackgroundOffice, observeOfficeSession, officePhaseReporter, openOfficeBrowser, serveOffice } from "./office-entry.js";
 import { readFile, readdir, stat } from "node:fs/promises";
@@ -257,8 +261,13 @@ else {
                 const root = args.scope === "user"
                     ? process.env.AGENT_OPS_HOME ?? homedir()
                     : process.cwd();
+                if (args.scope !== "user" && !["init", "update", "uninstall", "followup", "escapes", "office"].includes(args.command)) {
+                    const collected = await reconcileRepositoryFollowups(root);
+                    for (const warning of collected.warnings)
+                        process.stderr.write(`Warning: ${warning}\n`);
+                }
                 // 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") {
+                if ((args.command === "verify" || (args.command === "review" && args.action !== "show" && !args.criteriaReview)) && 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)
@@ -277,6 +286,8 @@ else {
                     const context = await productionRunContext(root);
                     return await runRunCommand({ args, ...context, root: context.mainRoot, office: async () => await ensureBackgroundOffice(root, undefined, openOfficeBrowser) });
                 }
+                if (args.command === "followup")
+                    return await runFollowupCommand({ args, cwd: root });
                 if (args.command === "escapes")
                     return await runEscapesCommand({ root });
                 if (args.command === "office") {
@@ -507,6 +518,8 @@ else {
                     return await runTaskCommand({
                         args,
                         service: taskService,
+                        onTaskCreated: async (record, createdRoot) => await reviewCreatedCriteria(createdRoot ?? root, record.task),
+                        criteriaStatus: async (record) => await criteriaReviewStatus(root, record.task),
                         ...(policyConfigHash === undefined ? {} : { policyConfigHash }),
                         ...(sessionId === undefined ? {} : { sessionId }),
                         ...(fromMain
@@ -527,6 +540,11 @@ else {
                             : {})
                     });
                 }
+                if (args.command === "review" && args.criteriaReview) {
+                    const record = await taskService.status({ taskId: args.taskId });
+                    const criteriaReview = await reviewCreatedCriteria(root, record.task, args.rerun);
+                    return { status: "ok", code: "CRITERIA_REVIEW_ADVISORY", data: { criteriaReview, text: renderCriteriaReview(criteriaReview) }, errors: [] };
+                }
                 const probeTarget = async (target, budget) => await probeReviewTargetDetailed(target, {
                     cwd: root,
                     deep: true,

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

@@ -31,6 +31,7 @@ Commands:
   review     Run an independent review or show recorded reports
   run        Start or control a supervised Claude/Codex native goal
   office     Open the local pixel office (Preview; opt-in)
+  followup   Collect and process retained review findings and risk observations
   escapes    Report escaped bugs, gate catches and learned rules (read-only)
   batch      Verify and review a parent task's subtasks together
   allow-stop Grant one fingerprint-bound completion-gate Stop permit (requires --session)
@@ -59,6 +60,7 @@ Options:
   --width <n>                         Batch only: reviews allowed at once (default 2)
   --target-version <version>          Update target version (offline-capable)
   --title <text>
+  --criteria                          Review only: one pre-edit advisory, no time budget
   --criterion <json>                    Repeatable
   --evidence <criterion-id=reference>   Repeatable
   --session <id>
@@ -76,6 +78,30 @@ Options:
  * rejected.
  */
 export const COMMAND_HELP_TEXT = {
+    followup: `Usage: agent-ops followup [list] [--json]
+       agent-ops followup <show|reopen> <followup-id> [--json]
+       agent-ops followup <import|sync> [--json]
+       agent-ops followup <accept|defer> <followup-id> --reason <text> [--json]
+       agent-ops followup clarify <followup-id> --finding-file <json> --reason <text> [--json]
+       agent-ops followup process <followup-id> --host <claude|codex> [--review-only-reason <text>] [--json]
+
+Receipt collection and history import are metadata-only: no model calls or repairs.
+State is private under the Git common directory, shared by linked worktrees.
+Text observations require a concrete nonblocking ReviewFinding JSON clarification
+(severity, blocking=false, title, details, locations, evidence, recommendation,
+criterionIds). Accept/defer require a reason; neither resolves the finding.
+Reopen retains history. Process again to revalidate a selected candidate.
+Process authorizes independent current-source assessment and a new bounded native
+repair only when conclusively PRESENT. UNKNOWN stays unresolved. Native start
+refusals retain the item and exact reason; macOS, clean main, checked-out target,
+trust, run policy and native controls still apply. Run through the trusted outer
+host as: env -u CODEX_SANDBOX_NETWORK_DISABLED agent-ops followup process ...
+ABSENT closure requires an explicit justified review-only contract and two fresh
+reviews. Reproducible bugs require corresponding behavioral red-to-green proof.
+Closure records the exact commit and finding-specific evidence; generic PASS,
+changed paths, completed run status, acceptance and deferral cannot resolve.
+Collection warnings are advisory and retryable with followup import.
+`,
     escapes: `Usage: agent-ops escapes [--json]
 
 Read-only Escape Loop report: misses per gate from the tracked
@@ -102,6 +128,7 @@ The URL carries an access token; do not share it.
        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 resume <run-id> --retry-delivery <task-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.
@@ -110,6 +137,9 @@ 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.
+--retry-delivery requeues one stopped child blocked by interrupted handoff proof.
+Inspect and repair the harness cause first. History is retained; fresh native
+generation, verification and delivery are required. It grants no command 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
@@ -252,11 +282,14 @@ Options:
   --json
 `,
     review: `Usage: agent-ops review --task <id> --yes [options]
+       agent-ops review --criteria --task <id> --yes [--rerun]
        agent-ops review show --task <id> [--json]
 
 Run the complete task-bound review: one necessary reviewer followed by one
 fresh adversarial reviewer from the configured pair. Show reads recorded
 reports without running a reviewer, including from the main checkout.
+Criteria mode runs/reads one pre-edit advisory, with no time/token budget;
+only --rerun starts another attempt. It never replaces final proof.
 
 Options:
   --task <id>          Required task whose original criteria are reviewed

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

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { resolve } from "node:path";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { finishWorktree } from "../../../../runtime/src/parallel/finish.js";
+import { followupFinishText } from "./parallel.js";
 import { integrateSessionChildren } from "../../../../runtime/src/parallel/integrate.js";
 import { readWorktreeRecord, resolveCheckouts, sessionWorktreeName, worktreePath } from "../../../../runtime/src/parallel/service.js";
 import { resolveReviewScope } from "../../../../runtime/src/review/scope.js";
@@ -93,7 +94,7 @@ export async function runAdvanceCommand(options) {
     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." });
+        return okEnvelope("TASK_ADVANCED", { ...finished, text: `Recovered the sealed integration without moving the target again.\n${followupFinishText(finished)}${finished.warnings.join("\n")}` });
     }
     if (savedProof !== null && await git(deps, mainRoot, ["rev-parse", `${record.targetBranch}^{commit}`]) !== savedProof.target)
         await abandonPreparedRunIntegration(commonDir, record, deps.git);
@@ -176,7 +177,7 @@ export async function runAdvanceCommand(options) {
                 reviewMode,
                 sourceFingerprint,
                 ...finished,
-                text: `Final candidate ${head} passed all task verifiers and ${reviewMode} review, then finished into ${record.targetBranch}. Receipt: ${finished.receipt}.\n${highlights}Full reports: agent-ops review show --task ${parent.task.id}`
+                text: `Final candidate ${head} passed all task verifiers and ${reviewMode} review, then finished into ${record.targetBranch}. Receipt: ${finished.receipt}.\n${followupFinishText(finished)}${finished.warnings.map(w => `Warning: ${w}\n`).join("")}${highlights}Full reports: agent-ops review show --task ${parent.task.id}`
             });
         }
         catch (failure) {

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

@@ -0,0 +1,74 @@
+import { readFile, lstat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
+import { reconcileFollowups } from "../../../../runtime/src/followup/intake.js";
+import { readFollowupProgress } from "../../../../runtime/src/followup/process.js";
+import { FileFollowupStore, clarifyFollowup, setFollowupDisposition } from "../../../../runtime/src/followup/store.js";
+import { readFollowupAssessment } from "../../../../runtime/src/review/followup.js";
+import { redactSecrets } from "../../../../runtime/src/security/redact.js";
+import { safeTaskText } from "../../../../runtime/src/task/render.js";
+import { productionFollowupContext, followupRepositoryContext } from "../followup-deps.js";
+import { errorEnvelope, okEnvelope } from "../output.js";
+/** Redact strings individually so multiline credentials cannot hide behind JSON escapes. */
+function display(value) {
+    if (typeof value === "string")
+        return safeTaskText(redactSecrets(value));
+    if (Array.isArray(value))
+        return value.map(display);
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, field]) => [key, display(field)]));
+    return value;
+}
+export async function runFollowupCommand(options) {
+    const { args, cwd } = options;
+    const source = await followupRepositoryContext(cwd);
+    const collection = await reconcileFollowups(source);
+    const store = new FileFollowupStore(source.commonDir);
+    const action = args.action ?? "list";
+    const warnings = collection.warnings.map(w => `Warning: ${w}`);
+    if (action === "import" || action === "sync")
+        return okEnvelope("FOLLOWUP_IMPORTED", { collection,
+            text: [`Followup: collected ${collection.candidates} candidate(s), ${collection.observations} observation(s).`, ...warnings].join("\n") });
+    if (action === "list") {
+        const items = await Promise.all((await store.read()).items.map(async (item) => {
+            const progress = await readFollowupProgress(source.commonDir, item.id, item);
+            return { id: item.id, kind: item.kind, disposition: item.disposition, status: progress.status, code: progress.code,
+                title: typeof item.original === "string" ? item.original : item.original.title };
+        }));
+        const safe = display(items);
+        return okEnvelope("FOLLOWUP_LIST", { items: safe, collection,
+            text: [safe.length === 0 ? "No followup items." : safe.map(i => `${i.id} ${i.kind} ${i.disposition} ${i.status} (${i.code})\n  ${i.title}`).join("\n"), ...warnings].join("\n") });
+    }
+    const id = args.followupId;
+    if (action === "clarify") {
+        const path = resolve(cwd, args.findingFile);
+        if (!(await lstat(path)).isFile() || (await lstat(path)).size > 128 * 1024)
+            throw new AgentOpsError("FOLLOWUP_CLARIFICATION_INVALID", "Finding JSON must be a regular file no larger than 128 KiB.");
+        let finding;
+        try {
+            finding = JSON.parse(await readFile(path, "utf8"));
+        }
+        catch {
+            throw new AgentOpsError("FOLLOWUP_CLARIFICATION_INVALID", "Finding file must contain concrete ReviewFinding JSON.");
+        }
+        await clarifyFollowup(store, id, finding, args.reason);
+    }
+    else if (action === "accept" || action === "defer" || action === "reopen") {
+        await setFollowupDisposition(store, id, action, args.reason);
+    }
+    else if (action === "process") {
+        const progress = await (await productionFollowupContext(cwd)).process(id, args.host, args.reviewOnlyReason);
+        // A persisted refusal remains an error to scripts, with the durable state available to show.
+        if (progress.attempts.at(-1)?.code === progress.code)
+            return { ...errorEnvelope(progress.code, `Repair start refused: ${progress.code}. Item retained; inspect with followup show ${id}.`),
+                data: display({ progress, collection }) };
+    }
+    const item = await store.get(id), progress = await readFollowupProgress(source.commonDir, id, item);
+    const assessment = progress.assessment === undefined ? undefined : await readFollowupAssessment(source.commonDir, progress.assessment);
+    const safe = display({ item, progress, ...(assessment === undefined ? {} : {
+            assessment: { conclusion: assessment.conclusion, reason: assessment.reason, binding: assessment.binding }
+        }) });
+    return okEnvelope("FOLLOWUP_DETAIL", { ...safe, collection,
+        text: [`${id}: ${safe.item.kind}, ${safe.item.disposition}, ${progress.status} (${progress.code})`,
+            JSON.stringify(safe, null, 2), ...warnings].join("\n") });
+}

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

@@ -38,6 +38,9 @@ function addText(result) {
         "(Claude Code: ExitWorktree with action keep before finishing; do not run task complete in the worktree)."
     ].join("\n");
 }
+export function followupFinishText(result) {
+    return result.followup === undefined ? "" : `Followup: collected ${result.followup.candidates} candidate(s), ${result.followup.observations} observation(s). Inspect with agent-ops followup list.\n`;
+}
 function finishText(result) {
     const { record } = result;
     return [
@@ -45,6 +48,7 @@ function finishText(result) {
         `Completed and recorded in git notes (refs/notes/agent-ops): ${result.taskIds.join(", ")}.`,
         `Removed ${record.path}.`,
         ...(result.receipt === undefined ? [] : [`Receipt: ${result.receipt}`]),
+        ...followupFinishText(result).trimEnd().split("\n").filter(Boolean),
         ...(result.residualRisks === undefined || result.residualRisks.length === 0 ? [] :
             ["Residual risks from review:", ...result.residualRisks.map((risk) => `- ${safeTaskText(redactSecrets(risk))}`)]),
         ...result.warnings.map((warning) => `Warning: ${warning}`)

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

@@ -108,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, options.args.retryApprovalIds)));
+            return okEnvelope("RUN_RESUMED", data(action, await options.service.resume(runId, options.args.retryApprovalIds, true, options.args.retryDeliveryTaskId)));
         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/commands/task.js

@@ -1,8 +1,15 @@
+import { renderCriteriaReview } from "../../../../runtime/src/review/criteria.js";
 import { lstat, readFile } from "node:fs/promises";
 import { taskContractHash } from "../../../../runtime/src/task/contract.js";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { renderTaskMarkdown, safeTaskText } from "../../../../runtime/src/task/render.js";
 import { errorEnvelope, okEnvelope } from "../output.js";
+async function withCriteriaStatus(envelope, options) {
+    const item = envelope.data?.record;
+    const advice = item === undefined ? null : await options.criteriaStatus?.(item).catch(() => null);
+    return advice == null || envelope.data === null ? envelope : { ...envelope, data: { ...envelope.data, criteriaReview: advice,
+            text: envelope.data.text + "\n\n" + renderCriteriaReview(advice) } };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -154,11 +161,15 @@ export async function runTaskCommand(options) {
                 requireSurface: true
             });
             const escape = origin === undefined ? undefined : await (worktree?.service ?? options.service).declareEscape(record.task.id);
-            const created = await withEscape(taskEnvelope(action, "TASK_CREATED", sessionId === undefined
+            const initialAdvice = await options.onTaskCreated?.(record, worktree?.path);
+            let created = await withEscape(taskEnvelope(action, "TASK_CREATED", sessionId === undefined
                 ? `Created task ${record.task.id}.`
                 : record.task.parentTaskId === undefined
                     ? `Created and attached task ${record.task.id}.`
                     : `Created subtask ${record.task.id}; the session stays on the top of its task tree.`, record), escape, worktree?.service ?? options.service);
+            if (initialAdvice !== undefined && created.data !== null)
+                created = { ...created, data: { ...created.data, criteriaReview: initialAdvice,
+                        text: created.data.text + "\n\n" + renderCriteriaReview(initialAdvice) } };
             if (worktree === undefined || created.data === null)
                 return created;
             return {
@@ -191,7 +202,7 @@ export async function runTaskCommand(options) {
                 ...(origin === undefined ? {} : { origin }),
                 reason: options.args.reason, ...(options.args.baseline === undefined ? {} : { baseline: options.args.baseline })
             });
-            return await withEscape(taskEnvelope(action, "TASK_REVISED", "Contract revised; obtain a fresh review, and new verification if the criteria or configuration changed.", record), origin === undefined ? undefined : await options.service.declareEscape(record.task.id), options.service);
+            return await withCriteriaStatus(await withEscape(taskEnvelope(action, "TASK_REVISED", "Contract revised; obtain a fresh review, and new verification if the criteria or configuration changed.", record), origin === undefined ? undefined : await options.service.declareEscape(record.task.id), options.service), options);
         }
         if (action === "replan") {
             const payload = await jsonFile(options.args.planFile);
@@ -201,7 +212,13 @@ export async function runTaskCommand(options) {
                 expectedTreeContractHash: options.args.expectedTreeContract, reason: options.args.reason,
                 tasks: payload
             });
-            return okEnvelope("TASK_REPLANNED", { action, message: "Task tree split atomically; reverify and review.", records, text: renderTaskList(records) });
+            const advice = [];
+            for (const record of records) {
+                const result = await options.onTaskCreated?.(record);
+                if (result !== undefined)
+                    advice.push(renderCriteriaReview(result));
+            }
+            return okEnvelope("TASK_REPLANNED", { action, message: "Task tree split atomically; reverify and review.", records, text: [renderTaskList(records), ...advice].join("\n\n") });
         }
         if (action === "pin-finding") {
             const criterion = parseCriterion(JSON.stringify(await jsonFile(options.args.criterionFiles[0])));
@@ -234,9 +251,9 @@ export async function runTaskCommand(options) {
             const reviewOnly = coverage.rows.filter(row => row.mode === "review-only").length;
             const legacy = coverage.rows.filter(row => row.mode === "legacy").length;
             const envelope = taskEnvelope(action, "TASK_STATUS", `Read task ${record.task.id}.`, record);
-            return { ...envelope, data: { ...envelope.data, coverage, treeContractHash: await options.service.treeContract(record.task.id),
+            return await withCriteriaStatus({ ...envelope, data: { ...envelope.data, coverage, treeContractHash: await options.service.treeContract(record.task.id),
                     text: envelope.data.text + "\nAcceptance: " + proven + "/" + mechanical + " mechanical proven; " + reviewOnly + " review-only; " + legacy + " legacy; originally mechanical " + coverage.originalMechanical +
-                        "; reviewed " + coverage.reviewed + "; undischarged " + coverage.rows.filter(row => row.status !== "proven" && !coverage.reviewed).length } };
+                        "; reviewed " + coverage.reviewed + "; undischarged " + coverage.rows.filter(row => row.status !== "proven" && !coverage.reviewed).length } }, options);
         }
         if (action === "attach") {
             if (sessionId === undefined) {

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

@@ -236,22 +236,26 @@ export async function runPolicyContext(root, renew = false) {
         return null;
     const here = realpathSync(root);
     const worker = saved.workers.find(w => w.worktree === here);
-    const proofProcess = worker?.proofProcess ?? saved.proofProcess;
-    let proof = false;
-    if (proofProcess != null && String(proofProcess.processId) === process.env.AGENT_OPS_RUN_PROOF_PID) {
+    const matchesProof = (registered) => {
+        if (registered == null || String(registered.processId) !== process.env.AGENT_OPS_RUN_PROOF_PID)
+            return false;
         try {
-            proof = execFileSync("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim() === String(proofProcess.processId) &&
-                execFileSync("ps", ["-o", "lstart=", "-p", String(proofProcess.processId)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim() === proofProcess.processIdentity;
+            return execFileSync("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim() === String(registered.processId) &&
+                execFileSync("ps", ["-o", "lstart=", "-p", String(registered.processId)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim() === registered.processIdentity;
         }
         catch {
-            proof = false;
+            return false;
         }
-    }
+    };
+    const globalProof = matchesProof(saved.proofProcess);
+    const proof = globalProof || matchesProof(worker?.proofProcess);
+    // Reading another registered checkout does not change a run-level proof's coordinator actor.
+    const actor = globalProof || worker === undefined ? saved.workers.find(w => w.workerId === saved.coordinatorId) : worker;
     if ((!proof && (worker === undefined || record?.runId !== runId || record.workerId !== worker.workerId ||
         record.ownerSessionId !== worker.ownerSessionId || record.coordinatorId !== saved.coordinatorId || record.workerGeneration !== worker.generation)) ||
         (worker === undefined && !(proof && saved.root === here)) ||
-        (process.env.AGENT_OPS_WORKER_ID !== undefined && (process.env.AGENT_OPS_WORKER_ID !== (worker?.workerId ?? saved.coordinatorId) ||
-            process.env.AGENT_OPS_WORKER_GENERATION !== String((worker ?? saved.workers.find(w => w.workerId === saved.coordinatorId))?.generation))))
+        ((globalProof || process.env.AGENT_OPS_WORKER_ID !== undefined) && (actor === undefined ||
+            process.env.AGENT_OPS_WORKER_ID !== actor.workerId || process.env.AGENT_OPS_WORKER_GENERATION !== String(actor.generation))))
         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.");

package/dist/packages/cli/src/criteria-review.js

@@ -0,0 +1,63 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
+import { runCriteriaReview, readCriteriaReview, renderCriteriaReview } from "../../../runtime/src/review/criteria.js";
+import { registeredRunProofRunner } from "../../../runtime/src/verify/spawn.js";
+import { appendLocalLog } from "../../../runtime/src/logging/local-log.js";
+import { localStatePaths } from "../../../runtime/src/security/permissions.js";
+import { TaskService } from "../../../runtime/src/task/service.js";
+import { FileTaskStore } from "../../../runtime/src/task/store.js";
+import { loadEffectiveConfig, runPolicyContext } from "./context.js";
+async function parentScope(root, task) {
+    const read = async (path, id) => (await new TaskService(new FileTaskStore(join(path, ".agent-ops/tasks/state.json"), path)).status({ taskId: id })).task;
+    if (task.parentTaskId !== undefined)
+        return await read(root, task.parentTaskId);
+    if (task.surface !== undefined && "covers" in task.surface) {
+        const run = await runPolicyContext(root);
+        const coordinator = run?.state.workers.find(worker => worker.workerId === run.state.coordinatorId);
+        if (run?.state.rootTaskId != null && coordinator?.worktree != null)
+            return await read(coordinator.worktree, run.state.rootTaskId);
+    }
+    return undefined;
+}
+export async function criteriaReviewStatus(root, task) {
+    return await readCriteriaReview(root, task, await parentScope(root, task).catch(() => undefined));
+}
+/** Only production creation/explicit review installs this hook; TaskService stays model-free. */
+export async function reviewCreatedCriteria(root, task, rerun = false) {
+    const controller = new AbortController();
+    const interrupt = (signal) => { controller.abort(signal); };
+    const int = () => interrupt("SIGINT"), term = () => interrupt("SIGTERM");
+    process.once("SIGINT", int);
+    process.once("SIGTERM", term);
+    try {
+        const config = await loadEffectiveConfig(root, "project").catch(() => undefined);
+        const role = config?.config.reviewRoles?.find(role => role.role === "independent-review");
+        const host = process.env.AGENT_OPS_HOST;
+        const target = role?.targets.find(target => target !== host) ?? role?.targets[0];
+        const parent = await parentScope(root, task).catch(() => undefined);
+        process.stderr.write(`Criteria advisory for ${task.id}: waiting for one independent reviewer (no time budget; Ctrl-C cancels).\n`);
+        let result = await runCriteriaReview({ root, task, parent, target, model: role?.model, effort: role?.effort,
+            rerun, signal: controller.signal, runner: registeredRunProofRunner(),
+            unavailableCode: config === undefined ? "CRITERIA_REVIEW_CONFIG_UNAVAILABLE" : target === undefined && role !== undefined ? "CRITERIA_REVIEW_NO_INDEPENDENT_TARGET" : "CRITERIA_REVIEW_UNCONFIGURED",
+            log: async (report, path) => {
+                const state = localStatePaths(process.env.AGENT_OPS_HOME ?? homedir());
+                await appendLocalLog(join(state.logDirectory, "events.ndjson"), { type: "criteria-review", taskId: task.id,
+                    attemptId: report.attemptId, status: report.status, code: report.code, durationMs: report.durationMs,
+                    invocations: report.invocations, recommendations: report.advice?.recommendations.length ?? 0,
+                    report: path, usage: { ...report.usage } }, { anchorDirectory: state.anchorDirectory });
+            } });
+        const latest = await new TaskService(new FileTaskStore(join(root, ".agent-ops/tasks/state.json"), root)).status({ taskId: task.id }).catch(() => undefined);
+        const currentView = latest === undefined ? null : await criteriaReviewStatus(root, latest.task);
+        if (currentView?.report.attemptId === result.report.attemptId)
+            result = { ...result, stale: currentView.stale };
+        if (controller.signal.aborted)
+            throw new AgentOpsError("CRITERIA_REVIEW_CANCELLED", "Criteria review cancelled; stop before implementation.");
+        process.stderr.write(renderCriteriaReview(result) + "\n");
+        return result;
+    }
+    finally {
+        process.removeListener("SIGINT", int);
+        process.removeListener("SIGTERM", term);
+    }
+}