@kylecheng3146/agent-ops 0.2.6 → 0.2.8

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

@@ -79,6 +79,7 @@ export function parseArgs(argv) {
     let dryRun = false;
     let json = false;
     let yes = false;
+    let rerun = false;
     let helpSeen = false;
     let versionSeen = false;
     for (let index = 0; index < argv.length; index += 1) {
@@ -242,6 +243,12 @@ export function parseArgs(argv) {
                 }
                 yes = true;
                 break;
+            case "--rerun":
+                if (rerun) {
+                    duplicate(token);
+                }
+                rerun = true;
+                break;
             case "--help":
             case "-h":
                 if (helpSeen) {
@@ -313,7 +320,8 @@ export function parseArgs(argv) {
             profiles: [],
             dryRun: false,
             json,
-            yes: false
+            yes: false,
+            rerun: false
         };
     }
     if (versionSeen && command !== undefined) {
@@ -337,7 +345,8 @@ export function parseArgs(argv) {
             checkAuth ||
             checkAuthTargets.length > 0 ||
             dryRun ||
-            yes) {
+            yes ||
+            rerun) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Only --json may be combined with global help or version.");
         }
         command = helpSeen ? "help" : "version";
@@ -399,7 +408,8 @@ export function parseArgs(argv) {
         if (harness !== undefined ||
             profiles.length > 0 ||
             dryRun ||
-            yes) {
+            yes ||
+            rerun) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Task commands do not accept harness, profile, dry-run, or yes options.");
         }
         const taskOptionInvalid = (action === "create" &&
@@ -492,6 +502,7 @@ export function parseArgs(argv) {
         ...(base === undefined ? {} : { base }),
         ...(checkAuth ? { checkAuth } : {}),
         ...(checkAuthTargets.length === 0 ? {} : { checkAuthTargets }),
+        rerun,
         dryRun,
         json,
         yes

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

@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 import { commonHarnessAdapters, harnessHookPath, HARNESS_IDS } from "../../../runtime/src/install/harness.js";
 import { agyRuntimeStatus, agyVersionSupported, hookRegistrationDrift, repositoryTrustStatus, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
 import { parseInstallManifest } from "../../../runtime/src/fs/manifest.js";
+import { readRecordedSessionId } from "../../../runtime/src/hooks/codex-loop.js";
 import { NpmRegistryClient } from "../../../runtime/src/registry/npm.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
@@ -378,7 +379,11 @@ else {
                     });
                 }
                 if (args.command === "task") {
-                    const sessionId = process.env.AGENT_OPS_SESSION_ID;
+                    // Explicit `--session` wins, then an injected identity, then the
+                    // id a SessionStart hook recorded for this checkout: a command
+                    // run inside a session is never told which session it is in.
+                    const sessionId = process.env.AGENT_OPS_SESSION_ID ??
+                        await readRecordedSessionId(root);
                     const policyConfigHash = args.action === "create"
                         ? calculateConfigHash((await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config)
                         : undefined;
@@ -436,7 +441,15 @@ else {
                                 ...(reviewRole?.timeoutMs === undefined
                                     ? {}
                                     : { timeoutMs: reviewRole.timeoutMs }),
-                                preflightTarget: async (target) => await probeReviewTarget(target, { cwd: root, deep: true }),
+                                preflightTarget: async (target, budget) => await probeReviewTarget(target, {
+                                    cwd: root,
+                                    deep: true,
+                                    // The probe answers within the chain's remaining budget
+                                    // or not at all; its own default would outlast it.
+                                    ...(budget === undefined
+                                        ? {}
+                                        : { timeoutMs: budget.timeoutMs })
+                                }),
                                 verifySourceFingerprint: async (expected) => {
                                     const currentScope = await resolveReviewScope({
                                         root,

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

@@ -1,7 +1,8 @@
 import { buildReviewPacket } from "../../../../runtime/src/review/packet.js";
 import { runIndependentReview } from "../../../../runtime/src/review/runner.js";
 import { renderReviewResult } from "../../../../runtime/src/review/render.js";
-import { invalidateReviewAttestation, reviewReportDigest, saveReviewAttestation, saveReviewReportArtifact } from "../../../../runtime/src/review/attestation.js";
+import { reviewReportResults } from "../../../../runtime/src/review/report.js";
+import { findPriorFailingFindings, findReviewAttestation, invalidateReviewAttestation, readReviewReportArtifact, reviewReportDigest, saveReviewAttestation, saveReviewReportArtifact } from "../../../../runtime/src/review/attestation.js";
 import { detectHostTarget, planReviewTargets, resolveReviewRole } from "../../../../runtime/src/review/roles.js";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { assertSafeSupportingPaths, isReviewerPolicyPath, resolveReviewScope, reviewScopeSignature } from "../../../../runtime/src/review/scope.js";
@@ -263,6 +264,55 @@ function hasCompleteReviewEvidence(result) {
             attempt.status === "PASS" &&
             attempt.sessionId !== undefined);
 }
+/**
+ * The recorded verdict for this exact source, when it is still the right one:
+ * same source fingerprint, same task, and a stored report that still matches
+ * its attestation. Anything else returns null and the chain runs.
+ */
+async function reusableReview(options, sourceFingerprint, context) {
+    if (options.root === undefined) {
+        return null;
+    }
+    const attestation = await findReviewAttestation(options.root, sourceFingerprint);
+    if (attestation === null || attestation.taskId !== context?.taskId) {
+        return null;
+    }
+    // The task's own policy baseline must still be the active one. This is
+    // checked before this point too; repeating it here keeps the reuse path
+    // safe wherever it is called from.
+    if (options.policyConfigHash !== undefined &&
+        context?.policyConfigHash !== options.policyConfigHash) {
+        return null;
+    }
+    const artifact = await readReviewReportArtifact(options.root, sourceFingerprint);
+    if (artifact === null ||
+        artifact.taskId !== attestation.taskId ||
+        artifact.report === undefined ||
+        artifact.adversarial === undefined) {
+        return null;
+    }
+    return {
+        status: "PASS",
+        harness: artifact.harness,
+        model: options.model ?? "configured",
+        effort: options.effort ?? "configured",
+        prompt: "",
+        results: reviewReportResults(artifact.report),
+        report: artifact.report,
+        adversarial: artifact.adversarial,
+        attempts: artifact.attempts,
+        preflight: artifact.preflight,
+        plannedTargets: artifact.plannedTargets,
+        sourceFingerprint,
+        reused: true,
+        ...(artifact.independence === undefined
+            ? {}
+            : { independence: artifact.independence }),
+        ...(artifact.sessionIsolation === undefined
+            ? {}
+            : { sessionIsolation: artifact.sessionIsolation })
+    };
+}
 async function persistReviewEvidence(options, result, sourceFingerprint, context) {
     if (options.root === undefined || sourceFingerprint === undefined) {
         return result;
@@ -391,9 +441,7 @@ export async function runReviewCommand(options) {
             });
         }
         sourceFingerprint = await calculateSourceFingerprint(options.root, scope, options.gitRunner);
-        if (options.authorized) {
-            await invalidateReviewAttestation(options.root, sourceFingerprint);
-        }
+        let pendingInvalidation = options.authorized;
         if (context !== undefined && options.policyConfigHash !== undefined) {
             if (context.policyConfigHash === null) {
                 return notRunEnvelope({
@@ -422,6 +470,27 @@ export async function runReviewCommand(options) {
             }
             verification = preflight.summary;
         }
+        if (pendingInvalidation) {
+            // Last of all the checks, never before them. A recorded PASS proves the
+            // source was reviewed; it says nothing about the policy in force now or
+            // about verification that has failed since, and both of those are
+            // decided above.
+            const reused = options.args.rerun
+                ? null
+                : await reusableReview(options, sourceFingerprint, context);
+            if (reused !== null) {
+                return okEnvelope("REVIEW_RESULT", {
+                    message: "Independent review passed (reused recorded evidence).",
+                    result: reused,
+                    text: renderReviewResult({
+                        ...reused,
+                        ...(verification === undefined ? {} : { verification })
+                    })
+                });
+            }
+            await invalidateReviewAttestation(options.root, sourceFingerprint);
+            pendingInvalidation = false;
+        }
     }
     const criteria = [
         ...(context?.criteria ?? GENERIC_CRITERIA)
@@ -452,6 +521,9 @@ export async function runReviewCommand(options) {
         }
         throw error;
     }
+    const priorFindings = options.root === undefined || context === undefined
+        ? []
+        : await findPriorFailingFindings(options.root, context.taskId);
     const result = await runIndependentReview({
         invocation: {
             harness: target,
@@ -462,7 +534,8 @@ export async function runReviewCommand(options) {
             effort: role?.effort ?? options.effort ?? "configured",
             packet,
             ...(scope === undefined ? {} : { scope }),
-            ...(verification === undefined ? {} : { verification })
+            ...(verification === undefined ? {} : { verification }),
+            ...(priorFindings.length === 0 ? {} : { priorFindings })
         },
         authorized: options.authorized,
         execute: options.execute ?? (async () => ({

package/dist/runtime/src/hooks/codex-loop.js

@@ -7,12 +7,20 @@ import { evaluateGuardrail } from "../guardrails/evaluate.js";
 import { appendLocalLog } from "../logging/local-log.js";
 import { readPrivateFile, withPrivateFileLock, writePrivateFile } from "../security/permissions.js";
 import { redactSecrets } from "../security/redact.js";
+import { DEFAULT_CHECKPOINT_BUDGET, renderTaskCheckpoint } from "../task/render.js";
+import { parseTaskStateSource } from "../task/store.js";
 import { normalizeShellHookEvent } from "./shell.js";
 const execFile = promisify(execFileCallback);
 const MAX_CONTEXT_CHARS = 1_200;
 const MAX_GIT_STATUS_CHARS = 4_096;
 const DEFAULT_TELEMETRY_MAX_BYTES = 64 * 1024;
 const LOOP_SNAPSHOT_ID = "loop-snapshot";
+const LOOP_SESSION_ID = "loop-session";
+/** Task state outranks the goal when both compete for the same ceiling. */
+const MAX_CHECKPOINT_CHARS = DEFAULT_CHECKPOINT_BUDGET;
+const MAX_GOAL_CHARS = 400;
+const MIN_GOAL_CHARS = 40;
+const SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
 export const PROJECT_LOOP_EVENTS = [
     "SessionStart",
     "UserPromptSubmit",
@@ -199,6 +207,15 @@ function boundedContext(value) {
         ? normalized
         : `${normalized.slice(0, MAX_CONTEXT_CHARS - 14)}\n[truncated]`;
 }
+/**
+ * Task titles and criterion descriptions are ordinary user text, so they get
+ * the same treatment as the goal file: secret-shaped content is dropped
+ * rather than injected, and everything else is redacted.
+ */
+function safeStateContext(value, scope) {
+    const decision = evaluateGuardrail({ kind: "content", content: value, scope });
+    return decision.action === "block" ? undefined : redactSecrets(value);
+}
 function safeGoalContext(source) {
     if (source === null || source.trim().length === 0) {
         return "No project loop goal is recorded.";
@@ -342,15 +359,183 @@ async function writeCompactSnapshot(options) {
         }), options.root);
     });
 }
-function sessionContext(goal, telemetryEntries) {
-    return boundedContext([
+function inputField(input, field) {
+    if (typeof input !== "object" || input === null) {
+        return undefined;
+    }
+    const value = input[field];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/**
+ * Claude Code publishes `source` on SessionStart: `compact` after a
+ * compaction, `resume` when the transcript is still present, `startup` and
+ * `clear` for an empty one. A host that publishes nothing is treated as
+ * `fresh`, which injects the least.
+ */
+function restoreMode(input) {
+    switch (inputField(input, "source")) {
+        case "compact":
+            return "compact";
+        case "resume":
+            return "resume";
+        default:
+            return "fresh";
+    }
+}
+function sessionIdOf(input) {
+    const value = inputField(input, "session_id");
+    return value !== undefined && SESSION_ID_PATTERN.test(value)
+        ? value
+        : undefined;
+}
+function parseSessionMarker(source) {
+    if (source === null) {
+        return {};
+    }
+    const session = source.match(/^Session: (\S+)$/mu)?.[1];
+    const task = source.match(/^Task: (\S+)$/mu)?.[1];
+    return {
+        ...(session === undefined ? {} : { sessionId: session }),
+        ...(task === undefined ? {} : { taskId: task })
+    };
+}
+/**
+ * The bridge the CLI cannot build for itself: a hook is told the session id,
+ * a command run inside that session is not. Recording it here lets
+ * `agent-ops task attach` default to the session actually running.
+ *
+ * ponytail: last writer wins. Two concurrent sessions in one checkout already
+ * violate the one-writer rule; pass `--session` explicitly if you need that.
+ */
+async function writeSessionMarker(options) {
+    const path = loopPath(options.root, options.harness, "loop-state.md");
+    await withPrivateFileLock(path, options.root, async () => {
+        const source = await readPrivateFile(path, options.root);
+        const baseline = source ?? "# Loop state\n";
+        const previous = parseSessionMarker(source);
+        const taskId = options.taskId ?? previous.taskId;
+        await writePrivateFile(path, applyManagedBlock(baseline, {
+            id: LOOP_SESSION_ID,
+            version: 1,
+            content: [
+                `Session: ${options.sessionId}`,
+                ...(taskId === undefined ? [] : [`Task: ${taskId}`])
+            ].join("\n")
+        }), options.root);
+    });
+}
+/**
+ * The session id a hook recorded for this checkout, for commands the host
+ * never tells. Both harness directories are considered and the most recently
+ * written marker wins, because a checkout may carry both.
+ */
+export async function readRecordedSessionId(root) {
+    const candidates = [];
+    for (const harness of ["claude", "codex"]) {
+        const path = loopPath(root, harness, "loop-state.md");
+        try {
+            const marker = parseSessionMarker(await readPrivateFile(path, root));
+            if (marker.sessionId === undefined) {
+                continue;
+            }
+            const status = await lstat(path);
+            candidates.push({ sessionId: marker.sessionId, at: status.mtimeMs });
+        }
+        catch {
+            continue;
+        }
+    }
+    return candidates.sort((left, right) => right.at - left.at)[0]?.sessionId;
+}
+/**
+ * The task attached to this session, never merely the most recent one: a
+ * checkpoint from somebody else's task is worse than none. When this session
+ * is unknown, the previous task is offered as a one-line pointer instead, so
+ * the agent can attach to it deliberately.
+ */
+async function restoreState(options) {
+    const marker = parseSessionMarker(await readPrivateFile(loopPath(options.root, options.harness, "loop-state.md"), options.root));
+    const state = parseTaskStateSource(await readPrivateFile(join(options.root, ".agent-ops", "tasks", "state.json"), options.root));
+    const attachment = options.sessionId === undefined
+        ? undefined
+        : state.sessions.find((candidate) => candidate.sessionId === options.sessionId);
+    const attached = attachment === undefined
+        ? undefined
+        : state.tasks.find((record) => record.task.id === attachment.taskId);
+    if (attached !== undefined) {
+        return {
+            checkpoint: renderTaskCheckpoint(attached, DEFAULT_CHECKPOINT_BUDGET, (value) => safeStateContext(value, "task-checkpoint")),
+            // A fresh start of an attached session — `/clear` keeps the id — is told
+            // the task exists without being handed its contents.
+            pointer: `Attached task here: ${attached.task.id} — its state was not ` +
+                `injected; read it with \`agent-ops task status --task ` +
+                `${attached.task.id}\`.`,
+            taskId: attached.task.id,
+            outcome: "hit"
+        };
+    }
+    const previous = marker.taskId === undefined
+        ? undefined
+        : state.tasks.find((record) => record.task.id === marker.taskId && record.status === "active");
+    if (previous === undefined) {
+        return { outcome: "miss" };
+    }
+    return {
+        pointer: `Last active task here: ${previous.task.id} — ` +
+            `attach it with \`agent-ops task attach --task ${previous.task.id}\` ` +
+            "to restore its state, or start a new one.",
+        taskId: previous.task.id,
+        outcome: "pointer"
+    };
+}
+function clamp(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, limit - 14)}\n[truncated]`;
+}
+function sessionContext(options) {
+    // Task state is assembled first and clamped on its own budget, so a long
+    // goal can no longer crowd out the one thing recovery exists to carry.
+    // Strictly one shape per mode. A resumed transcript still holds the state,
+    // and a fresh session is offered the previous task rather than handed its
+    // contents: `/clear` keeps the session id, so an attachment alone must not
+    // be read as "this context still knows the task".
+    const restored = (() => {
+        if (options.mode === "compact") {
+            // Already sanitized field by field, and never clamped here: the
+            // criterion ids and the evidence pointer are required, and slicing the
+            // assembled text is what would cut through them.
+            return options.restore.checkpoint === undefined
+                ? []
+                : [options.restore.checkpoint, ""];
+        }
+        if (options.mode === "fresh") {
+            const pointer = options.restore.pointer === undefined
+                ? undefined
+                : safeStateContext(options.restore.pointer, "task-pointer");
+            return pointer === undefined ? [] : [pointer, ""];
+        }
+        return [];
+    })();
+    const telemetry = `Telemetry: ${options.telemetryEntries} recent redacted event(s).`;
+    const fixed = [
         "agent-ops project loop is active.",
         "",
-        "Current goal:",
-        goal,
-        "",
-        `Telemetry: ${telemetryEntries} recent redacted event(s).`
-    ].join("\n"));
+        ...restored,
+        telemetry
+    ];
+    // The goal takes what is left rather than a fixed share: a task at the
+    // schema's limits needs most of the ceiling, and dropping the goal line is
+    // better than truncating the state the session is being restored with.
+    const spent = fixed.reduce((total, line) => total + line.length + 1, 0);
+    const goalRoom = Math.min(MAX_GOAL_CHARS, MAX_CONTEXT_CHARS - spent - "Current goal:".length - 2);
+    return boundedContext((goalRoom < MIN_GOAL_CHARS
+        ? fixed
+        : [
+            ...fixed.slice(0, -1),
+            "Current goal:",
+            clamp(options.goal, goalRoom),
+            "",
+            telemetry
+        ]).join("\n"));
 }
 function sessionOutput(harness, context) {
     return {
@@ -398,7 +583,9 @@ export async function runProjectLoop(options) {
         return noOutput();
     }
     const root = await resolveLoopRoot(options.input, options.root, options.harness).catch(() => null);
-    if (root !== null) {
+    // SessionStart records its own event naming the restore outcome, so the
+    // generic record is skipped rather than written twice.
+    if (root !== null && options.event !== "SessionStart") {
         await appendTelemetry({
             root,
             harness: options.harness,
@@ -424,12 +611,48 @@ export async function runProjectLoop(options) {
         }).catch(() => undefined);
     }
     if (options.event === "SessionStart" && root !== null) {
+        const sessionId = sessionIdOf(options.input);
+        const restore = await restoreState({
+            root,
+            harness: options.harness,
+            sessionId
+        }).catch(() => ({ outcome: "miss" }));
+        // Exactly one event per SessionStart, written before the context is built
+        // so a later read failure cannot lose the outcome.
+        await appendTelemetry({
+            root,
+            harness: options.harness,
+            event: "SessionStart",
+            decision: {
+                blocked: false,
+                outcome: "observed",
+                code: `restore-${restore.outcome}`,
+                denial: "none"
+            },
+            ...(options.now === undefined ? {} : { now: options.now }),
+            ...(options.telemetryMaxBytes === undefined
+                ? {}
+                : { maxBytes: options.telemetryMaxBytes })
+        }).catch(() => undefined);
+        if (sessionId !== undefined) {
+            await writeSessionMarker({
+                root,
+                harness: options.harness,
+                sessionId,
+                ...(restore.taskId === undefined ? {} : { taskId: restore.taskId })
+            }).catch(() => undefined);
+        }
         try {
             const [goal, telemetryEntries] = await Promise.all([
                 readPrivateFile(loopPath(root, options.harness, "loop-goal.md"), root),
                 telemetryCount(root, options.harness)
             ]);
-            return sessionOutput(options.harness, sessionContext(safeGoalContext(goal), telemetryEntries));
+            return sessionOutput(options.harness, sessionContext({
+                goal: safeGoalContext(goal),
+                telemetryEntries,
+                mode: restoreMode(options.input),
+                restore
+            }));
         }
         catch {
             return noOutput();

package/dist/runtime/src/review/attestation.js

@@ -1,3 +1,4 @@
+import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { AgentOpsError } from "../fs/paths.js";
 import { sha256 } from "../fs/hash.js";
@@ -25,7 +26,9 @@ function safeAttempt(attempt) {
         status: attempt.status,
         ...(attempt.sessionId === undefined ? {} : { sessionId: safeText(attempt.sessionId) }),
         ...(attempt.reason === undefined ? {} : { reason: safeText(attempt.reason) }),
-        ...(attempt.diagnostic === undefined ? {} : { diagnostic: safeText(attempt.diagnostic) })
+        ...(attempt.diagnostic === undefined ? {} : { diagnostic: safeText(attempt.diagnostic) }),
+        // Numbers only, so the cost of a round survives in the record too.
+        ...(attempt.metrics === undefined ? {} : { metrics: attempt.metrics })
     };
 }
 function safePreflight(attempt) {
@@ -239,6 +242,33 @@ export async function findReviewAttestation(root, sourceFingerprint) {
         return null;
     }
 }
+/**
+ * The stored report behind an attestation, for a caller that wants to reuse
+ * the recorded verdict rather than run the chain again. Returns null unless it
+ * parses, matches this exact source and records a PASS: a reuse path must fail
+ * closed exactly like the gates that read the attestation.
+ */
+export async function readReviewReportArtifact(root, sourceFingerprint) {
+    if (!FINGERPRINT_PATTERN.test(sourceFingerprint)) {
+        return null;
+    }
+    const source = await readPrivateFile(artifactPath(root, sourceFingerprint), root);
+    if (source === null) {
+        return null;
+    }
+    try {
+        const value = JSON.parse(source);
+        return value.sourceFingerprint === sourceFingerprint &&
+            value.status === "PASS" &&
+            value.report !== undefined &&
+            value.adversarial !== undefined
+            ? value
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** A new authorized attempt supersedes any earlier PASS for this source. */
 export async function invalidateReviewAttestation(root, sourceFingerprint) {
     if (!FINGERPRINT_PATTERN.test(sourceFingerprint)) {
@@ -249,3 +279,89 @@ export async function invalidateReviewAttestation(root, sourceFingerprint) {
         await writePrivateFile(path, "null\n", root);
     }
 }
+/** Prior findings stay a short checklist, never a second report to digest. */
+export const MAX_PRIOR_FINDINGS = 20;
+export const MAX_PRIOR_FINDINGS_BYTES = 16 * 1024;
+function blockingFindings(artifact) {
+    // A refuted PASS failed on the adversarial report; otherwise the primary
+    // report is the one that failed.
+    const report = artifact.adversarial?.refuted === true
+        ? artifact.adversarial.report
+        : artifact.report;
+    const findings = [];
+    let bytes = 2;
+    for (const finding of redactReviewReport(report).findings) {
+        if (!finding.blocking) {
+            continue;
+        }
+        const prior = {
+            severity: finding.severity,
+            title: finding.title,
+            details: finding.details,
+            locations: finding.locations,
+            criterionIds: finding.criterionIds
+        };
+        bytes += Buffer.byteLength(JSON.stringify(prior), "utf8") + 1;
+        if (findings.length === MAX_PRIOR_FINDINGS || bytes > MAX_PRIOR_FINDINGS_BYTES) {
+            break;
+        }
+        findings.push(prior);
+    }
+    return findings;
+}
+/**
+ * Blocking findings of this task's most recent decided review, when that
+ * review failed. NOT_RUN artifacts decide nothing and are skipped; a newer
+ * PASS settles the earlier findings, so none are returned. Any unreadable
+ * record is ignored: these are a hint for the next reviewer, and without them
+ * the review simply runs as it always has.
+ */
+export async function findPriorFailingFindings(root, taskId) {
+    const directory = join(root, ...REVIEW_ATTESTATION_DIRECTORY.split("/"));
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch {
+        return [];
+    }
+    // ponytail: linear scan of every report; index by task if the directory grows large.
+    let latest;
+    for (const name of names) {
+        const fingerprint = name.slice(0, -REVIEW_REPORT_ARTIFACT_SUFFIX.length);
+        if (!name.endsWith(REVIEW_REPORT_ARTIFACT_SUFFIX) || !FINGERPRINT_PATTERN.test(fingerprint)) {
+            continue;
+        }
+        try {
+            const source = await readPrivateFile(artifactPath(root, fingerprint), root);
+            if (source === null) {
+                continue;
+            }
+            const value = JSON.parse(source);
+            const decided = value.status === "PASS" ||
+                (value.status === "FAIL" && value.report !== undefined);
+            if (value?.schemaVersion !== 1 ||
+                value.sourceFingerprint !== fingerprint ||
+                value.taskId !== taskId ||
+                !decided ||
+                !Number.isFinite(Date.parse(value.createdAt))) {
+                continue;
+            }
+            if (latest === undefined || Date.parse(value.createdAt) > Date.parse(latest.createdAt)) {
+                latest = value;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (latest?.status !== "FAIL") {
+        return [];
+    }
+    try {
+        return blockingFindings(latest);
+    }
+    catch {
+        return [];
+    }
+}