@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/runtime/scheduler/snapshot-validation.js

@@ -1,4 +1,5 @@
 import { normalizeStoredSchedulerSchedule, validateSchedulerJobInput, validateTimeZone, } from "./schedule-validation.js";
+import { isSchedulerToolPermissionMode, requireSchedulerToolPermissionMode, } from "./tool-permission-mode.js";
 function isRecord(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -20,7 +21,7 @@ export function parseStoredJob(value) {
     validateSchedulerJobInput(job);
     if (!job.id || !job.environmentId)
         failSnapshot();
-    if (job.toolPermissionMode !== "full_access")
+    if (!isSchedulerToolPermissionMode(job.toolPermissionMode))
         failSnapshot();
     if (!["active", "paused", "cancelled", "completed"].includes(job.state))
         failSnapshot();
@@ -61,6 +62,7 @@ export function parseStoredRun(value) {
         failSnapshot();
     if (Number(value.jobRevision) < 1)
         failSnapshot();
+    requireSchedulerToolPermissionMode(value.toolPermissionMode);
     validateTimeZone(String(value.timeZone));
     const states = [
         "pending",

package/dist/src/runtime/scheduler/tool-permission-mode.d.ts

@@ -0,0 +1,5 @@
+import type { ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
+export type SchedulerToolPermissionMode = Extract<ToolPermissionMode, "full_access" | "full_plus">;
+export declare function isSchedulerToolPermissionMode(value: unknown): value is SchedulerToolPermissionMode;
+/** Missing authority belongs to legacy Full jobs and runs; never upgrade it. */
+export declare function requireSchedulerToolPermissionMode(value: unknown): SchedulerToolPermissionMode;

package/dist/src/runtime/scheduler/tool-permission-mode.js

@@ -0,0 +1,14 @@
+import { SchedulerValidationError } from "./validation-error.js";
+export function isSchedulerToolPermissionMode(value) {
+    if (value === "full_access")
+        return true;
+    return value === "full_plus";
+}
+/** Missing authority belongs to legacy Full jobs and runs; never upgrade it. */
+export function requireSchedulerToolPermissionMode(value) {
+    if (value === undefined)
+        return "full_access";
+    if (isSchedulerToolPermissionMode(value))
+        return value;
+    throw new SchedulerValidationError("scheduler_invalid_job", "toolPermissionMode must be full_access or full_plus");
+}

package/dist/src/runtime/session/cancelled-response.d.ts

@@ -0,0 +1,12 @@
+import type { SessionThinkingTraceEntry } from "../../sessions/types.js";
+import type { RequestSessionStore } from "../request/session-store.js";
+type CancelledResponseParams = {
+    sessionStore: Pick<RequestSessionStore, "getOrCreateSession" | "appendMessage">;
+    sessionId: string;
+    requestId: string;
+    partialAnswer: string;
+    thinkingTrace?: SessionThinkingTraceEntry[];
+};
+/** Called only after opening the request session; the terminal remains cancelled. */
+export declare function persistCancelledResponse(params: CancelledResponseParams): Promise<Record<string, unknown>>;
+export {};

package/dist/src/runtime/session/cancelled-response.js

@@ -0,0 +1,39 @@
+import { traceDebug } from "../observability/debug-logger.js";
+/** Called only after opening the request session; the terminal remains cancelled. */
+export async function persistCancelledResponse(params) {
+    try {
+        const stoppedResponse = await appendCancelledResponse(params);
+        if (stoppedResponse === undefined)
+            return {};
+        return { stoppedResponse };
+    }
+    catch (error) {
+        traceDebug("runtime.request", "cancelled_response.persist_failed", {
+            requestId: params.requestId,
+            sessionId: params.sessionId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return { stoppedResponsePersistenceFailed: true };
+    }
+}
+async function appendCancelledResponse(params) {
+    const session = await params.sessionStore.getOrCreateSession(params.sessionId);
+    const requestMessages = session.messages.filter((message) => message.requestId === params.requestId);
+    const hasPersistedUserMessage = requestMessages.some((message) => message.role === "user");
+    if (!hasPersistedUserMessage)
+        return undefined;
+    const existingResponse = requestMessages.find((message) => message.role === "assistant");
+    if (existingResponse)
+        return existingResponse.content;
+    const acknowledgement = "I stopped the task at your request.";
+    const output = params.partialAnswer.trim()
+        ? `${params.partialAnswer}\n\n${acknowledgement}`
+        : acknowledgement;
+    await params.sessionStore.appendMessage(params.sessionId, "assistant", output, {
+        requestId: params.requestId,
+        source: "request",
+        grounding: "conversation",
+        thinkingTrace: params.thinkingTrace,
+    });
+    return output;
+}

package/dist/src/runtime/session/request-activation.d.ts

@@ -0,0 +1,3 @@
+import type { SessionRequestLifecycleSnapshot, SessionRequestLifecycleStore, SessionStartActivationCommand } from "../../sessions/request-lifecycle/contracts.js";
+/** A failed acknowledgement cannot leave this owner's initial activation live. */
+export declare function startRequestActivation(store: SessionRequestLifecycleStore, sessionId: string, command: SessionStartActivationCommand): Promise<SessionRequestLifecycleSnapshot>;

package/dist/src/runtime/session/request-activation.js

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+import { SessionCommitOutcomeUnknownError } from "../../sessions/durable-session-commit.js";
+/** A failed acknowledgement cannot leave this owner's initial activation live. */
+export async function startRequestActivation(store, sessionId, command) {
+    try {
+        const started = await store.startActivation(sessionId, command);
+        if (!started.accepted)
+            throw new Error(`request_activation_rejected:${started.reason}`);
+        return started.current;
+    }
+    catch (error) {
+        if (!(error instanceof SessionCommitOutcomeUnknownError))
+            throw error;
+        const current = await store.get(sessionId, command.requestId);
+        if (!isUnconfirmedInitialActivation(current, command))
+            throw error;
+        // No runner has started. Close the exact visible activation before its
+        // owner releases the control; an uncertain commit never permits dispatch.
+        const interrupted = await store.interruptActivation(sessionId, {
+            expected: {
+                requestId: current.requestId,
+                generation: current.generation,
+                revision: current.revision,
+                activationId: command.activationId,
+                ownerEpoch: command.ownerEpoch,
+            },
+            commandId: randomUUID(),
+            message: {
+                content: "The task was interrupted because its startup could not be saved reliably.",
+            },
+        });
+        if (!interrupted.accepted)
+            throw new Error(`request_activation_interruption_rejected:${interrupted.reason}`, { cause: error });
+        throw error;
+    }
+}
+function isUnconfirmedInitialActivation(current, command) {
+    if (current?.status !== "streaming")
+        return false;
+    if (current.activation?.activationId !== command.activationId)
+        return false;
+    return current.activation.ownerEpoch === command.ownerEpoch;
+}

package/dist/src/runtime/session/request-history.js

@@ -1,10 +1,17 @@
+import { isAssistantInitiativeMessage } from "../../sessions/assistant-initiative.js";
 export function snapshotRequestHistory(session) {
-    return session.messages.map((message) => ({
+    return session.messages.filter(isRequestHistoryMessage).map((message) => ({
         id: message.id,
         role: message.role,
         content: message.content,
         createdAt: message.createdAt,
         ...(message.requestId ? { requestId: message.requestId } : {}),
         ...(message.grounding ? { grounding: message.grounding } : {}),
+        ...(isAssistantInitiativeMessage(message)
+            ? { assistantInitiativeId: message.initiative.proposalId }
+            : {}),
     }));
 }
+function isRequestHistoryMessage(message) {
+    return message.kind !== "tool_approval_request";
+}

package/dist/src/runtime/session/request-session.d.ts

@@ -1,5 +1,6 @@
 import type { ModelGatewayAttachment } from "../../model-gateway/types.js";
 import type { SessionRecord } from "../../sessions/types.js";
+import type { SessionActivation, SessionRequestLifecycleSnapshot } from "../../sessions/request-lifecycle/contracts.js";
 import type { AgentMode } from "../../shared/types.js";
 import type { RuntimeAttachmentReference, RuntimeAttachmentStore } from "../attachments/store.js";
 import type { EventSink } from "../ports.js";
@@ -8,6 +9,7 @@ import type { RequestSessionStore } from "../request/session-store.js";
 type OpenedRequestSession = {
     session: SessionRecord;
     attachments: RuntimeAttachmentReference[];
+    activation?: SessionRequestLifecycleSnapshot;
 };
 export declare function openRequestSession(params: {
     sessionId: string;
@@ -15,6 +17,7 @@ export declare function openRequestSession(params: {
     rawAttachments: unknown;
     sessionStore: RequestSessionStore;
     attachmentStore?: RuntimeAttachmentStore;
+    activation?: SessionActivation;
 }): Promise<OpenedRequestSession>;
 export declare function initializeRequestSession(params: {
     opened: OpenedRequestSession;

package/dist/src/runtime/session/request-session.js

@@ -1,5 +1,6 @@
 import { appendRequestAttachmentManifest } from "../orchestration/request/request-attachment-prompt.js";
 import { resolveModelGatewayAttachments, resolveRequestAttachments, resolveToolRequestAttachments, } from "../orchestration/request/request-attachments.js";
+import { startRequestActivation } from "./request-activation.js";
 export async function openRequestSession(params) {
     if (!params.sessionId) {
         throw new Error("sessionId required");
@@ -10,6 +11,17 @@ export async function openRequestSession(params) {
         sessionId: params.sessionId,
         attachmentStore: params.attachmentStore,
     });
+    if (params.activation) {
+        const store = params.sessionStore.requestLifecycle;
+        if (!store)
+            throw new Error("durable_approval_store_unavailable");
+        // The first persisted running record already has its recoverable activation.
+        const activation = await startRequestActivation(store, params.sessionId, {
+            requestId: params.requestId,
+            ...params.activation,
+        });
+        return { session, attachments, activation };
+    }
     await params.sessionStore.startRequestStream(params.sessionId, params.requestId);
     return { session, attachments };
 }
@@ -25,6 +37,9 @@ export async function initializeRequestSession(params) {
             ? { attachments: params.opened.attachments }
             : {}),
     });
+    params.events.event("session.messages.updated", {
+        sessionId: params.sessionId,
+    });
     if (params.schedule) {
         const message = persisted.messages.find((entry) => entry.requestId === params.requestId && entry.role === "user");
         params.events.event("schedule.triggered", {

package/dist/src/runtime/session/session-lifecycle-store.js

@@ -35,6 +35,25 @@ export function createSessionLifecycleStore(base, finalizeDeletion) {
         };
     }
     const store = {
+        ...(base.requestLifecycle
+            ? {
+                requestLifecycle: {
+                    ...base.requestLifecycle,
+                    startActivation: wrapSessionMutation(base.requestLifecycle.startActivation),
+                    commitWait: wrapSessionMutation(base.requestLifecycle.commitWait),
+                    commitDecision: wrapSessionMutation(base.requestLifecycle.commitDecision),
+                    cancelWait: wrapSessionMutation(base.requestLifecycle.cancelWait),
+                    interruptActivation: wrapSessionMutation(base.requestLifecycle.interruptActivation),
+                    commitTerminal: wrapSessionMutation(base.requestLifecycle.commitTerminal),
+                    appendActivationEvent: wrapSessionMutation(base.requestLifecycle.appendActivationEvent),
+                },
+            }
+            : {}),
+        ...(base.createAssistantConversation
+            ? {
+                createAssistantConversation: wrapSessionMutation(base.createAssistantConversation),
+            }
+            : {}),
         getAllSessions: base.getAllSessions.bind(base),
         listSessions: base.listSessions.bind(base),
         getSessionById: base.getSessionById.bind(base),

package/dist/src/runtime/session/session-title.js

@@ -1,3 +1,4 @@
+import { getRequestFinalState } from "../../sessions/record/projection.js";
 import { traceDebug } from "../observability/debug-logger.js";
 export function createRequestSessionTitleUpdater(params) {
     return async (title) => {
@@ -33,6 +34,22 @@ export function createRequestSessionTitleUpdater(params) {
     };
 }
 export function shouldGenerateSessionTitle(session) {
-    return (session.messages.length === 0 &&
-        (!session.title.trim() || session.title === session.id));
+    const hasPlaceholderTitle = !session.title.trim() || session.title === session.id;
+    if (!hasPlaceholderTitle)
+        return false;
+    if (session.messages.length === 0)
+        return true;
+    return hasOnlyCancelledRequestMessages(session);
+}
+function hasOnlyCancelledRequestMessages(session) {
+    const cancelledIds = new Set((session.requests ?? [])
+        .filter(isUserCancelledRequest)
+        .map(({ requestId }) => requestId));
+    return session.messages.every((message) => cancelledIds.has(message.requestId ?? ""));
+}
+function isUserCancelledRequest(request) {
+    if (request.status !== "failed")
+        return false;
+    const terminal = getRequestFinalState(request);
+    return (terminal?.status === "failed" && terminal.error === "request_cancelled");
 }

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

@@ -0,0 +1,32 @@
+import type { AuditorAssignment, AuditorDecision } from "./contracts.js";
+export declare const AUDITOR_ADVISORY_KIND = "runtime_execution_agent_auditor_advisory_v1";
+declare const EVIDENCE_BINDING_KIND = "runtime_auditor_evidence_binding_v1";
+export type AuditorAdvisoryReceipt = Readonly<{
+    auditId: string;
+    verdict: "pass" | "gaps" | "needs_evidence" | "failed";
+    requestedEvidenceIds: readonly string[];
+    evidenceBinding: Readonly<{
+        kind: typeof EVIDENCE_BINDING_KIND;
+        workFingerprint: string;
+        selectedEvidenceIds: readonly string[];
+        bundleFingerprint: string | null;
+    }>;
+}>;
+export declare function settleAuditorAdvisory(assignment: AuditorAssignment, decision: AuditorDecision): Readonly<{
+    kind: "terminal";
+    outcome: "failed";
+    summary: string;
+}> | Readonly<{
+    kind: "terminal";
+    outcome: "completed";
+    summary: string;
+}>;
+export declare function serializeAuditorAdvisory(assignment: AuditorAssignment, decision: AuditorDecision): string;
+export declare function isAuditorAdvisorySummaryAdmissible(summary: string): boolean;
+export declare function failedAuditorAdvisory(assignment: AuditorAssignment, reason: string): Readonly<{
+    kind: "terminal";
+    outcome: "failed";
+    summary: string;
+}>;
+export declare function readAuditorAdvisoryReceipt(summary: string): AuditorAdvisoryReceipt | undefined;
+export {};

package/dist/src/runtime/steps/auditor-decision/advisory-receipt.js

@@ -0,0 +1,106 @@
+import { ROLE_CALL_RESULT_MAX_LENGTH } from "../../orchestration/role-calls/index.js";
+import { fingerprintAuditorBundle } from "./evidence-inventory.js";
+export const AUDITOR_ADVISORY_KIND = "runtime_execution_agent_auditor_advisory_v1";
+const EVIDENCE_BINDING_KIND = "runtime_auditor_evidence_binding_v1";
+export function settleAuditorAdvisory(assignment, decision) {
+    const summary = serializeAuditorAdvisory(assignment, decision);
+    if (!isAuditorAdvisorySummaryAdmissible(summary)) {
+        return failedAuditorAdvisory(assignment, "auditor_result_not_admissible");
+    }
+    return Object.freeze({
+        kind: "terminal",
+        outcome: "completed",
+        summary,
+    });
+}
+export function serializeAuditorAdvisory(assignment, decision) {
+    return JSON.stringify({
+        kind: AUDITOR_ADVISORY_KIND,
+        authority: "model_advisory",
+        presenceEffect: "passive_result_not_execution_or_completion",
+        ...decision,
+        evidenceBinding: binding(assignment),
+    });
+}
+export function isAuditorAdvisorySummaryAdmissible(summary) {
+    return summary.length <= ROLE_CALL_RESULT_MAX_LENGTH;
+}
+export function failedAuditorAdvisory(assignment, reason) {
+    return Object.freeze({
+        kind: "terminal",
+        outcome: "failed",
+        summary: JSON.stringify({
+            kind: AUDITOR_ADVISORY_KIND,
+            authority: "runtime_validation",
+            presenceEffect: "passive_result_not_execution_or_completion",
+            auditId: assignment.auditId,
+            verdict: "failed",
+            requestedEvidenceIds: [],
+            reason,
+            evidenceBinding: binding(assignment),
+        }),
+    });
+}
+export function readAuditorAdvisoryReceipt(summary) {
+    let value;
+    try {
+        value = JSON.parse(summary);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(value) || value.kind !== AUDITOR_ADVISORY_KIND)
+        return undefined;
+    if (typeof value.auditId !== "string")
+        return undefined;
+    if (!isAuditorVerdict(value.verdict))
+        return undefined;
+    if (!hasAdvisoryAuthority(value.authority, value.verdict))
+        return undefined;
+    if (!isStringArray(value.requestedEvidenceIds))
+        return undefined;
+    const source = value.evidenceBinding;
+    if (!isRecord(source) || source.kind !== EVIDENCE_BINDING_KIND)
+        return undefined;
+    if (typeof source.workFingerprint !== "string")
+        return undefined;
+    if (!isStringArray(source.selectedEvidenceIds))
+        return undefined;
+    const expectedBundle = source.selectedEvidenceIds.length > 0
+        ? fingerprintAuditorBundle(source.workFingerprint, source.selectedEvidenceIds)
+        : null;
+    if (source.bundleFingerprint !== expectedBundle)
+        return undefined;
+    return value;
+}
+function binding(assignment) {
+    return Object.freeze({
+        kind: EVIDENCE_BINDING_KIND,
+        workFingerprint: assignment.workFingerprint,
+        selectedEvidenceIds: assignment.selectedEvidenceIds,
+        bundleFingerprint: assignment.selectedEvidenceIds.length > 0
+            ? fingerprintAuditorBundle(assignment.workFingerprint, assignment.selectedEvidenceIds)
+            : null,
+    });
+}
+function isAuditorVerdict(value) {
+    return (value === "pass" ||
+        value === "gaps" ||
+        value === "needs_evidence" ||
+        value === "failed");
+}
+function hasAdvisoryAuthority(authority, verdict) {
+    if (verdict === "failed")
+        return authority === "runtime_validation";
+    return authority === "model_advisory";
+}
+function isStringArray(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (!value.every((item) => typeof item === "string"))
+        return false;
+    return new Set(value).size === value.length;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/runtime/steps/auditor-decision/advisory-result-budget.d.ts

@@ -0,0 +1,5 @@
+import { type AuditorAssignment } from "./contracts.js";
+export declare class AuditorAdvisoryCapacityError extends Error {
+    constructor();
+}
+export declare function getAuditorAdvisoryDescriptionMaxLength(assignment: AuditorAssignment): number;

package/dist/src/runtime/steps/auditor-decision/advisory-result-budget.js

@@ -0,0 +1,40 @@
+import { ROLE_CALL_RESULT_MAX_LENGTH } from "../../orchestration/role-calls/index.js";
+import { serializeAuditorAdvisory } from "./advisory-receipt.js";
+import { AUDITOR_DECISION_TEXT_MAX_LENGTH, } from "./contracts.js";
+// JSON uses at most six UTF-16 units per Unicode code point, including escapes.
+const JSON_STRING_MAX_ESCAPE_CHARS_PER_CODE_POINT = 6;
+export class AuditorAdvisoryCapacityError extends Error {
+    constructor() {
+        super("auditor_result_metadata_exceeds_budget");
+        this.name = "AuditorAdvisoryCapacityError";
+    }
+}
+export function getAuditorAdvisoryDescriptionMaxLength(assignment) {
+    const ids = assignment.inventory.map(({ executionId }) => executionId);
+    // All IDs in one partition is at least as large as any valid split. Reserving
+    // every ID in the requested bundle preserves every offered evidence choice.
+    const reservedEnvelope = serializeAuditorAdvisory(assignment, {
+        auditId: assignment.auditId,
+        verdict: "needs_evidence",
+        criterionIds: assignment.criterionIds,
+        gaps: assignment.criterionIds.map((criterionId) => ({
+            criterionId,
+            description: "",
+        })),
+        neededEvidenceIds: ids,
+        notNeededEvidenceIds: [],
+        requestedEvidenceIds: ids,
+    });
+    const remainingChars = ROLE_CALL_RESULT_MAX_LENGTH - reservedEnvelope.length;
+    const escapedCharsPerDescriptionUnit = JSON_STRING_MAX_ESCAPE_CHARS_PER_CODE_POINT *
+        assignment.criterionIds.length;
+    const maxLength = Math.min(AUDITOR_DECISION_TEXT_MAX_LENGTH, Math.floor(remainingChars / escapedCharsPerDescriptionUnit));
+    if (!hasAuditorDescriptionCapacity(maxLength))
+        throw new AuditorAdvisoryCapacityError();
+    return maxLength;
+}
+function hasAuditorDescriptionCapacity(maxLength) {
+    if (!Number.isSafeInteger(maxLength))
+        return false;
+    return maxLength >= 1;
+}

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

@@ -0,0 +1,12 @@
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type AuditorCapabilityEvidence } from "./contracts.js";
+export type AuditorInputState = Readonly<{
+    available: boolean;
+    reason: string;
+    workFingerprint: string;
+    pendingEvidenceIds: readonly string[] | null;
+    reviewedBundleFingerprints: readonly string[];
+    reviewedEvidenceBundles: readonly (readonly string[])[];
+    reviewedBundleCount: number;
+}>;
+export declare function projectAuditorInputState(head: RoleCallLedgerHead, callerCallId: string, steeringVersion: number, criterionIds?: readonly string[], suppliedEvidence?: readonly AuditorCapabilityEvidence[]): AuditorInputState;

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 };
+}