@akagilnc/pi-workflow-roles 0.1.1751

package/dist/public-command-renderer.js

@@ -0,0 +1,20 @@
+import {
+  PACKAGED_ROLE_REGISTRY
+} from "./packaged-role-registry.js";
+const PUBLIC_CALLABLE_ROLES = new Set(
+  PACKAGED_ROLE_REGISTRY.map((entry) => entry.role)
+);
+function renderPublicAkRoleCommand(target) {
+  if (!PUBLIC_CALLABLE_ROLES.has(target.role)) return void 0;
+  const role = target.role;
+  if (target.phase === null || target.phase === void 0) {
+    return `ak-role ${role}`;
+  }
+  if (role === "coder" || role === "fixer") {
+    return `ak-role ${role} ${target.phase}`;
+  }
+  return `ak-role ${role}`;
+}
+export {
+  renderPublicAkRoleCommand
+};

package/dist/reviewer-agent.js

@@ -0,0 +1,93 @@
+import { isReviewerPromptText } from "./reviewer-prompt-identity.js";
+import { executeReviewerChild } from "./reviewer-child-executor.js";
+import { createReviewerWorkspaceOwner } from "./reviewer-workspace.js";
+import { normalizeReviewerFailureDiagnostic } from "./reviewer-failure-diagnostic.js";
+function reviewerDispatchFailureMessage(outcome) {
+    const diagnostics = [...new Set(Object.values(outcome.legs)
+            .filter((leg) => leg?.status === "failed")
+            .map((leg) => leg.diagnostic.trim())
+            .filter((diagnostic) => diagnostic.length > 0))];
+    if (diagnostics.length === 0)
+        return "Reviewer dispatch execution failed";
+    return diagnostics.length === 1 ? diagnostics[0] : diagnostics.join("; ");
+}
+export class ReviewerDispatchExecutionError extends Error {
+    outcome;
+    constructor(outcome) {
+        super(reviewerDispatchFailureMessage(outcome));
+        this.outcome = outcome;
+        this.name = "ReviewerDispatchExecutionError";
+    }
+}
+function classify(error, signal) { if (signal?.aborted)
+    return "cancelled"; if (typeof error === "object" && error !== null && "reviewerFailure" in error)
+    return error.reviewerFailure; return "unknown"; }
+function failed(error, target, prompt, signal, retained) {
+    const attached = typeof error === "object" && error !== null ? error : {};
+    const failure = classify(error, signal);
+    const diagnostic = normalizeReviewerFailureDiagnostic(error, failure);
+    return Object.freeze({
+        status: "failed",
+        failure,
+        diagnostic,
+        cause: error,
+        target: attached.targetSnapshot ?? target,
+        prompt,
+        workspaceDisposition: retained === undefined ? attached.workspaceDisposition ?? "not-created" : { retained },
+    });
+}
+export function createReviewerAgentRunner(dependencies = {}) {
+    const workspaceOwner = createReviewerWorkspaceOwner(dependencies.fault === undefined ? {} : { fault: dependencies.fault });
+    let accepted = false;
+    return {
+        async run(dispatch, options) {
+            if (dispatch.recipe !== "reviewer-common-bundle-v1" || dispatch.legs.length < 1 || dispatch.legs.length > 2 || dispatch.legs[0]?.axis !== "standards" || (dispatch.legs.length === 2 && dispatch.legs[1]?.axis !== "spec"))
+                throw new Error("Invalid accepted Reviewer dispatch cardinality or axes");
+            if (accepted)
+                throw new Error("Reviewer runner accepts exactly one dispatch");
+            accepted = true;
+            for (const leg of dispatch.legs)
+                if (!isReviewerPromptText(leg.prompt))
+                    throw new Error("Accepted Reviewer prompt evidence mismatch");
+            let batch;
+            try {
+                batch = await workspaceOwner.prepare(dispatch.targetSnapshot, dispatch.legs.map(l => l.axis), options.signal);
+            }
+            catch (error) {
+                const prepared = typeof error === "object" && error !== null && "preparedWorkspaces" in error ? error.preparedWorkspaces ?? [] : [];
+                const failedIndex = prepared.length;
+                const legs = Object.fromEntries(dispatch.legs.map((leg, index) => [leg.axis, failed(error, dispatch.targetSnapshot, leg.prompt, options.signal, index < failedIndex ? prepared[index].path : undefined)]));
+                // Siblings not yet attempted have no workspace; do not borrow the failed leg's retained path.
+                for (let index = failedIndex + 1; index < dispatch.legs.length; index += 1) {
+                    const axis = dispatch.legs[index].axis;
+                    legs[axis] = Object.freeze({ ...legs[axis], workspaceDisposition: "not-created" });
+                }
+                const target = Object.values(legs)[0].target;
+                throw new ReviewerDispatchExecutionError(Object.freeze({ identity: dispatch.identity, target, legs: Object.freeze(legs) }));
+            }
+            const settled = await Promise.allSettled(batch.workspaces.map(async (workspace) => {
+                const leg = dispatch.legs.find(candidate => candidate.axis === workspace.axis);
+                try {
+                    const child = await executeReviewerChild(workspace.path, leg, options.context, {
+                        ...(options.signal === undefined ? {} : { signal: options.signal }),
+                        ...(dependencies.credentialScratchParent === undefined
+                            ? {}
+                            : { credentialScratchParent: dependencies.credentialScratchParent }),
+                    });
+                    const disposition = await workspaceOwner.dispose(workspace);
+                    return [leg.axis, Object.freeze({ status: "successful", report: child.report, usage: child.usage, target: batch.target, prompt: child.prompt, workspaceDisposition: disposition })];
+                }
+                catch (error) {
+                    // Failed legs retain their workspace for the durable failure evidence and caller cleanup.
+                    return [leg.axis, failed(error, batch.target, leg.prompt, options.signal, workspace.path)];
+                }
+            }));
+            const pairs = settled.map(item => item.status === "fulfilled" ? item.value : (() => { throw item.reason; })());
+            const outcome = Object.freeze({ identity: dispatch.identity, target: batch.target, legs: Object.freeze(Object.fromEntries(pairs)) });
+            if (Object.values(outcome.legs).some(leg => leg?.status === "failed"))
+                throw new ReviewerDispatchExecutionError(outcome);
+            return outcome;
+        },
+        shutdown: () => workspaceOwner.shutdown(),
+    };
+}

