@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/runs/shared/acceptance-contract.js

@@ -1,347 +0,0 @@
-import { isRecord, isUnknownArray, recordAt } from "../../shared/unknown.js";
-import { Compile } from "../../shared/native-typebox.js";
-import { AcceptanceOverride } from "../../extension/schemas.js";
-import { formatAcceptanceReportExample } from "./acceptance-reports.js";
-import { DEFAULT_FINALIZATION_MAX_TURNS } from "./acceptance-defaults.js";
-const MAX_FINALIZATION_TURNS = 10;
-const VALID_EVIDENCE = new Set([
-    "changed-files",
-    "tests-added",
-    "commands-run",
-    "validation-output",
-    "residual-risks",
-    "no-staged-files",
-    "diff-summary",
-    "review-findings",
-    "manual-notes",
-]);
-const ACCEPTANCE_KEYS = new Set(Object.keys(recordAt(AcceptanceOverride, "properties") ?? {}));
-const REMOVED_ACCEPTANCE_KEYS = new Set(["level", "finalization", "reason", "review"]);
-const ACCEPTANCE_VALIDATOR = Compile(AcceptanceOverride);
-const EVIDENCE_REPORT_FIELDS = {
-    "changed-files": "changedFiles: array of changed file paths",
-    "tests-added": "testsAddedOrUpdated: array of test files, suites, or cases added/updated",
-    "commands-run": "commandsRun: array of commands with result passed/failed/not-run and a short summary",
-    "validation-output": "validationOutput: array of relevant validation output summaries",
-    "residual-risks": "residualRisks: array of remaining risks or blockers; use [] when none remain",
-    "no-staged-files": "noStagedFiles: boolean",
-    "diff-summary": "diffSummary: non-empty string summarizing changed behavior and important files",
-    "review-findings": "reviewFindings: array of reviewer findings as strings or objects; use [] when no findings remain",
-    "manual-notes": "manualNotes: string for manual notes or external evidence",
-};
-export function formatEvidenceReportFieldMapping(evidence) {
-    return evidence.map((kind) => `- ${kind} -> ${EVIDENCE_REPORT_FIELDS[kind]}`);
-}
-function hasArrayItems(value) {
-    return isUnknownArray(value) && value.length > 0;
-}
-function acceptanceErrorPath(pathLabel, instancePath) {
-    return instancePath
-        .split("/")
-        .slice(1)
-        .reduce((result, part) => {
-        const decoded = part.replaceAll("~1", "/").replaceAll("~0", "~");
-        return /^\d+$/.test(decoded) ? `${result}[${decoded}]` : `${result}.${decoded}`;
-    }, pathLabel);
-}
-function unsupportedAcceptanceFields(value, pathLabel) {
-    const errors = [];
-    if (Object.hasOwn(value, "level")) {
-        errors.push(`${pathLabel}.level is no longer supported; configure criteria, evidence, and verify directly.`);
-    }
-    if (Object.hasOwn(value, "review")) {
-        errors.push(`${pathLabel}.review is not supported; launch a separate parent-controlled reviewer after the worker completes.`);
-    }
-    if (Object.hasOwn(value, "finalization")) {
-        errors.push(`${pathLabel}.finalization is not supported; acceptance contracts always run the self-review loop.`);
-    }
-    if (Object.hasOwn(value, "reason")) {
-        errors.push(`${pathLabel}.reason is not supported because acceptance is disabled by omitting the field.`);
-    }
-    for (const key of Object.keys(value)) {
-        if (!ACCEPTANCE_KEYS.has(key) && !REMOVED_ACCEPTANCE_KEYS.has(key)) {
-            errors.push(`${pathLabel}.${key} is not supported.`);
-        }
-    }
-    return errors;
-}
-function ignoreCriterionAlternative(error, criteria) {
-    const match = error.instancePath.match(/^\/criteria\/(\d+)$/);
-    if (!match) {
-        return false;
-    }
-    const criterion = isUnknownArray(criteria) ? criteria[Number(match[1])] : undefined;
-    if (isRecord(criterion)) {
-        return error.keyword === "anyOf" || error.schemaPath.includes("/anyOf/0");
-    }
-    if (typeof criterion === "string") {
-        return error.keyword === "anyOf" || error.schemaPath.includes("/anyOf/1");
-    }
-    return error.keyword !== "anyOf";
-}
-function schemaTypeSuffix(expected, instancePath) {
-    if (/^\/stopRules\/\d+$/.test(instancePath)) {
-        return "a non-empty string";
-    }
-    return expected === "array" || expected === "object" ? `an ${expected}` : `a ${expected}`;
-}
-function schemaErrorProperties(params, key) {
-    if (!isRecord(params) || !isUnknownArray(params[key])) {
-        return [];
-    }
-    return params[key].filter((property) => typeof property === "string");
-}
-function schemaErrorDetail(error, pathLabel) {
-    const errorPath = acceptanceErrorPath(pathLabel, error.instancePath);
-    if (error.instancePath.endsWith("/timeoutMs")) {
-        return [`${errorPath} must be a positive integer.`];
-    }
-    if (error.instancePath === "/maxFinalizationTurns") {
-        return [`${errorPath} must be an integer from 1 to ${MAX_FINALIZATION_TURNS}.`];
-    }
-    switch (error.keyword) {
-        case "anyOf":
-            return [`${errorPath} must be a string or object.`];
-        case "required":
-            return schemaErrorProperties(error.params, "requiredProperties").map((property) => `${errorPath}.${property} is required.`);
-        case "additionalProperties":
-            return schemaErrorProperties(error.params, "additionalProperties").map((property) => error.instancePath.endsWith("/env")
-                ? `${errorPath}.${property} must be a string.`
-                : `${errorPath}.${property} is not supported.`);
-        case "enum":
-            if (error.instancePath.includes("/evidence/")) {
-                return [`${errorPath} is not a supported evidence kind.`];
-            }
-            if (error.instancePath.endsWith("/severity")) {
-                return [`${errorPath} must be required or recommended.`];
-            }
-            return [`${errorPath} ${error.message}.`];
-        case "type": {
-            const type = recordAt(error, "params")?.type;
-            const expected = typeof type === "string" ? type : "unknown";
-            return [`${errorPath} must be ${schemaTypeSuffix(expected, error.instancePath)}.`];
-        }
-        default:
-            return [`${errorPath} ${error.message}.`];
-    }
-}
-function acceptanceSchemaErrors(value, pathLabel) {
-    const structuralValue = Object.fromEntries(Object.entries(value).filter(([key]) => ACCEPTANCE_KEYS.has(key)));
-    return ACCEPTANCE_VALIDATOR.Errors(structuralValue).flatMap((error) => {
-        if (error.keyword === "minLength" || ignoreCriterionAlternative(error, value.criteria)) {
-            return [];
-        }
-        return schemaErrorDetail(error, pathLabel);
-    });
-}
-function emptyCriteriaFields(value, pathLabel) {
-    const errors = [];
-    for (const [index, criterion] of isUnknownArray(value) ? value.entries() : []) {
-        if (typeof criterion === "string" && criterion.trim().length === 0) {
-            errors.push(`${pathLabel}.criteria[${index}] must not be empty.`);
-        }
-        if (isRecord(criterion)) {
-            const item = criterion;
-            if (typeof item.id === "string" && item.id.trim().length === 0) {
-                errors.push(`${pathLabel}.criteria[${index}].id is required.`);
-            }
-            if (typeof item.must === "string" && item.must.trim().length === 0) {
-                errors.push(`${pathLabel}.criteria[${index}].must is required.`);
-            }
-        }
-    }
-    return errors;
-}
-function emptyVerificationFields(value, pathLabel) {
-    const errors = [];
-    for (const [index, command] of isUnknownArray(value) ? value.entries() : []) {
-        if (!isRecord(command)) {
-            continue;
-        }
-        const item = command;
-        if (typeof item.id === "string" && item.id.trim().length === 0) {
-            errors.push(`${pathLabel}.verify[${index}].id is required.`);
-        }
-        if (typeof item.command === "string" && item.command.trim().length === 0) {
-            errors.push(`${pathLabel}.verify[${index}].command is required.`);
-        }
-    }
-    return errors;
-}
-function emptyStopRules(value, pathLabel) {
-    const errors = [];
-    for (const [index, rule] of isUnknownArray(value) ? value.entries() : []) {
-        if (typeof rule === "string" && rule.trim().length === 0) {
-            errors.push(`${pathLabel}.stopRules[${index}] must be a non-empty string.`);
-        }
-    }
-    return errors;
-}
-export function validateAcceptanceInput(input, pathLabel = "acceptance") {
-    if (input === undefined) {
-        return [];
-    }
-    if (input === false || typeof input === "string") {
-        return [
-            `${pathLabel} must be an object. Public acceptance levels and false disables are no longer supported.`,
-        ];
-    }
-    if (!isRecord(input)) {
-        return [`${pathLabel} must be an object.`];
-    }
-    const value = input;
-    const errors = [
-        ...unsupportedAcceptanceFields(value, pathLabel),
-        ...acceptanceSchemaErrors(value, pathLabel),
-        ...emptyCriteriaFields(value.criteria, pathLabel),
-        ...emptyVerificationFields(value.verify, pathLabel),
-        ...emptyStopRules(value.stopRules, pathLabel),
-    ];
-    if (!hasArrayItems(value.criteria) &&
-        !hasArrayItems(value.evidence) &&
-        !hasArrayItems(value.verify) &&
-        !hasArrayItems(value.stopRules)) {
-        errors.push(`${pathLabel} must include at least one of criteria, evidence, verify, or stopRules.`);
-    }
-    return [...new Set(errors)];
-}
-function normalizeCriteria(criteria, evidence) {
-    return (criteria ?? [])
-        .map((criterion, index) => {
-        if (typeof criterion === "string") {
-            return {
-                id: `criterion-${index + 1}`,
-                must: criterion,
-                evidence,
-                severity: "required",
-            };
-        }
-        return {
-            id: criterion.id.trim(),
-            must: criterion.must,
-            evidence: criterion.evidence?.filter((item) => VALID_EVIDENCE.has(item)) ?? evidence,
-            severity: criterion.severity ?? "required",
-        };
-    })
-        .filter((criterion) => criterion.must.trim().length > 0);
-}
-function deriveAcceptanceLevel(config) {
-    if ((config.verify?.length ?? 0) > 0) {
-        return "verified";
-    }
-    return "checked";
-}
-export function resolveEffectiveAcceptance(input) {
-    if (input.explicit === undefined) {
-        return {
-            level: "none",
-            explicit: false,
-            inferredReason: ["acceptance not configured"],
-            criteria: [],
-            evidence: [],
-            verify: [],
-            stopRules: [],
-            finalization: { mode: "none", maxTurns: 0 },
-        };
-    }
-    const validationErrors = validateAcceptanceInput(input.explicit);
-    if (validationErrors.length > 0) {
-        throw new Error(validationErrors.join(" "));
-    }
-    const explicit = input.explicit;
-    const evidence = [...new Set(explicit.evidence ?? [])];
-    const criteria = normalizeCriteria(explicit.criteria, evidence);
-    const verify = explicit.verify ?? [];
-    const stopRules = explicit.stopRules ?? [];
-    return {
-        level: deriveAcceptanceLevel(explicit),
-        explicit: true,
-        inferredReason: ["explicit acceptance contract"],
-        criteria,
-        evidence,
-        verify,
-        stopRules,
-        finalization: {
-            mode: "self-review-loop",
-            maxTurns: explicit.maxFinalizationTurns ?? DEFAULT_FINALIZATION_MAX_TURNS,
-        },
-    };
-}
-export function acceptanceInputFromResolved(acceptance) {
-    if (acceptance?.explicit !== true) {
-        return undefined;
-    }
-    const maxTurns = acceptance.finalization.maxTurns;
-    return {
-        criteria: acceptance.criteria,
-        evidence: acceptance.evidence,
-        verify: acceptance.verify,
-        stopRules: acceptance.stopRules,
-        maxFinalizationTurns: maxTurns,
-    };
-}
-export function shouldRunAcceptanceFinalization(acceptance) {
-    return (acceptance.explicit &&
-        acceptance.finalization.mode === "self-review-loop" &&
-        acceptance.finalization.maxTurns > 0);
-}
-export function acceptanceSelfReviewConfig(acceptance) {
-    if (acceptance.verify.length === 0) {
-        return acceptance;
-    }
-    return {
-        ...acceptance,
-        level: "checked",
-        verify: [],
-    };
-}
-export function formatAcceptanceRequirements(criteria, evidence, emptyCriteria) {
-    const criteriaLines = criteria.length > 0
-        ? criteria.map((criterion) => `- ${criterion.id}: ${criterion.must}${criterion.evidence.length > 0 ? ` (evidence: ${criterion.evidence.join(", ")})` : ""}`)
-        : [emptyCriteria];
-    return [
-        "Criteria:",
-        ...criteriaLines,
-        "",
-        `Required evidence: ${evidence.length > 0 ? evidence.join(", ") : "none explicitly requested"}`,
-    ];
-}
-export function formatAcceptancePrompt(acceptance, nativeReport = false) {
-    if (acceptance.level === "none") {
-        return "";
-    }
-    const evidence = [
-        ...new Set([
-            ...acceptance.evidence,
-            ...acceptance.criteria.flatMap((criterion) => criterion.evidence),
-        ]),
-    ];
-    const lines = [
-        "",
-        "## Acceptance Contract",
-        nativeReport
-            ? "Completion is not accepted from prose alone. Finish the initial response with a sole structured_output tool call containing {value:{answer,report}}. answer is the complete standalone visible answer; report is a typed object, never JSON embedded in a string."
-            : "Completion is not accepted from prose alone. End the initial response with a structured acceptance report.",
-        "After the initial response, the runtime will continue this same session for a bounded self-review/repair loop before accepting the run.",
-        "For an observed human-only boundary (such as Touch ID or an unavailable MFA code), report the affected criterion as blocked with concrete evidence and a nonempty humanAction stating the exact user action. Retain completed evidence. This leaves acceptance incomplete and stops finalization/verification until explicit Continue. Do not use blocked for ordinary errors, missing unrelated evidence, or work you can fix.",
-        "Check early whether you can verify each criterion here. Apart from the human-only boundary above, if one needs a service, credential, device, network, or tool you cannot reach, say so right away (send a contact_supervisor progress_update when available), finish the verifiable work, and report that criterion not-satisfied with the missing prerequisite in residualRisks instead of spending turns on workarounds.",
-        "",
-        ...formatAcceptanceRequirements(acceptance.criteria, evidence, "- No explicit criteria were configured; satisfy the requested task and the required evidence/checks below."),
-    ];
-    if (evidence.length > 0) {
-        lines.push("", `Structured evidence must be present in the ${nativeReport ? "typed report object" : "`acceptance-report` JSON fields"}. Markdown sections in your visible answer do not satisfy required evidence by themselves. If you already described evidence in prose, copy or summarize it into the matching JSON field.`, "Evidence field mapping:", ...formatEvidenceReportFieldMapping(evidence));
-    }
-    if (acceptance.verify.length > 0) {
-        lines.push("", "Runtime verification commands configured by parent:");
-        for (const command of acceptance.verify) {
-            lines.push(`- ${command.id}: ${command.command}`);
-        }
-    }
-    if (acceptance.stopRules.length > 0) {
-        lines.push("", "Stop rules:", ...acceptance.stopRules.map((rule) => `- ${rule}`));
-    }
-    lines.push("", nativeReport
-        ? "Submit this shape through structured_output; do not emit a fenced acceptance-report:"
-        : "Finish with a fenced JSON block tagged `acceptance-report` in this shape:", formatAcceptanceReportExample(nativeReport));
-    return lines.join("\n");
-}

