@fitchmultz/pi-subagents 0.49.0 → 0.50.0

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

@@ -1,356 +0,0 @@
-import { acceptanceFailureMessage, evaluateAcceptance } from "./acceptance-evaluation.js";
-import { acceptanceSelfReviewConfig, formatEvidenceReportFieldMapping, formatAcceptanceRequirements, shouldRunAcceptanceFinalization, } from "./acceptance-contract.js";
-export { resolveExecutionOutcome } from "./acceptance-outcome.js";
-import { formatAcceptanceReportExample, parseAcceptanceReport, stripAcceptanceReport, } from "./acceptance-reports.js";
-import { reportAuditOutput } from "./acceptance-submission.js";
-export { createFinalizationReportRuntime, readFinalizationReport, } from "./acceptance-submission.js";
-export function formatUnconfirmedFinalizationOutput(output) {
-    return `UNCONFIRMED task report — retained for audit only; finalization did not deliver a current complete report.\n\n${stripAcceptanceReport(output)}`;
-}
-export function resolveFinalizationOutput(rawOutput, previousOutput) {
-    const prose = stripAcceptanceReport(rawOutput);
-    if (prose.trim().length > 0) {
-        return prose;
-    }
-    const report = parseAcceptanceReport(rawOutput).report;
-    const summary = report?.diffSummary?.trim() ?? "";
-    if (summary.length > 0) {
-        return summary;
-    }
-    const notes = report?.notes?.trim() ?? "";
-    return notes.length > 0 ? notes : previousOutput;
-}
-function skipSelfReview(input, ledger) {
-    return (ledger.status === "blocked" ||
-        !shouldRunAcceptanceFinalization(input.acceptance) ||
-        input.initial.exitCode !== 0 ||
-        (input.initial.error ?? "").length > 0 ||
-        input.initial.interrupted === true ||
-        (input.signal?.aborted === true && (input.recordedTurns ?? 0) === 0));
-}
-/** Owns ordered continuation, cumulative audit evidence, and the authoritative current ledger. */
-class AcceptanceReview {
-    input;
-    initialLedger;
-    selfReview;
-    turns = [];
-    authoritativeLedger;
-    previousFailure;
-    auditOutput;
-    constructor(input, initialLedger, selfReview) {
-        this.input = input;
-        this.initialLedger = initialLedger;
-        this.selfReview = selfReview;
-        this.authoritativeLedger = initialLedger;
-        this.previousFailure = acceptanceFailureMessage(initialLedger);
-        this.auditOutput = reportAuditOutput({
-            output: input.initialOutput,
-            report: input.initialReport,
-        });
-    }
-    finish(status) {
-        return attachFinalizationToLedger({
-            initialLedger: this.initialLedger,
-            authoritativeLedger: this.authoritativeLedger,
-            turns: this.turns,
-            status,
-            maxTurns: this.input.acceptance.finalization.maxTurns,
-        });
-    }
-    processFailure(result, turn, prompt) {
-        if (result.error === undefined || result.error.length === 0) {
-            return undefined;
-        }
-        this.turns.push({
-            ...createFinalizationProcessFailureTurn({
-                turn,
-                prompt,
-                rawOutput: result.output,
-                message: result.error,
-            }),
-            ...(this.input.nativeReport === true ? { unconfirmedOutput: this.auditOutput } : {}),
-        });
-        const ledger = buildFinalizationProcessFailureLedger({
-            initialLedger: this.initialLedger,
-            turns: this.turns,
-            maxTurns: this.input.acceptance.finalization.maxTurns,
-            message: result.error,
-        });
-        return this.input.nativeReport === true
-            ? {
-                ...ledger,
-                childReport: undefined,
-                childReportParseError: result.reportSubmissionError,
-                unconfirmedOutput: this.auditOutput,
-            }
-            : ledger;
-    }
-    async evaluateTurn(result) {
-        const submissionError = result.reportSubmissionError;
-        const rejectedSubmission = submissionError !== undefined && submissionError.length > 0;
-        // Replay the native boundary's checks, not the workspace left by a later repair.
-        let ledger = !rejectedSubmission && result.acceptance
-            ? result.acceptance
-            : await evaluateAcceptance({
-                acceptance: this.selfReview,
-                governing: this.input.acceptance,
-                output: rejectedSubmission ? "" : result.output,
-                report: rejectedSubmission ? undefined : result.report,
-                cwd: this.input.cwd,
-                signal: this.input.signal,
-            });
-        if (rejectedSubmission) {
-            ledger = {
-                ...ledger,
-                childReportParseError: submissionError,
-                runtimeChecks: [{ id: "finalization-report", status: "failed", message: submissionError }],
-            };
-        }
-        if (this.input.nativeReport === true && (ledger.childReportParseError ?? "").length > 0) {
-            ledger = { ...ledger, unconfirmedOutput: this.auditOutput };
-        }
-        return ledger;
-    }
-    async completeReview(result) {
-        if (result.acceptance || this.selfReview !== this.input.acceptance) {
-            this.authoritativeLedger = await evaluateAcceptance({
-                acceptance: this.input.acceptance,
-                output: result.output,
-                report: result.report,
-                cwd: this.input.cwd,
-                signal: this.input.signal,
-            });
-        }
-        return this.finish(this.input.signal?.aborted === true ? "failed" : "completed");
-    }
-    runTurn(turn, prompt) {
-        if (this.input.signal?.aborted === true && turn > (this.input.recordedTurns ?? 0)) {
-            return Promise.resolve({ output: "", error: "Acceptance finalization cancelled." });
-        }
-        return this.input.runTurn(prompt, turn, this.input.sessionFile);
-    }
-    retainAudit(result) {
-        const retained = result.unconfirmedOutput ?? reportAuditOutput(result);
-        if (this.input.nativeReport === true && parseAcceptanceReport(retained).report) {
-            this.auditOutput = retained;
-        }
-    }
-    async performTurn(turn) {
-        const prompt = formatAcceptanceFinalizationPrompt({
-            acceptance: this.input.acceptance,
-            initialOutput: this.input.initialOutput,
-            initialLedger: this.initialLedger,
-            turn,
-            maxTurns: this.input.acceptance.finalization.maxTurns,
-            previousFailure: this.previousFailure,
-            nativeReport: this.input.nativeReport,
-            outputSchema: this.input.outputSchema,
-        });
-        const result = await this.runTurn(turn, prompt);
-        this.retainAudit(result);
-        const processFailure = this.processFailure(result, turn, prompt);
-        if (processFailure) {
-            return processFailure;
-        }
-        this.authoritativeLedger = await this.evaluateTurn(result);
-        this.turns.push(createFinalizationTurn({
-            turn,
-            prompt,
-            rawOutput: result.output,
-            ledger: this.authoritativeLedger,
-        }));
-        if (this.authoritativeLedger.status === "blocked") {
-            return this.finish("blocked");
-        }
-        const failure = acceptanceFailureMessage(this.authoritativeLedger);
-        if (failure === undefined && this.input.signal?.aborted !== true) {
-            return this.completeReview(result);
-        }
-        if (this.input.signal?.aborted === true) {
-            return this.finish("failed");
-        }
-        this.previousFailure = failure;
-        return undefined;
-    }
-    async run() {
-        for (let turn = 1; turn <= this.input.acceptance.finalization.maxTurns; turn++) {
-            // Each repair resumes the same session and consumes the preceding turn's authoritative outcome.
-            // oxlint-disable-next-line no-await-in-loop
-            const finished = await this.performTurn(turn);
-            if (finished) {
-                return finished;
-            }
-        }
-        return this.finish("failed");
-    }
-}
-export async function evaluateRunAcceptance(input) {
-    const review = shouldRunAcceptanceFinalization(input.acceptance);
-    const selfReview = review ? acceptanceSelfReviewConfig(input.acceptance) : input.acceptance;
-    const initialLedger = input.initialAcceptance ??
-        (await evaluateAcceptance({
-            acceptance: selfReview,
-            governing: input.acceptance,
-            output: input.initialOutput,
-            report: input.initialReport,
-            cwd: input.cwd,
-            signal: input.signal,
-        }));
-    if (skipSelfReview(input, initialLedger)) {
-        return initialLedger;
-    }
-    if (input.sessionFile === undefined || input.sessionFile.length === 0) {
-        const message = "Acceptance finalization requires a session file for same-session continuation.";
-        const turns = [createFinalizationProcessFailureTurn({ turn: 1, prompt: "", message })];
-        return buildFinalizationProcessFailureLedger({
-            initialLedger,
-            turns,
-            maxTurns: input.acceptance.finalization.maxTurns,
-            message,
-        });
-    }
-    return new AcceptanceReview({ ...input, sessionFile: input.sessionFile }, initialLedger, selfReview).run();
-}
-const INITIAL_OUTPUT_LIMIT = 8_000;
-function truncateForPrompt(value) {
-    const trimmed = stripAcceptanceReport(value).trim();
-    if (trimmed.length <= INITIAL_OUTPUT_LIMIT) {
-        return trimmed.length > 0
-            ? trimmed
-            : "(initial output was empty after removing acceptance-report)";
-    }
-    return `${trimmed.slice(0, INITIAL_OUTPUT_LIMIT)}\n...[truncated]`;
-}
-function formatReportForPrompt(ledger) {
-    if (ledger.childReport) {
-        return JSON.stringify(ledger.childReport, null, 2);
-    }
-    return `Missing or malformed acceptance report: ${ledger.childReportParseError ?? "no parse detail"}`;
-}
-function initialReviewEvidence(output, ledger, previousFailure) {
-    const lines = [
-        "",
-        "Initial visible output:",
-        truncateForPrompt(output),
-        "",
-        "Initial acceptance report:",
-        formatReportForPrompt(ledger),
-    ];
-    if (previousFailure !== undefined && previousFailure.length > 0) {
-        lines.push("", "Previous finalization failure to address:", previousFailure);
-    }
-    return lines;
-}
-function finalizationInstructions(nativeReport, schema) {
-    if (schema) {
-        const action = nativeReport
-            ? "Your final action must be a sole `structured_output` tool call with {value:{answer,report}}."
-            : "Return the schema-constrained JSON object {answer,report}.";
-        return [
-            `${action} answer must be the complete current public payload matching outputSchema below, including all repairs; do not embed it in a prose string. report is the private typed acceptance object. This submission replaces the initial payload. If more activity follows submission, resubmit the complete current answer and report.\noutputSchema: ${JSON.stringify(schema)}`,
-        ];
-    }
-    const action = nativeReport
-        ? "Now do the self-check. Your final action must be a sole `structured_output` tool call with {value:{answer,report}}. answer must contain the complete standalone final answer with the current result and every requested handoff detail (including paths, identifiers, findings, and evidence), repairs or remaining blockers. report is a typed object matching the schema, never JSON embedded in a string. This answer replaces the initial answer; do not replace useful details with only a statement that you rechecked them. If additional messages prompt more activity after submission, resubmit the complete current answer and report as your final action; a prose-only reply does not finalize the task."
-        : "Now do the self-check. Return a standalone final answer with the current result and every requested handoff detail (including paths, identifiers, findings, and evidence). This answer replaces the initial answer; do not replace useful details with only a statement that you rechecked them. Include repairs or remaining blockers, then finish with exactly one fenced JSON block tagged `acceptance-report`.";
-    return [action, formatAcceptanceReportExample(nativeReport)];
-}
-export function formatAcceptanceFinalizationPrompt(input) {
-    const evidence = [
-        ...new Set([
-            ...input.acceptance.evidence,
-            ...input.acceptance.criteria.flatMap((criterion) => criterion.evidence),
-        ]),
-    ];
-    const lines = [
-        "## Acceptance Finalization",
-        "You are continuing the same subagent session. Before this run can be accepted, compare the current work to the acceptance contract and the evidence below.",
-        `This is finalization turn ${input.turn} of ${input.maxTurns}. The run will be rejected if the contract is still not satisfied after turn ${input.maxTurns}.`,
-        "",
-        "If a criterion is incomplete and fixable in this session, keep working now before returning the final report.",
-        "Only an observed human-only boundary, such as Touch ID or an unavailable MFA code, may use criterion status blocked with concrete evidence and a nonempty humanAction describing the exact action needed. Preserve completed criteria/evidence; blocked acceptance is incomplete and stops further review and verification until explicit Continue. Ordinary errors, missing evidence, or fixable work remain not-satisfied, not blocked; explain the blocker in residualRisks.",
-        "Do not claim a criterion is satisfied unless the current work has concrete evidence from files, commands, validation output, or other inspectable artifacts.",
-        "Report cumulative evidence for the whole delegated task, not just this finalization turn. Retain still-valid changed files, tests, commands, and other evidence from the initial report; correct or remove evidence only when the final state invalidates it. No new edits during review does not mean changedFiles is empty.",
-        "",
-        "## Acceptance Contract",
-        ...formatAcceptanceRequirements(input.acceptance.criteria, evidence, "- No explicit criteria were configured; satisfy the requested task and required evidence/checks."),
-    ];
-    if (evidence.length > 0) {
-        lines.push("", `Structured evidence must be present in the ${input.nativeReport === true || input.outputSchema ? "typed report object" : "final `acceptance-report` JSON fields"}. Markdown sections in the visible answer do not satisfy required evidence by themselves. If the previous visible output already included the evidence, copy or summarize it into the matching JSON field.`, "Evidence field mapping:", ...formatEvidenceReportFieldMapping(evidence));
-    }
-    if (input.acceptance.verify.length > 0) {
-        lines.push("", "Runtime verification commands that must pass:", ...input.acceptance.verify.map((command) => `- ${command.id}: ${command.command}`));
-    }
-    if (input.acceptance.stopRules.length > 0) {
-        lines.push("", "Stop rules are hard constraints while deciding whether to continue, stop as blocked, or report success:", ...input.acceptance.stopRules.map((rule) => `- ${rule}`));
-    }
-    lines.push(...initialReviewEvidence(input.initialOutput, input.initialLedger, input.previousFailure), "", ...finalizationInstructions(input.nativeReport === true, input.outputSchema));
-    return lines.join("\n");
-}
-function createFinalizationTurn(input) {
-    const failureMessage = acceptanceFailureMessage(input.ledger);
-    return {
-        turn: input.turn,
-        prompt: input.prompt,
-        status: input.ledger.status,
-        rawOutput: input.rawOutput,
-        ...(input.ledger.unconfirmedOutput !== undefined
-            ? { unconfirmedOutput: input.ledger.unconfirmedOutput }
-            : {}),
-        ...(input.ledger.childReport ? { report: input.ledger.childReport } : {}),
-        ...(input.ledger.childReportParseError !== undefined &&
-            input.ledger.childReportParseError.length > 0
-            ? { parseError: input.ledger.childReportParseError }
-            : {}),
-        runtimeChecks: input.ledger.runtimeChecks,
-        verifyRuns: input.ledger.verifyRuns,
-        ...(failureMessage !== undefined && failureMessage.length > 0 ? { failureMessage } : {}),
-    };
-}
-export function createFinalizationProcessFailureTurn(input) {
-    return {
-        turn: input.turn,
-        prompt: input.prompt,
-        status: "rejected",
-        ...(input.rawOutput !== undefined && input.rawOutput.length > 0
-            ? { rawOutput: input.rawOutput }
-            : {}),
-        runtimeChecks: [{ id: "finalization-process", status: "failed", message: input.message }],
-        verifyRuns: [],
-        failureMessage: `Acceptance rejected: ${input.message}`,
-    };
-}
-function attachFinalizationToLedger(input) {
-    return {
-        ...input.authoritativeLedger,
-        ...(input.initialLedger.childReport
-            ? { initialChildReport: input.initialLedger.childReport }
-            : {}),
-        ...(input.initialLedger.childReportParseError !== undefined &&
-            input.initialLedger.childReportParseError.length > 0
-            ? { initialChildReportParseError: input.initialLedger.childReportParseError }
-            : {}),
-        finalization: {
-            mode: "self-review-loop",
-            status: input.status,
-            maxTurns: input.maxTurns,
-            turns: input.turns,
-        },
-    };
-}
-export function buildFinalizationProcessFailureLedger(input) {
-    return attachFinalizationToLedger({
-        initialLedger: input.initialLedger,
-        authoritativeLedger: {
-            ...input.initialLedger,
-            status: "rejected",
-            runtimeChecks: [
-                ...input.initialLedger.runtimeChecks,
-                { id: "finalization-process", status: "failed", message: input.message },
-            ],
-        },
-        turns: input.turns,
-        status: "failed",
-        maxTurns: input.maxTurns,
-    });
-}

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

