@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/runtime/steps/auditor-decision/audit-input-state.js

@@ -0,0 +1,101 @@
+import { traceDebug } from "../../observability/debug-logger.js";
+import { readAuditorAdvisoryReceipt, } from "./advisory-receipt.js";
+import { EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID, parseExecutionAgentAuditObjective, } from "./contracts.js";
+import { fingerprintAuditorBundle, fingerprintAuditorWork, projectAuditorWorkEvidence, } from "./evidence-inventory.js";
+export function projectAuditorInputState(head, callerCallId, steeringVersion, criterionIds = [EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID], suppliedEvidence) {
+    const evidence = suppliedEvidence ?? projectAuditorWorkEvidence(head, callerCallId);
+    const workFingerprint = fingerprintAuditorWork({
+        requestId: head.state.requestId,
+        callerCallId,
+        steeringVersion,
+        criterionIds,
+        evidence,
+    });
+    const receipts = matchingReceipts(head, callerCallId, workFingerprint, steeringVersion, criterionIds);
+    const reviewedBundleFingerprints = Object.freeze(receipts.flatMap((receipt) => receipt.evidenceBinding.bundleFingerprint
+        ? [receipt.evidenceBinding.bundleFingerprint]
+        : []));
+    const eligibility = auditInputEligibility(evidence, receipts, workFingerprint, reviewedBundleFingerprints);
+    const state = Object.freeze({
+        ...eligibility,
+        workFingerprint,
+        reviewedBundleFingerprints,
+        reviewedEvidenceBundles: Object.freeze(receipts
+            .filter((receipt) => receipt.evidenceBinding.bundleFingerprint !== null)
+            .map((receipt) => Object.freeze([...receipt.evidenceBinding.selectedEvidenceIds]))),
+        reviewedBundleCount: reviewedBundleFingerprints.length,
+    });
+    traceDebug("runtime.auditor", "input.availability", {
+        requestId: head.state.requestId,
+        callId: callerCallId,
+        phase: "availability",
+        workFingerprint,
+        inventoryCount: evidence.length,
+        available: state.available,
+        reason: state.reason,
+        reviewedBundleCount: state.reviewedBundleCount,
+        pendingEvidenceCount: state.pendingEvidenceIds?.length ?? 0,
+    });
+    return state;
+}
+function auditInputEligibility(evidence, receipts, workFingerprint, reviewed) {
+    if (evidence.length === 0)
+        return unavailable("no_work_evidence");
+    if (receipts.some((receipt) => receipt.verdict !== "needs_evidence")) {
+        return unavailable("audit_finished_for_work");
+    }
+    const latest = receipts.at(-1);
+    if (!latest)
+        return { available: true, reason: "new_work", pendingEvidenceIds: null };
+    const requested = latest.requestedEvidenceIds;
+    if (!isAvailableEvidenceBundle(requested, evidence))
+        return unavailable("requested_evidence_unavailable");
+    if (reviewed.includes(fingerprintAuditorBundle(workFingerprint, requested))) {
+        return unavailable("requested_bundle_already_reviewed");
+    }
+    return {
+        available: true,
+        reason: "auditor_requested_evidence",
+        pendingEvidenceIds: Object.freeze([...requested]),
+    };
+}
+function isAvailableEvidenceBundle(ids, evidence) {
+    if (ids.length === 0 || new Set(ids).size !== ids.length)
+        return false;
+    const knownIds = new Set(evidence.map((entry) => entry.executionId));
+    return ids.every((id) => knownIds.has(id));
+}
+function matchingReceipts(head, callerCallId, fingerprint, steeringVersion, criterionIds) {
+    const receipts = [];
+    for (const result of head.state.results) {
+        if (result.roleId !== "reviewer")
+            continue;
+        const producer = head.state.calls.find((call) => call.callId === result.producerCallId);
+        if (producer?.parentCallId !== callerCallId || !producer.objective)
+            continue;
+        if (!hasMatchingAuditObjective(producer.objective, steeringVersion, criterionIds))
+            continue;
+        const receipt = readAuditorAdvisoryReceipt(result.summary);
+        if (!receipt || receipt.auditId !== producer.callId)
+            continue;
+        if (receipt.evidenceBinding.workFingerprint !== fingerprint)
+            continue;
+        receipts.push(receipt);
+    }
+    return Object.freeze(receipts);
+}
+function hasMatchingAuditObjective(encoded, steeringVersion, criterionIds) {
+    try {
+        const objective = parseExecutionAgentAuditObjective(encoded);
+        if (objective.requestSteeringVersion !== steeringVersion)
+            return false;
+        return (JSON.stringify([...objective.criterionIds].sort()) ===
+            JSON.stringify([...criterionIds].sort()));
+    }
+    catch {
+        return false;
+    }
+}
+function unavailable(reason) {
+    return { available: false, reason, pendingEvidenceIds: null };
+}

