@kylecheng3146/agent-ops 0.5.2 → 0.6.0

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

@@ -25,10 +25,11 @@ Commands:
   doctor     Diagnose an installation
   update     Update managed artifacts
   uninstall  Remove managed artifacts
-  task <create|status|attach|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
+  review     Run an independent review or show recorded reports
+  run        Start or control a supervised Claude/Codex native goal
   batch      Verify and review a parent task's subtasks together
   allow-stop Grant one fingerprint-bound completion-gate Stop permit (requires --session)
   agy-run    Run headless agy with a process-exit completion recheck
@@ -71,6 +72,14 @@ Options:
  * rejected.
  */
 export const COMMAND_HELP_TEXT = {
+    run: `Usage: agent-ops run [start] "<goal>" --host <claude|codex> [--jobs <1|2>] [--time-budget <60m>] [--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 respond <run-id> --question-id <id> <--answer <text>|--answer-file <path>> [--json]
+
+Native goal state is observational. Completion requires current verification,
+two fresh reviews, task completion and a target-bound integration receipt.
+`,
     init: `Usage: agent-ops init [options]
 
 Plan or install agent-ops into this repository.
@@ -141,27 +150,47 @@ Options:
   --json
   --yes
 `,
-    task: `Usage: agent-ops task <create|status|attach|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, --dry-run or --yes.
+--harness, --profile or --dry-run. Only advance accepts --yes.
 
 Options:
   --title <text>                        create
+  --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
+  --plan-file <path>                    replan: split-task array with requirement mappings
+  --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
   --parent <task-id>                    create: record a subtask; status: list subtasks
-  --task <id>                           status, attach, complete, archive, export
-  --session <id>                        attach, status
+  --task <id>                           status, attach, revise, replan, pin-finding, complete, archive, export, advance
+  --session <id>                        create, attach, status, advance
   --evidence <criterion-id=reference>   complete, repeatable
   --base <git-ref>                      complete: a clean committed range
+  --yes                                 advance: authorize the two review sessions
   --json
 
-Each --criterion is one JSON object with exactly these keys:
+Each --criterion or --criterion-file supplies one criterion object. Legacy example:
 
   {"id":"kebab-id","description":"what must hold","verifierIds":["node-test"]}
 
-Every criterion needs at least one verifierIds entry naming a verification
-command id configured in .agent-ops/config.json. No other key is accepted.
+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
+redCheckIds; tasks cannot supply commands. Creation freezes the baseline.
+Review-only example (mandatory repository policy commands still run):
+
+  {"id":"judgment","description":"Meets the original goal","verifierIds":[],"acceptance":{"mode":"review-only","bindings":[],"reviewOnlyReason":"Requires independent judgment"}}
+
+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.
 `,
     verify: `Usage: agent-ops verify [options]
 
@@ -174,12 +203,15 @@ Options:
   --json
 `,
     review: `Usage: agent-ops review --task <id> --yes [options]
+       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.
+fresh adversarial reviewer from the configured pair. Show reads recorded
+reports without running a reviewer, including from the main checkout.
 
 Options:
   --task <id>          Required task whose original criteria are reviewed
+  --tree               Cover this task and every non-archived descendant in one two-round review
   --base <git-ref>     Review a clean committed range
   --output <file>      Write the JSON envelope to <file> (mode 0600) and print
                        one summary line, so no shell redirect is needed

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

@@ -0,0 +1,173 @@
+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 { 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";
+import { renderReviewDetails, renderReviewHighlights } from "../../../../runtime/src/review/render.js";
+import { calculateSourceFingerprint } from "../../../../runtime/src/verify/source-fingerprint.js";
+import { okEnvelope } from "../output.js";
+import { readFinishedReview } from "./review-show.js";
+import { prepareRunIntegration, readRunIntegrationProof, abandonPreparedRunIntegration } from "../../../../runtime/src/run/integration.js";
+/** The child process runs the existing CLI in the candidate checkout. */
+export async function runAdvanceStep(cwd, args) {
+    const bin = process.argv[1];
+    if (bin === undefined)
+        throw new AgentOpsError("ADVANCE_CLI_MISSING", "Cannot locate the agent-ops CLI entry point.");
+    return await new Promise((resolveStep, reject) => {
+        const child = spawn(process.execPath, [resolve(bin), ...args, "--json"], {
+            cwd, env: process.env, stdio: ["ignore", "pipe", "inherit"]
+        });
+        const chunks = [];
+        let bytes = 0;
+        child.stdout.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > 4 * 1024 * 1024)
+                child.kill();
+            else
+                chunks.push(chunk);
+        });
+        child.once("error", reject);
+        child.once("close", () => {
+            try {
+                const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+                if (value.status !== "ok" && value.status !== "error")
+                    throw new Error("Invalid CLI envelope.");
+                resolveStep(value);
+            }
+            catch {
+                reject(new AgentOpsError("ADVANCE_STEP_UNREADABLE", `Could not read ${args[0]} result from the candidate checkout.`));
+            }
+        });
+    });
+}
+function runner(deps, cwd) {
+    return { run: async (args) => {
+            const result = await deps.git(cwd, args);
+            return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout, "utf8") };
+        } };
+}
+async function git(deps, cwd, args) {
+    const result = await deps.git(cwd, args);
+    if (result.exitCode !== 0)
+        throw new AgentOpsError("ADVANCE_GIT_FAILED", `${args.join(" ")}: ${result.stderr.trim()}`);
+    return result.stdout.trim();
+}
+function requirePass(step, label) {
+    if (step.status === "ok" && (step.data?.result?.status === "PASS" || step.data?.report?.status === "PASS"))
+        return;
+    const result = step.data?.result;
+    const details = result?.report !== undefined || result?.attempts !== undefined
+        ? `\n${renderReviewDetails([{ taskId: result.taskId ?? label, title: label, artifact: result }], "active")}`
+        : step.data?.text ?? "";
+    throw new AgentOpsError(step.code, `${label}: ${step.errors?.[0]?.message ?? result?.reason ?? "proof did not pass"}${details ? `\n${details}` : ""}`);
+}
+export async function reviewFinalTree(step, cwd, parentTaskId, taskIds, base) {
+    const reviewed = await step(cwd, ["review", "--task", parentTaskId, "--tree", "--base", base, "--yes"]);
+    if (reviewed.status === "error" && reviewed.data?.result?.status === "NOT_RUN" &&
+        reviewed.data.result.reason === "scope-too-large") {
+        for (const taskId of taskIds) {
+            requirePass(await step(cwd, ["review", "--task", taskId, "--base", base, "--yes"]), `Review ${taskId}`);
+        }
+        return "per-task-fallback";
+    }
+    requirePass(reviewed, "Tree review");
+    return "tree";
+}
+export async function runAdvanceCommand(options) {
+    const { deps, cwd } = options;
+    if (options.sessionId === undefined || options.parentTaskId === undefined) {
+        throw new AgentOpsError("ADVANCE_TARGET_REQUIRED", "task advance requires --task and a current or explicit --session.");
+    }
+    const { mainRoot, currentRoot, commonDir } = await resolveCheckouts(deps, cwd);
+    if (mainRoot !== currentRoot)
+        throw new AgentOpsError("WORKTREE_NESTED", `Run task advance from ${mainRoot}.`);
+    const name = sessionWorktreeName(options.sessionId);
+    const record = await readWorktreeRecord(worktreePath(mainRoot, name));
+    if (record === null || record.sessionId !== options.sessionId || record.agentId !== undefined) {
+        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) {
+        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." });
+    }
+    if (savedProof !== null && await git(deps, mainRoot, ["rev-parse", `${record.targetBranch}^{commit}`]) !== savedProof.target)
+        await abandonPreparedRunIntegration(commonDir, record, deps.git);
+    const parent = await deps.tasks(record.path).status({ taskId: options.parentTaskId });
+    if (parent.status !== "active" || parent.task.parentTaskId !== undefined) {
+        throw new AgentOpsError("ADVANCE_PARENT_INVALID", "Advance requires an active root task in the coordinator worktree.");
+    }
+    const children = await integrateSessionChildren(deps, record, parent.task.id);
+    const step = options.step ?? runAdvanceStep;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const target = await git(deps, mainRoot, ["rev-parse", `${record.targetBranch}^{commit}`]);
+        const branchHead = await git(deps, record.path, ["rev-parse", "HEAD"]);
+        if ((await deps.git(record.path, ["merge-base", "--is-ancestor", target, "HEAD"])).exitCode !== 0) {
+            const rebase = await deps.git(record.path, ["rebase", "--rebase-merges", "--no-autostash", target]);
+            if (rebase.exitCode !== 0) {
+                const files = (await deps.git(record.path, ["diff", "--name-only", "--diff-filter=U"])).stdout.trim();
+                await deps.git(record.path, ["rebase", "--abort"]);
+                throw new AgentOpsError("WORKTREE_REBASE_CONFLICT", `Target moved; rebase conflicted in ${files || "unknown files"}. Candidate remains at ${branchHead}.`);
+            }
+        }
+        const head = await git(deps, record.path, ["rev-parse", "HEAD"]);
+        const all = (await deps.tasks(record.path).list()).filter(({ status }) => status !== "archived");
+        const selected = new Set([parent.task.id]);
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const item of all) {
+                if (item.task.parentTaskId !== undefined && selected.has(item.task.parentTaskId) && !selected.has(item.task.id)) {
+                    selected.add(item.task.id);
+                    changed = true;
+                }
+            }
+        }
+        if (selected.size !== all.length || all.some(({ task, status }) => !selected.has(task.id) || status !== "active")) {
+            throw new AgentOpsError("ADVANCE_TASK_TREE_INVALID", "The candidate has unrelated or already completed tasks; final proof must cover one active tree.");
+        }
+        const ordered = all.filter(({ task }) => selected.has(task.id));
+        const noChangePaths = head === target ? parent.noChangePaths : undefined;
+        if (noChangePaths !== undefined)
+            for (const task of ordered)
+                await deps.tasks(record.path).recordEvidence(task.task.id, {}, undefined, noChangePaths);
+        for (const task of ordered) {
+            requirePass(await step(record.path, ["verify", "--task", task.task.id, "--base", target]), `Verify ${task.task.id}`);
+        }
+        const reviewMode = await reviewFinalTree(step, record.path, parent.task.id, ordered.map(({ task }) => task.id), target);
+        const scope = await resolveReviewScope({ root: record.path, runner: runner(deps, record.path), base: target,
+            ...(noChangePaths === undefined ? {} : { noChangePaths }) });
+        const sourceFingerprint = await calculateSourceFingerprint(record.path, scope, runner(deps, record.path));
+        const finalProof = { target, head, sourceFingerprint, children,
+            ...(noChangePaths === undefined ? {} : { noChange: { sourceCommit: head,
+                    contractDigest: await deps.tasks(record.path).treeContract(parent.task.id), reviewScope: scope,
+                    artifactRefs: Object.values((await deps.tasks(record.path).status({ taskId: parent.task.id })).evidence).flat() } }) };
+        await prepareRunIntegration(commonDir, record, finalProof);
+        try {
+            const finished = await finishWorktree(deps, {
+                cwd: mainRoot, name,
+                finalProof
+            });
+            if (finished.receipt === undefined)
+                throw new AgentOpsError("WORKTREE_RECEIPT_MISSING", "Finish returned without a final review receipt.");
+            const review = await readFinishedReview(deps, mainRoot, commonDir, finished.receipt);
+            const highlights = renderReviewHighlights(review.entries);
+            return okEnvelope("TASK_ADVANCED", {
+                parentTaskId: parent.task.id,
+                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}`
+            });
+        }
+        catch (failure) {
+            if (failure instanceof AgentOpsError && failure.code === "WORKTREE_TARGET_MOVED" && attempt === 0) {
+                await abandonPreparedRunIntegration(commonDir, record, deps.git);
+                continue;
+            }
+            throw failure;
+        }
+    }
+    throw new AgentOpsError("WORKTREE_TARGET_MOVED", "The target moved again; preserve the candidate and rerun after coordination.");
+}

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