@@ -1,53 +0,0 @@
-import { acceptanceFailureMessage } from "./acceptance-evaluation.js";
-import { isFailFastAbort } from "./parallel-utils.js";
-function cancellationOutcome(input) {
-    const { signal, result } = input;
-    if (signal?.aborted === true) {
-        const reason = signal.reason;
-        if (reason instanceof Error && reason.name === "TimeoutError") {
-            return {
-                ...result,
-                exitCode: 124,
-                timedOut: true,
-                interrupted: false,
-                error: reason.message.length > 0 ? reason.message : "Subagent timed out.",
-            };
-        }
-        return { ...result, exitCode: 1, interrupted: false, error: "Subagent cancelled." };
-    }
-    if (isFailFastAbort(input.interruptSignal)) {
-        return { ...result, exitCode: -1, interrupted: false, error: "Interrupted due to fail-fast" };
-    }
-    return undefined;
-}
-function executionStopOutcome(input) {
-    const { result } = input;
-    if (result.timedOut === true || result.resourceLimitExceeded) {
-        return {
-            ...result,
-            exitCode: result.timedOut === true ? 124 : 1,
-            interrupted: result.interrupted === undefined ? undefined : false,
-        };
-    }
-    if (input.interruptSignal?.aborted === true || result.interrupted === true) {
-        return { ...result, exitCode: 0, interrupted: true, error: undefined };
-    }
-    return undefined;
-}
-function configuredAcceptanceFailure(acceptance) {
-    return acceptance?.explicit === true ? acceptanceFailureMessage(acceptance) : undefined;
-}
-/** Cancellation and resource limits outrank interruption; acceptance only rejects successful execution. */
-export function resolveExecutionOutcome(input) {
-    const stopped = cancellationOutcome(input) ?? executionStopOutcome(input);
-    if (stopped) {
-        return stopped;
-    }
-    const { result } = input;
-    const failure = configuredAcceptanceFailure(input.acceptance);
-    if (failure !== undefined && failure.length > 0 && result.exitCode === 0) {
-        const error = (result.error ?? "").length > 0 ? `${result.error ?? ""}\n${failure}` : failure;
-        return { ...result, exitCode: 1, error };
-    }
-    return result;
-}

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