package/dist/reviewer-child-executor.js

@@ -0,0 +1,23 @@
+import { executeEvidenceChild } from "./evidence-child-executor.js";
+/**
+ * Single conversion at the Reviewer adapter boundary: shared child classifications
+ * become Reviewer failure classifications without a second error taxonomy.
+ */
+export function projectSharedChildFailure(error) {
+    if (typeof error === "object" && error !== null && "evidenceChildFailure" in error) {
+        const classification = error.evidenceChildFailure;
+        if (classification === "provider" || classification === "child") {
+            Object.assign(error, { reviewerFailure: classification });
+        }
+    }
+    return error;
+}
+/** Reviewer policy adapter over the shared evidence-child lifecycle seam. */
+export async function executeReviewerChild(workspace, leg, context, options = {}) {
+    try {
+        return await executeEvidenceChild(workspace, leg.prompt, context, options);
+    }
+    catch (error) {
+        throw projectSharedChildFailure(error);
+    }
+}

package/dist/reviewer-construction.js

@@ -0,0 +1,95 @@
+import { sha256Hex } from "./sha256.js";
+import { reviewerScopePrompt } from "./reviewer-scope-prompt.js";
+export const REVIEWER_CONSTRUCTION_RECIPE = Object.freeze({
+    recipeId: "reviewer-common-bundle",
+    version: 1,
+    runtimeVersion: "1",
+    implementationSha256: sha256Hex("reviewer-common-bundle:v1:direct-text-prompts"),
+});
+export const REVIEWER_AXIS_OUTPUT_ADAPTER = Object.freeze({
+    adapterId: "reviewer-axis-output",
+    version: 1,
+    implementationSha256: sha256Hex("reviewer-axis-output:v1:single-axis-verbatim-report+standards-three-priorities"),
+});
+/** Typed Standards conclusion keys owned by reviewer construction (presentation labels are not the contract). */
+export const REVIEWER_STANDARDS_CONCLUSION_KEYS = Object.freeze([
+    "constitutionality",
+    "minimum-necessary-test-cost",
+    "complexity",
+]);
+const REVIEWER_STANDARDS_CONCLUSION_LABELS = Object.freeze({
+    constitutionality: "constitutionality",
+    "minimum-necessary-test-cost": "minimum-necessary test cost",
+    complexity: "complexity",
+});
+export function reviewerAxisOutputContract(axis) {
+    const three = REVIEWER_STANDARDS_CONCLUSION_KEYS;
+    return axis === "standards"
+        ? Object.freeze({ axis, requiredConclusions: three, excludedConclusions: Object.freeze([]) })
+        : Object.freeze({ axis, requiredConclusions: Object.freeze([]), excludedConclusions: three });
+}
+function renderConclusionList(keys, finalJoiner) {
+    const labels = keys.map((key) => REVIEWER_STANDARDS_CONCLUSION_LABELS[key]);
+    if (labels.length === 0)
+        return "";
+    if (labels.length === 1)
+        return labels[0];
+    if (labels.length === 2)
+        return `${labels[0]} ${finalJoiner} ${labels[1]}`;
+    return `${labels.slice(0, -1).join(", ")}, ${finalJoiner} ${labels[labels.length - 1]}`;
+}
+function renderAxisPriorityClause(contract) {
+    if (contract.requiredConclusions.length > 0) {
+        return `Inside that single Standards report, explicitly conclude on ${renderConclusionList(contract.requiredConclusions, "and")}; a finding or clear no-finding on each counts as a conclusion.`;
+    }
+    return `Do not discuss ${renderConclusionList(contract.excludedConclusions, "or")}; those are Standards judgements.`;
+}
+/** Package-owned mechanics layered over the unchanged canonical Skill semantics. */
+export function reviewerAxisMethodAdapter(axis) {
+    const contract = reviewerAxisOutputContract(axis);
+    const question = axis === "standards"
+        ? "Answer only the canonical Standards question, including its complete smell baseline and burden."
+        : "Answer only the canonical Spec question.";
+    return [
+        `Axis-Output-Adapter: ${REVIEWER_AXIS_OUTPUT_ADAPTER.adapterId}@${REVIEWER_AXIS_OUTPUT_ADAPTER.version}:${axis}`,
+        "The complete canonical Skill text below remains authoritative semantic input.",
+        "For this already-isolated leg, this package adapter supersedes that Skill's dual-agent orchestration, dual-axis aggregation, and dual-section presentation mechanics.",
+        question,
+        `Emit one substantive ${axis === "standards" ? "Standards" : "Spec"} report. Incidental cross-axis content, headings, and finding-count annotations are presentation matters, not defects.`,
+        renderAxisPriorityClause(contract),
+        "Before making any substantive claim, actually use the canonical Skill and fixed range facts; a citation without reading those facts is not evidence.",
+        "Independently acquire issue, authority, and context; do not treat caller prose as controlling authority or as the Spec source.",
+        "You may use any supplied common fact, including facts relevant to the other axis; access and citation do not change the assigned question.",
+        "The returned report is the complete output envelope and its UTF-8 bytes are preserved verbatim; no heading parser, sanitizer, section splitter, rewrite, aggregation, or replacement leg follows.",
+    ].join("\n");
+}
+/** Deterministic compiler: fixed target/range plus packaged Skill in, dispatch text out. */
+export function constructReviewerDispatch(input) {
+    const common = [
+        `Target: ${input.range.target}`,
+        `Base: ${input.range.base}`,
+        `Diff: ${input.range.diffCommand}`,
+        reviewerScopePrompt(input.reviewScopeKeys),
+        `Recipe: ${REVIEWER_CONSTRUCTION_RECIPE.recipeId}@${REVIEWER_CONSTRUCTION_RECIPE.version}`,
+        "Canonical-Skill:",
+        input.canonicalSkill,
+        "Fixed-Range:",
+        JSON.stringify(input.range, null, 2),
+    ].join("\n");
+    const axes = [{ axis: "standards" }, { axis: "spec" }];
+    const legs = axes.map((x) => Object.freeze({
+        axis: x.axis,
+        prompt: `${common}\n${reviewerAxisMethodAdapter(x.axis)}\n`,
+    }));
+    return Object.freeze({
+        identity: input.identity,
+        recipe: "reviewer-common-bundle-v1",
+        input: Object.freeze({
+            canonicalSkill: input.canonicalSkill,
+            construction: REVIEWER_CONSTRUCTION_RECIPE,
+        }),
+        targetSnapshot: input.target,
+        range: input.range,
+        legs: Object.freeze(legs),
+    });
+}