@@ -0,0 +1,189 @@
+import { readdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { sha256 } from "../../../../runtime/src/fs/hash.js";
+import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
+import { listWorktrees } from "../../../../runtime/src/parallel/manage.js";
+import { NOTES_REF, resolveCheckouts } from "../../../../runtime/src/parallel/service.js";
+import { REVIEW_ATTESTATION_DIRECTORY, REVIEW_REPORT_ARTIFACT_SUFFIX } from "../../../../runtime/src/review/attestation.js";
+import { renderReviewDetails } from "../../../../runtime/src/review/render.js";
+import { validateReviewReport } from "../../../../runtime/src/review/report.js";
+import { resolveReviewScope } from "../../../../runtime/src/review/scope.js";
+import { readPrivateFile } from "../../../../runtime/src/security/permissions.js";
+import { calculateSourceFingerprint } from "../../../../runtime/src/verify/source-fingerprint.js";
+import { okEnvelope } from "../output.js";
+function invalid(message) {
+    throw new AgentOpsError("REVIEW_RECORD_INVALID", message);
+}
+function checkedArtifact(value, fingerprint, taskId) {
+    if (typeof value !== "object" || value === null)
+        invalid("Review artifact is unreadable.");
+    const artifact = value;
+    if (![1, 2].includes(artifact.schemaVersion) || artifact.sourceFingerprint !== fingerprint ||
+        artifact.taskId !== taskId || !["PASS", "FAIL", "NOT_RUN"].includes(artifact.status) ||
+        !Array.isArray(artifact.attempts) ||
+        (artifact.report !== undefined && !validReport(artifact.report, artifact)) ||
+        (artifact.adversarial !== undefined && !validReport(artifact.adversarial.report, artifact))) {
+        invalid(`Review artifact for ${taskId} does not match the candidate.`);
+    }
+    return artifact;
+}
+function validReport(report, artifact) {
+    const ids = artifact.tree?.criterionIds ?? report?.results?.map(({ criterionId }) => criterionId);
+    return ids !== undefined && validateReviewReport(report, ids).ok;
+}
+function entriesFromReceipt(receipt) {
+    const records = receipt.reviewMode === "tree"
+        ? [receipt.tasks.find(({ task }) => task.parentTaskId === undefined) ?? receipt.tasks[0]]
+        : receipt.tasks;
+    return records.map(({ task }) => {
+        const sealed = receipt.reviews[task.id]?.report;
+        if (sealed === undefined || sha256(JSON.stringify(sealed.value)) !== sealed.digest) {
+            invalid(`Review evidence for ${task.id} is missing or changed.`);
+        }
+        return { taskId: task.id, title: task.title,
+            artifact: checkedArtifact(sealed.value, receipt.sourceFingerprint, task.id) };
+    });
+}
+/** The note binds the private receipt to the merged commit and its exact bytes. */
+export async function readFinishedReview(deps, mainRoot, commonDir, path) {
+    if (dirname(path) !== join(commonDir, "agent-ops", "receipts"))
+        invalid("Final review receipt path is outside the receipt directory.");
+    const source = await readPrivateFile(path, commonDir);
+    if (source === null)
+        invalid("Final review receipt is missing.");
+    let receipt;
+    try {
+        receipt = JSON.parse(source);
+    }
+    catch {
+        return invalid("Final review receipt is malformed.");
+    }
+    if (receipt.schemaVersion !== 1 || !/^[a-f0-9]{40,64}$/u.test(receipt.candidateHead) ||
+        !Array.isArray(receipt.tasks) || receipt.tasks.length === 0 ||
+        !["tree", "per-task-fallback"].includes(receipt.reviewMode) ||
+        typeof receipt.reviews !== "object" || receipt.reviews === null) {
+        invalid("Final review receipt is invalid.");
+    }
+    const note = await deps.git(mainRoot, ["notes", `--ref=${NOTES_REF}`, "show", receipt.candidateHead]);
+    const binding = `\nreceipt: ${path}\nreceipt-sha256: ${sha256(source)}`;
+    if (note.exitCode !== 0 || !note.stdout.trimEnd().endsWith(binding)) {
+        invalid("Final review receipt does not match its Git note.");
+    }
+    return { mode: receipt.reviewMode, candidateHead: receipt.candidateHead,
+        sourceFingerprint: receipt.sourceFingerprint, entries: entriesFromReceipt(receipt), receipt: path };
+}
+async function finishedPath(commonDir, taskId) {
+    const directory = join(commonDir, "agent-ops", "receipts");
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    let latest = null;
+    for (const name of names.filter((item) => /^[a-f0-9]{64}-[a-f0-9]{40,64}\.json$/u.test(item))) {
+        const path = join(directory, name);
+        const source = await readPrivateFile(path, commonDir);
+        if (source === null)
+            continue;
+        try {
+            const receipt = JSON.parse(source);
+            if (!Array.isArray(receipt.tasks) || !receipt.tasks.some(({ task }) => task.id === taskId))
+                continue;
+            if (latest === null || receipt.createdAt > latest.createdAt)
+                latest = { path, createdAt: receipt.createdAt };
+        }
+        catch { /* An unrelated malformed receipt cannot name this task. */ }
+    }
+    return latest?.path ?? null;
+}
+function runner(deps, cwd) {
+    return { run: async (args) => {
+            const result = await deps.git(cwd, args);
+            return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout, "utf8") };
+        } };
+}
+async function activeReview(deps, mainRoot, taskId) {
+    const matching = [];
+    for (const { record } of await listWorktrees(deps, mainRoot)) {
+        const records = await deps.tasks(record.path).list();
+        if (records.some(({ task }) => task.id === taskId))
+            matching.push({ record, records });
+    }
+    if (matching.length > 1)
+        invalid(`Task ${taskId} exists in more than one active worktree.`);
+    const current = matching[0];
+    if (current === undefined)
+        return null;
+    const { record, records } = current;
+    const headResult = await deps.git(record.path, ["rev-parse", "HEAD"]);
+    if (headResult.exitCode !== 0)
+        invalid("Cannot read the active candidate HEAD.");
+    const candidateHead = headResult.stdout.trim();
+    const selected = new Set([taskId]);
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const { task } of records) {
+            if (task.parentTaskId !== undefined && selected.has(task.parentTaskId) && !selected.has(task.id)) {
+                selected.add(task.id);
+                changed = true;
+            }
+        }
+    }
+    const tree = [records.find(({ task }) => task.id === taskId),
+        ...records.filter(({ task }) => selected.has(task.id) && task.id !== taskId)];
+    const target = await deps.git(mainRoot, ["rev-parse", `${record.targetBranch}^{commit}`]);
+    if (target.exitCode !== 0)
+        invalid("Cannot read the target branch for the active candidate.");
+    let fingerprint;
+    try {
+        const scope = await resolveReviewScope({ root: record.path, runner: runner(deps, record.path), base: target.stdout.trim() });
+        fingerprint = await calculateSourceFingerprint(record.path, scope, runner(deps, record.path));
+    }
+    catch (error) {
+        if (error instanceof AgentOpsError && error.code === "REVIEW_DIRTY_WORKTREE") {
+            try {
+                const scope = await resolveReviewScope({ root: record.path, runner: runner(deps, record.path) });
+                fingerprint = await calculateSourceFingerprint(record.path, scope, runner(deps, record.path));
+            }
+            catch { /* No report for this source state. */ }
+        }
+    }
+    const entries = [];
+    for (const { task } of tree) {
+        let artifact = null;
+        if (fingerprint !== undefined) {
+            const source = await readPrivateFile(join(record.path, REVIEW_ATTESTATION_DIRECTORY, `${fingerprint}.${task.id}${REVIEW_REPORT_ARTIFACT_SUFFIX}`), record.path);
+            if (source !== null) {
+                try {
+                    artifact = checkedArtifact(JSON.parse(source), fingerprint, task.id);
+                }
+                catch (error) {
+                    if (error instanceof AgentOpsError)
+                        throw error;
+                    invalid(`Review artifact for ${task.id} is malformed.`);
+                }
+            }
+        }
+        entries.push({ taskId: task.id, title: task.title, artifact });
+    }
+    // A failed whole-tree review writes one parent artifact; its criterion IDs
+    // already cover the whole tree, so do not print empty child aliases.
+    const first = entries[0];
+    const wholeTree = first?.artifact?.report?.results.some(({ criterionId }) => criterionId.includes(":"));
+    return { mode: "active", candidateHead, ...(fingerprint === undefined ? {} : { sourceFingerprint: fingerprint }),
+        entries: wholeTree ? [first] : entries };
+}
+export async function runReviewShowCommand(options) {
+    const { mainRoot, commonDir } = await resolveCheckouts(options.deps, options.cwd);
+    const active = await activeReview(options.deps, mainRoot, options.taskId);
+    const path = active === null ? await finishedPath(commonDir, options.taskId) : null;
+    const view = active ?? (path === null ? null : await readFinishedReview(options.deps, mainRoot, commonDir, path));
+    if (view === null)
+        throw new AgentOpsError("REVIEW_TASK_NOT_FOUND", `No active or finished review task ${options.taskId}.`);
+    return okEnvelope("REVIEW_SHOWN", { ...view,
+        text: `Candidate: ${view.candidateHead}\n${renderReviewDetails(view.entries, view.mode)}` });
+}