package/dist/runs/shared/acceptance-defaults.js

@@ -1 +0,0 @@
-export const DEFAULT_FINALIZATION_MAX_TURNS = 3;

package/dist/runs/shared/acceptance-evaluation.js

@@ -1,276 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { isUnknownArray } from "../../shared/unknown.js";
-import { isAcceptanceReport, parseAcceptanceReport, validateAcceptanceReportShape, } from "./acceptance-reports.js";
-import { runVerifyCommand } from "./acceptance-verification.js";
-const LEVEL_RANK = {
-    none: 0,
-    attested: 1,
-    checked: 2,
-    verified: 3,
-};
-function isStringArray(value) {
-    return isUnknownArray(value) && value.every((item) => typeof item === "string");
-}
-function nonemptyStringArray(value) {
-    return isUnknownArray(value) && value.length > 0 && isStringArray(value);
-}
-function evidenceStatus(present, blocked) {
-    if (present) {
-        return "passed";
-    }
-    return blocked ? "blocked" : "failed";
-}
-function criterionCheck(criterion, item) {
-    const id = `criterion:${criterion.id}`;
-    if (!item) {
-        return {
-            id,
-            status: "failed",
-            message: `Required criterion '${criterion.id}' was not reported.`,
-        };
-    }
-    if (item.status === "blocked") {
-        return {
-            id,
-            status: "blocked",
-            message: `Needs human action: ${item.humanAction ?? ""}. Evidence: ${item.evidence}`,
-        };
-    }
-    if (item.status !== "satisfied") {
-        return {
-            id,
-            status: "failed",
-            message: `Required criterion '${criterion.id}' was reported as ${item.status}.`,
-        };
-    }
-    return { id, status: "passed", message: `Required criterion '${criterion.id}' satisfied.` };
-}
-function checkCriteriaSatisfied(criteria, report) {
-    const reports = new Map((report.criteriaSatisfied ?? [])
-        .filter((item) => (item.id ?? "").length > 0)
-        .map((item) => [item.id, item]));
-    return criteria
-        .filter((item) => item.severity !== "recommended")
-        .flatMap((criterion) => {
-        const item = reports.get(criterion.id);
-        const checks = [criterionCheck(criterion, item)];
-        for (const kind of criterion.evidence) {
-            const present = reportEvidencePresent(report, kind);
-            checks.push({
-                id: `criterion:${criterion.id}:evidence:${kind}`,
-                status: evidenceStatus(present, item?.status === "blocked"),
-                message: present
-                    ? `${kind} evidence present for '${criterion.id}'.`
-                    : `${kind} evidence missing for required criterion '${criterion.id}'.`,
-            });
-        }
-        return checks;
-    });
-}
-function reportEvidencePresent(report, kind) {
-    switch (kind) {
-        case "changed-files":
-            return nonemptyStringArray(report.changedFiles);
-        case "tests-added":
-            return nonemptyStringArray(report.testsAddedOrUpdated);
-        case "commands-run":
-            return report.commandsRun?.some((command) => command.result !== "not-run") === true;
-        case "validation-output":
-            return nonemptyStringArray(report.validationOutput);
-        case "residual-risks":
-            return isStringArray(report.residualRisks);
-        case "no-staged-files":
-            return report.noStagedFiles === true;
-        case "diff-summary":
-            return (report.diffSummary ?? "").trim().length > 0;
-        case "review-findings":
-            return report.reviewFindings !== undefined;
-        case "manual-notes":
-            return (report.manualNotes ?? report.notes ?? "").trim().length > 0;
-    }
-}
-function checkNoStagedFiles(cwd) {
-    const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
-    if (result.status !== 0) {
-        return {
-            id: "no-staged-files",
-            status: "not-applicable",
-            message: "git status unavailable; no staged-files check skipped",
-        };
-    }
-    const staged = result.stdout
-        .split(/\r?\n/)
-        .filter((line) => line.length >= 2 && line[0] !== " " && line[0] !== "?");
-    return staged.length === 0
-        ? { id: "no-staged-files", status: "passed", message: "No staged files detected." }
-        : {
-            id: "no-staged-files",
-            status: "failed",
-            message: `Staged files present: ${staged.join(", ")}`,
-        };
-}
-function unconfiguredBlockedChecks(report) {
-    return (report.criteriaSatisfied ?? [])
-        .filter((item) => item.status === "blocked")
-        .map((item) => ({
-        id: `criterion:${item.id ?? "human-action"}`,
-        status: "blocked",
-        message: `Needs human action: ${item.humanAction ?? ""}. Evidence: ${item.evidence}`,
-    }));
-}
-function runStructuralChecks(acceptance, report) {
-    const checks = checkCriteriaSatisfied(acceptance.criteria, report);
-    if (acceptance.criteria.length === 0) {
-        checks.push(...unconfiguredBlockedChecks(report));
-    }
-    const blockedCriteria = new Set((report.criteriaSatisfied ?? [])
-        .filter((criterion) => criterion.status === "blocked")
-        .map((criterion) => criterion.id));
-    const blockedEvidence = new Set(acceptance.criteria
-        .filter((criterion) => blockedCriteria.has(criterion.id))
-        .flatMap((criterion) => criterion.evidence));
-    for (const kind of acceptance.evidence) {
-        const present = reportEvidencePresent(report, kind);
-        const deferred = blockedEvidence.has(kind) || (acceptance.criteria.length === 0 && blockedCriteria.size > 0);
-        checks.push({
-            id: `evidence:${kind}`,
-            status: evidenceStatus(present, deferred),
-            message: present
-                ? `${kind} evidence present.`
-                : `${kind} evidence missing from child report.`,
-        });
-    }
-    return checks;
-}
-function readReport(input) {
-    if (input.report === undefined) {
-        return parseAcceptanceReport(input.output);
-    }
-    if (isAcceptanceReport(input.report)) {
-        return { report: input.report };
-    }
-    return {
-        error: `Acceptance report is invalid: ${validateAcceptanceReportShape(input.report) ?? "unrecognized report"}`,
-    };
-}
-function requiresStructuralChecks(acceptance, report) {
-    return (LEVEL_RANK[acceptance.level] >= LEVEL_RANK.checked ||
-        report.criteriaSatisfied?.some((item) => item.status === "blocked") === true);
-}
-function structuralStatus(checks) {
-    if (checks.some((check) => check.status === "failed")) {
-        return "rejected";
-    }
-    return checks.some((check) => check.status === "blocked") ? "blocked" : "checked";
-}
-/** Structural evidence only. The run owner must still perform runtime checks before acceptance. */
-export function evaluateAcceptanceReport(input) {
-    const { acceptance } = input;
-    const ledger = {
-        status: acceptance.level === "none" ? "not-required" : "claimed",
-        explicit: acceptance.explicit,
-        effectiveAcceptance: input.governing ?? acceptance,
-        inferredReason: acceptance.inferredReason,
-        criteria: acceptance.criteria,
-        runtimeChecks: [],
-        verifyRuns: [],
-    };
-    if (acceptance.level === "none") {
-        return ledger;
-    }
-    const parsed = readReport(input);
-    if (!parsed.report) {
-        return {
-            ...ledger,
-            childReportParseError: parsed.error,
-            runtimeChecks: [
-                {
-                    id: "attestation",
-                    status: "failed",
-                    message: parsed.error ?? "Structured acceptance report missing.",
-                },
-            ],
-            status: "rejected",
-        };
-    }
-    if (!requiresStructuralChecks(acceptance, parsed.report)) {
-        return { ...ledger, childReport: parsed.report, status: "attested" };
-    }
-    const runtimeChecks = runStructuralChecks(acceptance, parsed.report);
-    return {
-        ...ledger,
-        childReport: parsed.report,
-        runtimeChecks,
-        status: structuralStatus(runtimeChecks),
-    };
-}
-function requiresStagedCheck(acceptance, report) {
-    return (requiresStructuralChecks(acceptance, report) &&
-        (acceptance.evidence.includes("no-staged-files") ||
-            acceptance.criteria.some((criterion) => criterion.evidence.includes("no-staged-files"))));
-}
-function cancelledVerification(ledger) {
-    return {
-        ...ledger,
-        runtimeChecks: [
-            ...ledger.runtimeChecks,
-            { id: "cancelled", status: "failed", message: "Acceptance verification cancelled." },
-        ],
-        status: "rejected",
-    };
-}
-function canRunVerification(ledger, acceptance) {
-    return (ledger.status !== "rejected" && ledger.status !== "blocked" && acceptance.verify.length > 0);
-}
-export async function evaluateAcceptance(input) {
-    const { acceptance } = input;
-    let ledger = evaluateAcceptanceReport(input);
-    if (!ledger.childReport) {
-        return ledger;
-    }
-    if (requiresStagedCheck(acceptance, ledger.childReport)) {
-        const check = checkNoStagedFiles(input.cwd);
-        ledger = {
-            ...ledger,
-            runtimeChecks: [...ledger.runtimeChecks, check],
-            status: check.status === "failed" ? "rejected" : ledger.status,
-        };
-    }
-    if (!canRunVerification(ledger, acceptance)) {
-        return ledger;
-    }
-    const verifyRuns = [];
-    for (const command of acceptance.verify) {
-        if (input.signal?.aborted === true) {
-            return cancelledVerification({ ...ledger, verifyRuns });
-        }
-        // Verification commands are ordered and can depend on prior commands' effects.
-        // oxlint-disable-next-line no-await-in-loop
-        verifyRuns.push(await runVerifyCommand(command, input.cwd, input.signal));
-    }
-    const failed = verifyRuns.some((run) => run.status === "failed" || run.status === "timed-out");
-    return { ...ledger, verifyRuns, status: failed ? "rejected" : "verified" };
-}
-export function acceptanceHumanAction(ledger) {
-    if (ledger?.status !== "blocked") {
-        return undefined;
-    }
-    return ledger.childReport?.criteriaSatisfied
-        ?.filter((criterion) => criterion.status === "blocked")
-        .map((criterion) => `${criterion.id ?? "Criterion"}: ${criterion.humanAction ?? ""}\nEvidence: ${criterion.evidence}`)
-        .join("\n");
-}
-export function acceptanceFailureMessage(ledger) {
-    if (ledger.status !== "rejected") {
-        return undefined;
-    }
-    const failedCheck = ledger.runtimeChecks.find((check) => check.status === "failed");
-    if (failedCheck) {
-        return `Acceptance rejected: ${failedCheck.message}`;
-    }
-    const failedVerify = ledger.verifyRuns.find((run) => run.status === "failed" || run.status === "timed-out");
-    if (failedVerify) {
-        return `Acceptance verification '${failedVerify.id}' ${failedVerify.status}.`;
-    }
-    return "Acceptance rejected.";
-}