package/dist/reviewer-dispatch.js

@@ -0,0 +1,77 @@
+import { sameReviewerPinnedTarget } from "./reviewer-git-snapshot.js";
+import { immutableReviewerPin } from "./reviewer-pinned-git.js";
+export { createReviewerPinnedGitReader, immutableReviewerPin } from "./reviewer-pinned-git.js";
+import { isReviewerPromptText, sameReviewerPromptText } from "./reviewer-prompt-identity.js";
+import { sha256Hex } from "./sha256.js";
+import { constructReviewerDispatch } from "./reviewer-construction.js";
+import { ReviewerCorrectablePreflightError } from "./reviewer-preflight-error.js";
+export { sha256Hex } from "./sha256.js";
+export { isReviewerPromptText as isReviewerPromptIdentity, sameReviewerPromptText as sameReviewerPromptIdentity } from "./reviewer-prompt-identity.js";
+export const REVIEWER_PREFLIGHT_VIOLATIONS = ["base-invalid", "range-invalid", "prompt-identity-invalid", "target-drift"];
+export class ReviewerPreflightError extends Error {
+    code;
+    diagnostic;
+    constructor(code, diagnostic = `${code} constraint failed`) {
+        super(`${code}: ${diagnostic}`);
+        this.code = code;
+        this.diagnostic = diagnostic;
+    }
+}
+export function toReviewerExecution(dispatch) {
+    return Object.freeze({
+        identity: dispatch.identity,
+        recipe: dispatch.recipe,
+        targetSnapshot: immutableReviewerPin(dispatch.targetSnapshot),
+        legs: Object.freeze(dispatch.legs.map((l) => Object.freeze({ axis: l.axis, prompt: l.prompt }))),
+    });
+}
+const preflight = (error) => {
+    if (error instanceof ReviewerPreflightError)
+        return error;
+    if (error instanceof ReviewerCorrectablePreflightError) {
+        return new ReviewerPreflightError(error.code, error.diagnostic);
+    }
+    return undefined;
+};
+export function createReviewerDispatcher(d) {
+    const target = immutableReviewerPin(d.reader.pin);
+    let started = false;
+    return Object.freeze({
+        async dispatch(baseRevision, invocation) {
+            if (started)
+                throw new Error("Reviewer fixed dispatch can start exactly once");
+            const identity = sha256Hex(JSON.stringify({
+                baseRevision,
+                target: target.targetHead,
+                canonicalSkill: sha256Hex(d.canonicalSkill),
+            }));
+            let dispatch;
+            try {
+                const base = await d.reader.resolve(baseRevision);
+                const range = await d.reader.range(base);
+                dispatch = constructReviewerDispatch({
+                    identity,
+                    canonicalSkill: d.canonicalSkill,
+                    target,
+                    range,
+                    ...(d.reviewScopeKeys === undefined ? {} : { reviewScopeKeys: d.reviewScopeKeys }),
+                });
+                if (!sameReviewerPinnedTarget(await d.reader.snapshot(), target)) {
+                    throw new ReviewerPreflightError("target-drift", "pinned target snapshot changed before child execution");
+                }
+            }
+            catch (error) {
+                const p = preflight(error);
+                if (!p)
+                    throw error;
+                d.decisionEvidence?.(Object.freeze({ disposition: "rejected", identity, violations: Object.freeze([p.code]), started: false }));
+                return Object.freeze({ status: "rejected", identity, violations: Object.freeze([p.code]), diagnostic: p.diagnostic });
+            }
+            started = true;
+            d.decisionEvidence?.(Object.freeze({ disposition: "accepted", identity, dispatch }));
+            const results = await d.run(toReviewerExecution(dispatch), invocation);
+            return Object.freeze({ status: "accepted", dispatch, results });
+        },
+    });
+}
+export { isReviewerPromptText, sameReviewerPromptText };