@@ -1,212 +0,0 @@
-import { isRecord, isUnknownArray, errorMessage } from "../../shared/unknown.js";
-// Open finding objects are intentional: native strict conversion must fall back,
-// rather than discarding caller-defined review evidence.
-export const ACCEPTANCE_REPORT_SCHEMA = {
-    type: "object",
-    properties: {
-        criteriaSatisfied: {
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    id: { type: "string" },
-                    status: {
-                        type: "string",
-                        enum: ["satisfied", "not-satisfied", "not-applicable", "blocked"],
-                    },
-                    evidence: { type: "string", pattern: "\\S" },
-                    humanAction: { type: "string" },
-                },
-                required: ["status", "evidence"],
-                if: { properties: { status: { const: "blocked" } } },
-                // JSON Schema's conditional vocabulary is noncallable data, not a Promise thenable.
-                // oxlint-disable-next-line unicorn/no-thenable
-                then: { required: ["humanAction"], properties: { humanAction: { pattern: "\\S" } } },
-            },
-        },
-        changedFiles: { type: "array", items: { type: "string" } },
-        testsAddedOrUpdated: { type: "array", items: { type: "string" } },
-        commandsRun: {
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    command: { type: "string" },
-                    result: { type: "string", enum: ["passed", "failed", "not-run"] },
-                    summary: { type: "string" },
-                },
-                required: ["command", "result", "summary"],
-            },
-        },
-        validationOutput: { type: "array", items: { type: "string" } },
-        residualRisks: { type: "array", items: { type: "string" } },
-        noStagedFiles: { type: "boolean" },
-        diffSummary: { type: "string" },
-        reviewFindings: {
-            type: "array",
-            items: {
-                anyOf: [
-                    { type: "string" },
-                    { type: "object", minProperties: 1, additionalProperties: true },
-                ],
-            },
-        },
-        manualNotes: { type: "string" },
-        notes: { type: "string" },
-    },
-};
-export function formatAcceptanceReportExample(nativeReport = false) {
-    const report = {
-        criteriaSatisfied: [
-            { id: "criterion-1", status: "satisfied", evidence: "specific proof from the final state" },
-        ],
-        changedFiles: [],
-        testsAddedOrUpdated: [],
-        commandsRun: [{ command: "command", result: "passed", summary: "short result" }],
-        validationOutput: [],
-        residualRisks: [],
-        noStagedFiles: true,
-        diffSummary: "concise summary of changed behavior and important files",
-        reviewFindings: [],
-        manualNotes: "manual notes or external evidence, if any",
-        notes: "self-review summary and remaining work",
-    };
-    return `\`\`\`${nativeReport ? "json" : "acceptance-report"}\n${JSON.stringify(nativeReport ? { value: { answer: "Complete standalone final answer with all requested handoff details", report } } : report, null, 2)}\n\`\`\``;
-}
-export function parseAcceptanceReport(output) {
-    const fenced = [...output.matchAll(/```acceptance-report\s*\n([\s\S]*?)```/gi)]
-        .map((match) => match[1]?.trim())
-        .filter((value) => typeof value === "string" && value.length > 0);
-    const parseErrors = [];
-    for (const body of fenced) {
-        try {
-            const parsed = JSON.parse(body);
-            const report = parsed !== null && typeof parsed === "object" && "acceptance" in parsed
-                ? parsed.acceptance
-                : parsed;
-            const shapeError = validateAcceptanceReportShape(report);
-            if (isAcceptanceReport(report)) {
-                return { report };
-            }
-            parseErrors.push(`acceptance-report block is invalid: ${shapeError ?? "unrecognized report"}`);
-        }
-        catch (error) {
-            parseErrors.push(errorMessage(error));
-        }
-    }
-    if (parseErrors.length > 0) {
-        return { error: `Failed to parse acceptance-report: ${parseErrors.join("; ")}` };
-    }
-    return { error: "Structured acceptance report not found." };
-}
-export function stripAcceptanceReport(output) {
-    return output.replace(/\n?```acceptance-report\s*\n[\s\S]*?```\s*$/i, "").trimEnd();
-}
-function isStringArray(value) {
-    return isUnknownArray(value) && value.every((item) => typeof item === "string");
-}
-function isCriterionReport(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    const criterion = value;
-    if (criterion.id !== undefined && typeof criterion.id !== "string") {
-        return false;
-    }
-    if (typeof criterion.status !== "string" ||
-        !["satisfied", "not-satisfied", "not-applicable", "blocked"].includes(criterion.status)) {
-        return false;
-    }
-    if (criterion.status === "blocked" &&
-        (typeof criterion.humanAction !== "string" || criterion.humanAction.trim().length === 0)) {
-        return false;
-    }
-    return typeof criterion.evidence === "string" && criterion.evidence.trim().length > 0;
-}
-function isCommandReport(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    const command = value;
-    return (typeof command.command === "string" &&
-        (command.result === "passed" || command.result === "failed" || command.result === "not-run") &&
-        typeof command.summary === "string");
-}
-function isReviewFinding(value) {
-    if (typeof value === "string") {
-        return true;
-    }
-    if (!isRecord(value)) {
-        return false;
-    }
-    const values = Object.values(value);
-    return values.some((item) => typeof item === "string" && item.trim().length > 0);
-}
-export function isAcceptanceReport(value) {
-    return validateAcceptanceReportShape(value) === undefined;
-}
-function everyArrayItem(value, valid) {
-    return isUnknownArray(value) && value.every(valid);
-}
-const REPORT_FIELDS = [
-    {
-        key: "criteriaSatisfied",
-        valid: (value) => everyArrayItem(value, isCriterionReport),
-        error: "criteriaSatisfied must be an array of {id?, status, evidence} objects",
-    },
-    { key: "changedFiles", valid: isStringArray, error: "changedFiles must be an array of strings" },
-    {
-        key: "testsAddedOrUpdated",
-        valid: isStringArray,
-        error: "testsAddedOrUpdated must be an array of strings",
-    },
-    {
-        key: "commandsRun",
-        valid: (value) => everyArrayItem(value, isCommandReport),
-        error: "commandsRun must be an array of {command, result, summary} objects with result passed, failed, or not-run",
-    },
-    {
-        key: "validationOutput",
-        valid: isStringArray,
-        error: "validationOutput must be an array of strings",
-    },
-    {
-        key: "residualRisks",
-        valid: isStringArray,
-        error: "residualRisks must be an array of strings",
-    },
-    {
-        key: "noStagedFiles",
-        valid: (value) => typeof value === "boolean",
-        error: "noStagedFiles must be a boolean",
-    },
-    {
-        key: "diffSummary",
-        valid: (value) => typeof value === "string",
-        error: "diffSummary must be a string",
-    },
-    {
-        key: "reviewFindings",
-        valid: (value) => everyArrayItem(value, isReviewFinding),
-        error: "reviewFindings must be an array of strings or non-empty objects with at least one string value",
-    },
-    {
-        key: "manualNotes",
-        valid: (value) => typeof value === "string",
-        error: "manualNotes must be a string",
-    },
-    { key: "notes", valid: (value) => typeof value === "string", error: "notes must be a string" },
-];
-export function validateAcceptanceReportShape(value) {
-    if (!isRecord(value)) {
-        return "acceptance report must be a JSON object";
-    }
-    for (const field of REPORT_FIELDS) {
-        const entry = value[field.key];
-        if (entry !== undefined && !field.valid(entry)) {
-            return field.error;
-        }
-    }
-    const hasReportField = REPORT_FIELDS.some((field) => field.key !== "notes" && value[field.key] !== undefined);
-    return hasReportField ? undefined : "acceptance report must include at least one report field";
-}