package/dist/src/runtime/steps/auditor-decision/contracts.d.ts

@@ -5,8 +5,6 @@ export declare const EXECUTION_AGENT_AUDIT_OBJECTIVE_KIND: "runtime_execution_ag
 export declare const AUDITOR_DECISION_IDENTIFIER_MAX_LENGTH = 128;
 export declare const AUDITOR_DECISION_TEXT_MAX_LENGTH = 8192;
 export declare const AUDITOR_DECISION_CRITERION_LIMIT = 32;
-export declare const AUDITOR_DECISION_EVIDENCE_LIMIT = 16;
-export declare const AUDITOR_DECISION_EVIDENCE_TOTAL_MAX_CHARS = 48000;
 export type ExecutionAgentAuditObjective = Readonly<{
     kind: typeof EXECUTION_AGENT_AUDIT_OBJECTIVE_KIND;
     criterionIds: readonly string[];
@@ -31,15 +29,27 @@ export type AuditorCapabilityEvidence = Readonly<{
     }>[];
     adapterResult: CapabilityAdapterResult;
 }>;
-export type AuditorRoleResultEvidence = Readonly<{
-    kind: "subordinate_result";
-    resultRef: string;
-    producerCallId: string;
-    roleId: "planner" | "worker" | "researcher" | "reviewer";
-    outcome: "completed" | "failed";
-    summary: string;
+export type AuditorEvidence = AuditorCapabilityEvidence;
+export type AuditorEvidencePreview = Readonly<{
+    text: string;
+    originalChars: number;
+    truncated: boolean;
+}>;
+export type AuditorEvidenceInventoryEntry = Readonly<{
+    executionId: string;
+    callId: string;
+    invocationAttempt: number;
+    capabilityId: string;
+    declaredEffect: AuditorCapabilityEvidence["declaredEffect"];
+    outcome: AuditorCapabilityEvidence["outcome"];
+    observedEffect: AuditorCapabilityEvidence["observedEffect"];
+    summaryPreview: AuditorEvidencePreview;
+    targetPreviews: readonly AuditorEvidencePreview[];
+    referenceCount: number;
+    omittedReferencePreviewCount: number;
+    exactEvidenceChars: number;
+    evidenceFingerprint: string;
 }>;
-export type AuditorEvidence = AuditorCapabilityEvidence | AuditorRoleResultEvidence;
 export type AuditorAssignment = Readonly<{
     auditId: string;
     callerCallId: string;
@@ -47,6 +57,12 @@ export type AuditorAssignment = Readonly<{
     sourceRevision: number;
     criterionIds: readonly string[];
     criteria: readonly AuditorCriterion[];
+    workFingerprint: string;
+    inventory: readonly AuditorEvidenceInventoryEntry[];
+    selectedEvidenceIds: readonly string[];
+    reviewedBundleFingerprints: readonly string[];
+    reviewedEvidenceBundles: readonly (readonly string[])[];
+    pendingEvidenceIds: readonly string[] | null;
     evidence: readonly AuditorEvidence[];
     availableEvidenceCount: number;
     omittedEvidenceCount: number;
@@ -55,6 +71,7 @@ export type AuditorEvidenceProjectionStatus = Readonly<{
     complete: boolean;
     evidenceCountConsistent: boolean;
     projectedEvidenceCount: number;
+    selectedEvidenceCount: number;
     availableEvidenceCount: number;
     omittedEvidenceCount: number;
 }>;
@@ -64,14 +81,12 @@ export type AuditorGap = Readonly<{
 }>;
 export type AuditorDecision = Readonly<{
     auditId: string;
-    verdict: "pass";
-    criterionIds: readonly string[];
-    gaps: readonly [];
-}> | Readonly<{
-    auditId: string;
-    verdict: "gaps";
+    verdict: "pass" | "gaps" | "needs_evidence";
     criterionIds: readonly string[];
     gaps: readonly AuditorGap[];
+    neededEvidenceIds: readonly string[];
+    notNeededEvidenceIds: readonly string[];
+    requestedEvidenceIds: readonly string[];
 }>;
 export type AuditorDecisionValidationIssue = Readonly<{
     code: string;

package/dist/src/runtime/steps/auditor-decision/contracts.js

@@ -5,8 +5,6 @@ export const EXECUTION_AGENT_AUDIT_OBJECTIVE_KIND = "runtime_execution_agent_aud
 export const AUDITOR_DECISION_IDENTIFIER_MAX_LENGTH = 128;
 export const AUDITOR_DECISION_TEXT_MAX_LENGTH = 8_192;
 export const AUDITOR_DECISION_CRITERION_LIMIT = 32;
-export const AUDITOR_DECISION_EVIDENCE_LIMIT = 16;
-export const AUDITOR_DECISION_EVIDENCE_TOTAL_MAX_CHARS = 48_000;
 export function encodeExecutionAgentAuditObjective(criterionIds, requestSteeringVersion = 0) {
     if (!Number.isSafeInteger(requestSteeringVersion) ||
         requestSteeringVersion < 0) {
@@ -45,7 +43,8 @@ export function projectAuditorEvidenceProjectionStatus(assignment) {
         Number.isSafeInteger(assignment.omittedEvidenceCount) &&
         assignment.availableEvidenceCount >= 0 &&
         assignment.omittedEvidenceCount >= 0 &&
-        assignment.availableEvidenceCount ===
+        assignment.availableEvidenceCount === assignment.inventory.length &&
+        assignment.selectedEvidenceIds.length ===
             assignment.evidence.length + assignment.omittedEvidenceCount;
     return Object.freeze({
         complete: evidenceCountConsistent &&
@@ -53,6 +52,7 @@ export function projectAuditorEvidenceProjectionStatus(assignment) {
             assignment.omittedEvidenceCount === 0,
         evidenceCountConsistent,
         projectedEvidenceCount: assignment.evidence.length,
+        selectedEvidenceCount: assignment.selectedEvidenceIds.length,
         availableEvidenceCount: assignment.availableEvidenceCount,
         omittedEvidenceCount: assignment.omittedEvidenceCount,
     });

package/dist/src/runtime/steps/auditor-decision/evidence-binding.d.ts

@@ -0,0 +1,5 @@
+import { type AuditorAssignment, type AuditorCapabilityEvidence } from "./contracts.js";
+export declare class AuditorEvidenceAdmissionError extends Error {
+}
+export declare function auditEvidenceSelectionIssue(ids: unknown, assignment: AuditorAssignment): string | undefined;
+export declare function bindAuditorEvidence(assignment: AuditorAssignment, source: readonly AuditorCapabilityEvidence[], selectedEvidenceIds: readonly string[]): AuditorAssignment;

package/dist/src/runtime/steps/auditor-decision/evidence-binding.js

@@ -0,0 +1,43 @@
+import { fingerprintAuditorBundle, fingerprintAuditorEvidence, } from "./evidence-inventory.js";
+export class AuditorEvidenceAdmissionError extends Error {
+}
+export function auditEvidenceSelectionIssue(ids, assignment) {
+    if (!Array.isArray(ids) || ids.length === 0)
+        return "auditor_evidence_selection_empty";
+    if (new Set(ids).size !== ids.length)
+        return "auditor_evidence_ids_duplicate";
+    const inventoryById = new Map(assignment.inventory.map((entry) => [entry.executionId, entry]));
+    for (const id of ids) {
+        if (typeof id !== "string")
+            return "auditor_evidence_id_invalid";
+        const entry = inventoryById.get(id);
+        if (!entry)
+            return "auditor_evidence_id_unknown";
+    }
+    const bundle = fingerprintAuditorBundle(assignment.workFingerprint, ids);
+    if (assignment.reviewedBundleFingerprints.includes(bundle))
+        return "auditor_evidence_bundle_already_reviewed";
+    return undefined;
+}
+export function bindAuditorEvidence(assignment, source, selectedEvidenceIds) {
+    const issue = auditEvidenceSelectionIssue(selectedEvidenceIds, assignment);
+    if (issue)
+        throw new AuditorEvidenceAdmissionError(issue);
+    const sourceById = new Map(source.map((entry) => [entry.executionId, entry]));
+    const evidence = selectedEvidenceIds.map((id) => {
+        const entry = sourceById.get(id);
+        if (!entry)
+            throw new AuditorEvidenceAdmissionError("auditor_evidence_source_unavailable");
+        const expected = assignment.inventory.find((item) => item.executionId === id);
+        if (fingerprintAuditorEvidence(entry) !== expected?.evidenceFingerprint) {
+            throw new AuditorEvidenceAdmissionError("auditor_evidence_source_changed");
+        }
+        return entry;
+    });
+    return Object.freeze({
+        ...assignment,
+        selectedEvidenceIds: Object.freeze([...selectedEvidenceIds]),
+        evidence: Object.freeze(evidence),
+        omittedEvidenceCount: 0,
+    });
+}

package/dist/src/runtime/steps/auditor-decision/evidence-coverage.d.ts

@@ -0,0 +1,2 @@
+import { type AuditorAssignment, type AuditorDecisionValidationIssue } from "./contracts.js";
+export declare function validateAuditorEvidenceCoverage(value: Record<string, unknown>, assignment: AuditorAssignment): readonly AuditorDecisionValidationIssue[];

package/dist/src/runtime/steps/auditor-decision/evidence-coverage.js

@@ -0,0 +1,71 @@
+import { projectAuditorEvidenceProjectionStatus, } from "./contracts.js";
+import { auditEvidenceSelectionIssue } from "./evidence-binding.js";
+import { fingerprintAuditorBundle } from "./evidence-inventory.js";
+export function validateAuditorEvidenceCoverage(value, assignment) {
+    const needed = value.neededEvidenceIds;
+    const notNeeded = value.notNeededEvidenceIds;
+    if (!hasExactInventoryCoverage(needed, notNeeded, assignment)) {
+        return issue("auditor_evidence_coverage_invalid", "neededEvidenceIds and notNeededEvidenceIds must partition the complete inventory exactly once.");
+    }
+    if (value.verdict === "needs_evidence")
+        return validateRequestedBundle(value.requestedEvidenceIds, needed, assignment);
+    if (!isEmptyEvidenceRequest(value.requestedEvidenceIds)) {
+        return issue("auditor_unexpected_evidence_request", "Only needs_evidence may request another bundle.");
+    }
+    if (!requiresCurrentOriginalEvidence(value.verdict))
+        return [];
+    if (!projectAuditorEvidenceProjectionStatus(assignment).complete) {
+        return issue(`auditor_${value.verdict}_evidence_incomplete`, "Conclusive verdicts require all selected original evidence without omissions.");
+    }
+    if (!hasCurrentNeededEvidence(needed, assignment, value.verdict)) {
+        return issue(`auditor_${value.verdict}_needed_evidence_missing`, "Every needed evidence ID must be present in the current exact bundle; previews and prior reviews are not proof.");
+    }
+    return [];
+}
+function hasExactInventoryCoverage(needed, notNeeded, assignment) {
+    if (!Array.isArray(needed) || !Array.isArray(notNeeded))
+        return false;
+    const ids = [...needed, ...notNeeded];
+    if (ids.length !== assignment.availableEvidenceCount)
+        return false;
+    if (new Set(ids).size !== ids.length)
+        return false;
+    const inventoryIds = new Set(assignment.inventory.map((entry) => entry.executionId));
+    return ids.every((id) => typeof id === "string" && inventoryIds.has(id));
+}
+function requiresCurrentOriginalEvidence(verdict) {
+    if (verdict === "pass")
+        return true;
+    return verdict === "gaps";
+}
+function hasCurrentNeededEvidence(needed, assignment, verdict) {
+    if (needed.length === 0)
+        return verdict === "gaps";
+    const admitted = new Set(assignment.evidence.map((entry) => entry.executionId));
+    return needed.every((id) => admitted.has(id));
+}
+function validateRequestedBundle(ids, needed, assignment) {
+    const currentBundle = fingerprintAuditorBundle(assignment.workFingerprint, assignment.selectedEvidenceIds);
+    const code = auditEvidenceSelectionIssue(ids, {
+        ...assignment,
+        reviewedBundleFingerprints: [
+            ...assignment.reviewedBundleFingerprints,
+            currentBundle,
+        ],
+    });
+    if (code)
+        return issue(code, "Request a complete admissible evidence bundle that has not already been reviewed for this work snapshot.");
+    if (!hasRequestedNeededEvidence(needed, ids))
+        return issue("auditor_requested_needed_evidence_missing", "The requested next bundle must include every needed evidence ID, including originals already read in the current bundle.");
+    return [];
+}
+function hasRequestedNeededEvidence(needed, requested) {
+    const requestedIds = new Set(requested);
+    return needed.every((id) => requestedIds.has(id));
+}
+function isEmptyEvidenceRequest(ids) {
+    return Array.isArray(ids) && ids.length === 0;
+}
+function issue(code, message) {
+    return Object.freeze([{ code, path: "decision.evidenceCoverage", message }]);
+}

package/dist/src/runtime/steps/auditor-decision/evidence-inventory.d.ts

@@ -0,0 +1,13 @@
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import type { AuditorCapabilityEvidence, AuditorEvidenceInventoryEntry } from "./contracts.js";
+export declare function projectAuditorWorkEvidence(head: RoleCallLedgerHead, callerCallId: string): readonly AuditorCapabilityEvidence[];
+export declare function projectAuditorEvidenceInventory(head: RoleCallLedgerHead, callerCallId: string, evidence: readonly AuditorCapabilityEvidence[]): readonly AuditorEvidenceInventoryEntry[];
+export declare function fingerprintAuditorWork(params: Readonly<{
+    requestId: string;
+    callerCallId: string;
+    steeringVersion: number;
+    criterionIds: readonly string[];
+    evidence: readonly AuditorCapabilityEvidence[];
+}>): string;
+export declare function fingerprintAuditorBundle(workFingerprint: string, selectedEvidenceIds: readonly string[]): string;
+export declare function fingerprintAuditorEvidence(evidence: AuditorCapabilityEvidence): string;

package/dist/src/runtime/steps/auditor-decision/evidence-inventory.js

@@ -0,0 +1,89 @@
+import { createHash } from "node:crypto";
+import { projectAuditorEvidenceRepresentation } from "./evidence-representation.js";
+const INVENTORY_PREVIEW_MAX_CHARS = 160;
+const INVENTORY_TARGET_PREVIEW_LIMIT = 2;
+export function projectAuditorWorkEvidence(head, callerCallId) {
+    return Object.freeze(rootSettledExecutions(head, callerCallId).map(projectCapabilityEvidence));
+}
+export function projectAuditorEvidenceInventory(head, callerCallId, evidence) {
+    const executions = rootSettledExecutions(head, callerCallId);
+    return Object.freeze(evidence.map((entry, index) => {
+        const execution = executions[index];
+        const references = entry.references ?? [];
+        return Object.freeze({
+            executionId: entry.executionId,
+            callId: execution.callId,
+            invocationAttempt: execution.invocationAttempt,
+            capabilityId: entry.capabilityId,
+            declaredEffect: entry.declaredEffect,
+            outcome: entry.outcome,
+            observedEffect: entry.observedEffect,
+            summaryPreview: preview(entry.summary),
+            targetPreviews: Object.freeze(references
+                .slice(0, INVENTORY_TARGET_PREVIEW_LIMIT)
+                .map(({ target }) => preview(target))),
+            referenceCount: references.length,
+            omittedReferencePreviewCount: Math.max(0, references.length - INVENTORY_TARGET_PREVIEW_LIMIT),
+            exactEvidenceChars: JSON.stringify(projectAuditorEvidenceRepresentation(entry)).length,
+            evidenceFingerprint: fingerprintAuditorEvidence(entry),
+        });
+    }));
+}
+export function fingerprintAuditorWork(params) {
+    return fingerprint(JSON.stringify({
+        ...params,
+        criterionIds: [...params.criterionIds].sort(),
+    }));
+}
+export function fingerprintAuditorBundle(workFingerprint, selectedEvidenceIds) {
+    return fingerprint(JSON.stringify({
+        workFingerprint,
+        selectedEvidenceIds: [...selectedEvidenceIds].sort(),
+    }));
+}
+export function fingerprintAuditorEvidence(evidence) {
+    return fingerprint(JSON.stringify(evidence));
+}
+function rootSettledExecutions(head, callerCallId) {
+    return head.state.capabilityExecutions.filter((execution) => execution.callId === callerCallId && execution.status === "settled");
+}
+function projectCapabilityEvidence(execution) {
+    if (!hasSettledEvidence(execution)) {
+        throw new Error("execution_agent_auditor_evidence_invalid");
+    }
+    return Object.freeze({
+        kind: "capability_result",
+        executionId: execution.executionId,
+        capabilityId: execution.capabilityId,
+        declaredEffect: execution.declaredEffect,
+        outcome: execution.outcome,
+        observedEffect: execution.observedEffect,
+        summary: execution.summary,
+        ...(execution.referenceData !== undefined
+            ? { referenceData: execution.referenceData }
+            : {}),
+        ...(execution.references !== undefined
+            ? { references: execution.references }
+            : {}),
+        adapterResult: execution.exactResult,
+    });
+}
+function hasSettledEvidence(execution) {
+    if (execution.status !== "settled")
+        return false;
+    if (execution.outcome === null || execution.observedEffect === null)
+        return false;
+    if (execution.summary === null)
+        return false;
+    return execution.exactResult !== undefined;
+}
+function preview(text) {
+    return Object.freeze({
+        text: text.slice(0, INVENTORY_PREVIEW_MAX_CHARS),
+        originalChars: text.length,
+        truncated: text.length > INVENTORY_PREVIEW_MAX_CHARS,
+    });
+}
+function fingerprint(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}

package/dist/src/runtime/steps/auditor-decision/evidence-representation.d.ts

@@ -0,0 +1,10 @@
+import type { AuditorCapabilityEvidence } from "./contracts.js";
+type SupplementField = "summary" | "referenceData" | "references";
+type AdapterPath = readonly (string | number)[];
+type RepresentedFields = Partial<Record<SupplementField, AdapterPath>>;
+export type AuditorEvidenceRepresentation = Readonly<Omit<AuditorCapabilityEvidence, SupplementField> & Partial<Pick<AuditorCapabilityEvidence, SupplementField>> & {
+    representedFields?: Readonly<RepresentedFields>;
+}>;
+/** Canonical records and their exact adapter envelopes are never rewritten. */
+export declare function projectAuditorEvidenceRepresentation(evidence: AuditorCapabilityEvidence): AuditorEvidenceRepresentation;
+export {};

package/dist/src/runtime/steps/auditor-decision/evidence-representation.js

@@ -0,0 +1,56 @@
+/** Canonical records and their exact adapter envelopes are never rewritten. */
+export function projectAuditorEvidenceRepresentation(evidence) {
+    const represented = {
+        ...evidence,
+    };
+    const representedFields = {};
+    for (const field of ["summary", "referenceData", "references"]) {
+        const supplement = evidence[field];
+        if (supplement === undefined)
+            continue;
+        const path = findExactAdapterPath(evidence.adapterResult, supplement);
+        if (!path)
+            continue;
+        delete represented[field];
+        representedFields[field] = path;
+    }
+    return Object.freeze({
+        ...represented,
+        ...(Object.keys(representedFields).length > 0
+            ? { representedFields: Object.freeze(representedFields) }
+            : {}),
+    });
+}
+function findExactAdapterPath(adapterResult, supplement) {
+    const expectedArray = Array.isArray(supplement)
+        ? JSON.stringify(supplement)
+        : undefined;
+    function visit(value, path) {
+        if (isExactSupplementValue(value, supplement, expectedArray))
+            return Object.freeze([...path]);
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index += 1) {
+                const found = visit(value[index], [...path, index]);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        if (value !== null && typeof value === "object") {
+            for (const [key, child] of Object.entries(value)) {
+                const found = visit(child, [...path, key]);
+                if (found)
+                    return found;
+            }
+        }
+        return undefined;
+    }
+    return visit(adapterResult, []);
+}
+function isExactSupplementValue(value, supplement, expectedArray) {
+    if (typeof supplement === "string")
+        return value === supplement;
+    if (!Array.isArray(value) || expectedArray === undefined)
+        return false;
+    return JSON.stringify(value) === expectedArray;
+}

package/dist/src/runtime/steps/auditor-decision/evidence-selection.d.ts

@@ -0,0 +1,9 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { StructuredModelParseResult } from "../../model/invoke-structured-step.js";
+import type { AuditorAssignment } from "./contracts.js";
+export type AuditorEvidenceSelection = Readonly<{
+    auditId: string;
+    selectedEvidenceIds: readonly string[];
+}>;
+export declare function createAuditorEvidenceSelectionFormat(assignment: AuditorAssignment): ModelGatewayJsonSchemaFormat;
+export declare function parseAuditorEvidenceSelection(text: string, assignment: AuditorAssignment): StructuredModelParseResult<AuditorEvidenceSelection>;

package/dist/src/runtime/steps/auditor-decision/evidence-selection.js

@@ -0,0 +1,71 @@
+import { createStructuredDecisionEnvelopeSchema, readStructuredDecisionEnvelope, } from "../../model/structured-decision-envelope.js";
+import { auditEvidenceSelectionIssue } from "./evidence-binding.js";
+export function createAuditorEvidenceSelectionFormat(assignment) {
+    return Object.freeze({
+        type: "json_schema",
+        name: "auditor_evidence_selection",
+        strict: true,
+        schema: createStructuredDecisionEnvelopeSchema([
+            {
+                type: "object",
+                additionalProperties: false,
+                required: ["auditId", "selectedEvidenceIds"],
+                properties: {
+                    auditId: { type: "string", enum: [assignment.auditId] },
+                    selectedEvidenceIds: {
+                        type: "array",
+                        minItems: 1,
+                        maxItems: assignment.inventory.length,
+                        items: {
+                            type: "string",
+                            enum: assignment.inventory.map(({ executionId }) => executionId),
+                        },
+                    },
+                },
+            },
+        ]),
+    });
+}
+export function parseAuditorEvidenceSelection(text, assignment) {
+    let decoded;
+    try {
+        decoded = JSON.parse(text);
+    }
+    catch {
+        return reject("auditor_selection_not_json");
+    }
+    const decision = readStructuredDecisionEnvelope(decoded);
+    if (!decision)
+        return reject("auditor_selection_envelope_invalid");
+    if (!hasExactSelectionFields(decision))
+        return reject("auditor_selection_shape_invalid");
+    if (decision.auditId !== assignment.auditId)
+        return reject("auditor_selection_id_mismatch");
+    const issue = auditEvidenceSelectionIssue(decision.selectedEvidenceIds, assignment);
+    if (issue)
+        return reject(issue);
+    return Object.freeze({
+        ok: true,
+        decision: Object.freeze({
+            auditId: assignment.auditId,
+            selectedEvidenceIds: Object.freeze([
+                ...decision.selectedEvidenceIds,
+            ]),
+        }),
+    });
+}
+function hasExactSelectionFields(value) {
+    if (Object.keys(value).length !== 2)
+        return false;
+    return (Object.hasOwn(value, "auditId") &&
+        Object.hasOwn(value, "selectedEvidenceIds"));
+}
+function reject(code) {
+    return Object.freeze({
+        ok: false,
+        stage: "domain_parser",
+        issues: Object.freeze([
+            { code, path: "decision.selectedEvidenceIds", message: code },
+        ]),
+    });
+}