package/dist/reviewer-execution-ledger.js

@@ -0,0 +1,160 @@
+import { sameReviewerPinnedTarget } from "./reviewer-git-snapshot.js";
+import { isReviewerPromptText, sameReviewerPromptText } from "./reviewer-prompt-identity.js";
+import { REVIEWER_PREFLIGHT_VIOLATIONS, } from "./reviewer-dispatch.js";
+export function projectAcceptedDispatch(dispatch) {
+    return {
+        source: "reviewer-dispatch", type: "accepted", identity: dispatch.identity,
+        recipe: dispatch.recipe, input: dispatch.input, target: dispatch.targetSnapshot,
+        range: dispatch.range, legs: dispatch.legs,
+    };
+}
+export function projectReviewerDispatchOutcome(ledger, dispatch, result) {
+    if (result.identity !== dispatch.identity)
+        throw new Error("Reviewer runner identity does not match accepted dispatch");
+    if (!sameReviewerPinnedTarget(result.target, dispatch.targetSnapshot))
+        throw new Error("Reviewer runner target does not match accepted pinned target");
+    const expectedAxes = dispatch.legs.map(({ axis }) => axis).sort();
+    const actualAxes = Object.keys(result.legs).sort();
+    if (actualAxes.length !== expectedAxes.length || actualAxes.some((axis, index) => axis !== expectedAxes[index])) {
+        throw new Error(`Reviewer runner result axes do not match accepted dispatch: expected ${expectedAxes.join(",")}; received ${actualAxes.join(",")}`);
+    }
+    for (const leg of dispatch.legs) {
+        const actual = result.legs[leg.axis];
+        if (actual === undefined)
+            throw new Error(`Reviewer runner omitted ${leg.axis} result`);
+        ledger.append(actual.status === "failed"
+            ? { source: "reviewer-agent", type: "leg-settled", dispatchIdentity: dispatch.identity, axis: leg.axis, status: "failed", prompt: actual.prompt, target: actual.target, failure: actual.failure, diagnostic: actual.diagnostic, workspaceDisposition: actual.workspaceDisposition }
+            : { source: "reviewer-agent", type: "leg-settled", dispatchIdentity: dispatch.identity, axis: leg.axis, status: "successful", prompt: actual.prompt, target: actual.target, report: actual.report, usage: actual.usage, workspaceDisposition: actual.workspaceDisposition });
+    }
+}
+function cloneFreeze(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(cloneFreeze));
+    if (typeof value === "object" && value !== null) {
+        const copy = {};
+        for (const [key, item] of Object.entries(value))
+            copy[key] = cloneFreeze(item);
+        return Object.freeze(copy);
+    }
+    return value;
+}
+function hasExactEventShape(event, keys) {
+    const actual = Object.keys(event);
+    return actual.length === keys.length && actual.every((key) => keys.includes(key));
+}
+function fatal(error) {
+    const record = typeof error === "object" && error !== null ? error : undefined;
+    return cloneFreeze({
+        diagnostics: "infrastructure-failure",
+        cause: error,
+        ...(record?.targetSnapshot === undefined ? {} : { targetSnapshot: record.targetSnapshot }),
+        ...(record?.workspaceDisposition === undefined ? {} : { workspaceDisposition: record.workspaceDisposition }),
+    });
+}
+export function createReviewerExecutionLedger() {
+    const rejections = [];
+    const closedAttempts = [];
+    let accepted;
+    let started;
+    const results = {};
+    let infrastructureFailure;
+    function append(raw) {
+        const event = cloneFreeze(raw);
+        if (event.source === "reviewer-dispatch" && event.type === "rejected") {
+            if (!hasExactEventShape(event, ["source", "type", "identity", "violations", "started"]) || event.started !== false ||
+                event.violations.length === 0 || event.violations.some((code) => !REVIEWER_PREFLIGHT_VIOLATIONS.includes(code)))
+                throw new Error("Rejected dispatch must contain only closed bounded non-start evidence");
+            if (accepted !== undefined || started !== undefined)
+                throw new Error("Rejection cannot follow an accepted dispatch");
+            rejections.push(cloneFreeze({ identity: event.identity, violations: event.violations, started: false }));
+            return;
+        }
+        if (event.source === "reviewer-dispatch" && event.type === "closed-attempt") {
+            if (!hasExactEventShape(event, ["source", "type", "identity", "reason", "started"]) || event.reason !== "acceptance-closed" || event.started !== false)
+                throw new Error("Closed attempt must contain only immutable non-start outcome evidence");
+            if (accepted === undefined)
+                throw new Error("Closed attempt requires a closed acceptance lifecycle");
+            closedAttempts.push(cloneFreeze({ identity: event.identity, reason: event.reason, started: false }));
+            return;
+        }
+        if (event.source === "reviewer-dispatch" && event.type === "accepted") {
+            if (accepted !== undefined)
+                throw new Error("Projection permits exactly one accepted dispatch");
+            const axes = event.legs.map((leg) => leg.axis);
+            if (axes[0] !== "standards" || (axes.length !== 1 && (axes.length !== 2 || axes[1] !== "spec")))
+                throw new Error("Accepted dispatch sibling axes disagree");
+            if (!isReviewerPromptText(event.input.canonicalSkill))
+                throw new Error("Accepted canonical Skill must be plain text");
+            for (const leg of event.legs) {
+                if (!isReviewerPromptText(leg.prompt))
+                    throw new Error("Accepted compiled prompt must be plain text");
+            }
+            accepted = event;
+            return;
+        }
+        if (event.source === "reviewer-runtime" && event.type === "fatal") {
+            if (infrastructureFailure === undefined)
+                infrastructureFailure = cloneFreeze({
+                    diagnostics: event.diagnostics,
+                    cause: event.cause,
+                    ...(event.targetSnapshot === undefined ? {} : { targetSnapshot: event.targetSnapshot }),
+                    ...(event.workspaceDisposition === undefined ? {} : { workspaceDisposition: event.workspaceDisposition }),
+                });
+            return;
+        }
+        if (event.type === "dispatch-started") {
+            if (accepted === undefined || event.dispatchIdentity !== accepted.identity)
+                throw new Error("Start requires its accepted dispatch");
+            if (started !== undefined)
+                throw new Error("Accepted dispatch can start exactly once");
+            if (event.cardinality !== accepted.legs.length)
+                throw new Error("Dispatch start cardinality disagrees with acceptance");
+            started = cloneFreeze({ dispatchIdentity: event.dispatchIdentity, cardinality: event.cardinality });
+            return;
+        }
+        if (accepted === undefined || started === undefined || event.dispatchIdentity !== accepted.identity)
+            throw new Error("Runner result requires its irreversible accepted dispatch start");
+        if (results[event.axis] !== undefined)
+            throw new Error(`Reviewer ${event.axis} result can settle exactly once`);
+        const compiled = accepted.legs.find((leg) => leg.axis === event.axis);
+        if (compiled === undefined)
+            throw new Error(`Reviewer ${event.axis} was not an accepted leg`);
+        if (!sameReviewerPromptText(event.prompt, compiled.prompt) || !isReviewerPromptText(event.prompt))
+            throw new Error("Actual runner prompt does not exactly match compiled prompt text");
+        if (!sameReviewerPinnedTarget(event.target, accepted.target))
+            throw new Error("Runner target does not match shared pinned target");
+        if (event.status === "successful") {
+            if (typeof event.report !== "string" || event.report.length === 0 || event.failure !== undefined)
+                throw new Error("Successful settlement requires a report");
+        }
+        else if (event.failure === undefined || event.report !== undefined) {
+            throw new Error("Failed settlement requires a bounded failure classification and no report");
+        }
+        results[event.axis] = event;
+    }
+    function recordInfrastructureFailure(error) {
+        if (infrastructureFailure === undefined) {
+            const evidence = fatal(error);
+            append({ source: "reviewer-runtime", type: "fatal", ...evidence });
+        }
+        return error;
+    }
+    function recordForAudit(status) {
+        if (infrastructureFailure !== undefined)
+            throw Object.assign(new Error(`Reviewer infrastructure previously failed: ${infrastructureFailure.diagnostics}`), { fatalReviewerInfrastructure: true });
+        if (status === "completed") {
+            if (accepted === undefined || started === undefined)
+                throw new Error("Reviewer completed requires exactly one accepted and started dispatch");
+            const expected = accepted.legs.map((leg) => leg.axis);
+            if (expected.some((axis) => results[axis]?.status !== "successful") || Object.keys(results).length !== expected.length)
+                throw new Error(expected.length === 2 ? "Reviewer completed requires both axes settled successfully" : "Reviewer completed requires Standards settled successfully and no Spec evidence");
+        }
+        else if (accepted !== undefined) {
+            const expected = accepted.legs.map((leg) => leg.axis);
+            if (started === undefined || expected.some((axis) => results[axis] === undefined) || Object.keys(results).length !== expected.length)
+                throw new Error("Reviewer refused after acceptance requires every expected leg terminal outcome");
+        }
+        return cloneFreeze({ rejections, closedAttempts, ...(accepted === undefined ? {} : { accepted }), ...(started === undefined ? {} : { started }), results });
+    }
+    return Object.freeze({ append, recordInfrastructureFailure, recordForAudit });
+}

package/dist/reviewer-failure-diagnostic.js

@@ -0,0 +1,17 @@
+export function normalizeReviewerFailureDiagnostic(error, failure) {
+    const original = error instanceof Error && Object.hasOwn(error, "reviewerOriginal")
+        ? error.reviewerOriginal
+        : error;
+    const message = original instanceof Error
+        ? original.message.trim()
+        : typeof original === "string"
+            ? original.trim()
+            : typeof original === "object" && original !== null && typeof original.errorMessage === "string"
+                ? original.errorMessage.trim()
+                : "";
+    if (message !== "")
+        return message;
+    return failure === "provider"
+        ? "Reviewer Agent provider supplied no diagnostic details"
+        : "Reviewer Agent failed without diagnostic details";
+}

package/dist/reviewer-git-snapshot.js

@@ -0,0 +1,38 @@
+export const REVIEW_REF_PREFIXES = ["refs/heads", "refs/tags", "refs/remotes"];
+export function parseReviewerRefSnapshot(raw) {
+    const refs = {};
+    for (const line of raw.split("\n")) {
+        if (!line)
+            continue;
+        const fields = line.split("\0");
+        if (fields.length !== 5 || !fields[0] || !fields[1] || !fields[3]) {
+            throw new Error(`Malformed Git ref snapshot line: ${line}`);
+        }
+        const peeledCommitId = fields[3] === "commit"
+            ? fields[1]
+            : fields[4] === "commit" && fields[2] ? fields[2] : null;
+        refs[fields[0]] = Object.freeze({
+            objectId: fields[1],
+            peeledCommitId,
+        });
+    }
+    return refs;
+}
+export function reviewerRefSnapshotArgs() {
+    return ["for-each-ref", "--format=%(refname)%00%(objectname)%00%(*objectname)%00%(objecttype)%00%(*objecttype)", ...REVIEW_REF_PREFIXES];
+}
+export function immutableReviewerRefs(refs) {
+    return Object.freeze(Object.fromEntries(Object.entries(refs)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, entry]) => [name, Object.freeze({ objectId: entry.objectId, peeledCommitId: entry.peeledCommitId })])));
+}
+export function sameReviewerPinnedTarget(actual, expected) {
+    return actual.repositoryRoot === expected.repositoryRoot && actual.objectFormat === expected.objectFormat &&
+        actual.targetHead === expected.targetHead && sameReviewerRefs(actual.refs, expected.refs);
+}
+export function sameReviewerRefs(actual, expected) {
+    const actualEntries = Object.entries(actual).sort(([left], [right]) => left.localeCompare(right));
+    const expectedEntries = Object.entries(expected).sort(([left], [right]) => left.localeCompare(right));
+    return actualEntries.length === expectedEntries.length && actualEntries.every(([name, value], index) => name === expectedEntries[index]?.[0] && value.objectId === expectedEntries[index]?.[1].objectId &&
+        value.peeledCommitId === expectedEntries[index]?.[1].peeledCommitId);
+}