@abot-ai/runtime 1.0.0

package/dist/src/runtime/steps/reviewer-decision/diagnostics.js

@@ -0,0 +1,246 @@
+import { traceDebug } from "../../observability/debug-logger.js";
+import { REVIEWER_ROLE_ID, } from "./contracts.js";
+const REVIEWER_LOG_SCOPE = "runtime.reviewer";
+const REVIEWER_LOG_ISSUE_LIMIT = 16;
+export function traceReviewerContextProjected(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "context.projected", {
+        ...baseFields(params.diagnostic),
+        reviewScopeId: params.snapshot.reviewScopeId,
+        sourceRevision: params.snapshot.sourceRevision,
+        objectiveLength: params.objectiveLength,
+        messageCount: params.context.messages.length,
+        messageCharacterCount: params.context.messages.reduce((total, message) => total + message.content.length, 0),
+        historyMessageCount: 0,
+        attachmentCount: 0,
+        referenceMessageCount: params.referenceMessageCount,
+        modelContextContract: "runtime_reviewer_audit_v2",
+        auditCapsuleCharacterCount: params.auditCapsuleCharacterCount,
+        evidenceAppendixCharacterCount: params.evidenceAppendixCharacterCount,
+        continuationMessageCount: 0,
+        projectContextIncluded: false,
+        plannedWorkContextIncluded: false,
+        capabilityContextIncluded: false,
+        projectionComplete: params.snapshot.projectionComplete,
+        freshness: params.snapshot.freshness,
+        subjectCount: params.snapshot.subjects.length,
+        factCount: params.snapshot.facts.length,
+        factStatusCounts: countFactStatuses(params.snapshot),
+        evidenceCount: params.snapshot.evidence.length,
+        allowedGapKindCount: params.snapshot.allowedGapKinds.length,
+        allowedGapKinds: params.snapshot.allowedGapKinds,
+        subjectSummaryLength: sumLengths(params.snapshot.subjects.map(({ summary }) => summary)),
+        factSummaryLength: sumLengths(params.snapshot.facts.map(({ summary }) => summary)),
+        evidenceSummaryLength: sumLengths(params.snapshot.evidence.map(({ summary }) => summary)),
+        evidenceReferenceDataCount: params.snapshot.evidence.filter(({ referenceData }) => referenceData !== undefined).length,
+        evidenceReferenceDataLength: sumLengths(params.snapshot.evidence.flatMap(({ referenceData }) => referenceData ? [referenceData] : [])),
+        schemaCharacterCount: JSON.stringify(params.format.schema).length,
+        contextWindowTokens: params.context.budget.contextWindowTokens,
+        estimatedInputTokens: params.context.budget.estimatedInputTokens,
+        availableInputTokens: params.context.budget.availableInputTokens,
+        outputReserveTokens: params.context.budget.outputReserveTokens,
+        safetyReserveTokens: params.context.budget.safetyReserveTokens,
+        formatReserveTokens: params.context.budget.formatReserveTokens,
+        attachmentReserveTokens: params.context.budget.attachmentReserveTokens,
+        allowedActions: params.snapshot.projectionComplete &&
+            params.snapshot.freshness !== "unavailable"
+            ? ["pass", "report_gaps"]
+            : ["report_gaps"],
+        configuredInstructionBlockCount: params.configuredInstructionBlockCount,
+        configuredInstructionCharacterCount: params.configuredInstructionCharacterCount,
+        configuredInstructionRefs: params.configuredInstructionRefs,
+        configuredInstructionContentHashes: params.configuredInstructionContentHashes,
+    });
+}
+export function traceReviewerContextRejected(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "context.rejected", {
+        ...baseFields(params.diagnostic),
+        issueCount: params.issues.length,
+        issues: boundedIssues(params.issues),
+        truncatedIssueCount: Math.max(0, params.issues.length - REVIEWER_LOG_ISSUE_LIMIT),
+    });
+}
+export function traceReviewerEnvelopeAccepted(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "output.envelope.accepted", {
+        ...baseFields(params.diagnostic),
+        validationStage: "json_envelope",
+        outputLength: params.outputLength,
+        rootType: "object",
+        keyCount: params.keyCount,
+    });
+}
+export function traceReviewerEnvelopeRejected(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "output.envelope.rejected", {
+        ...baseFields(params.diagnostic),
+        validationStage: "json_envelope",
+        outputLength: params.outputLength,
+        issueCount: params.issues.length,
+        issues: boundedIssues(params.issues),
+    });
+}
+export function traceReviewerDecisionAccepted(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "decision.accepted", {
+        ...baseFields(params.diagnostic),
+        validationStage: "domain_parser",
+        reviewScopeId: params.decision.reviewScopeId,
+        selectedAction: params.decision.action,
+        decisionSerializedLength: JSON.stringify(params.decision).length,
+        summaryLength: params.decision.summary.length,
+        gapCount: params.decision.gaps.length,
+        gapKinds: params.decision.gaps.map(({ kind }) => kind),
+        gapSubjectRefCount: sumCounts(params.decision.gaps.map(({ subjectRefs }) => subjectRefs)),
+        gapFactRefCount: sumCounts(params.decision.gaps.map(({ factRefs }) => factRefs)),
+        gapEvidenceRefCount: sumCounts(params.decision.gaps.map(({ evidenceRefs }) => evidenceRefs)),
+        gapSummaryLength: sumLengths(params.decision.gaps.map(({ summary }) => summary)),
+    });
+}
+export function traceReviewerDecisionTextNormalized(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "decision.text_normalized", {
+        ...baseFields(params.diagnostic),
+        validationStage: "domain_parser",
+        path: params.path,
+        reason: "max_length",
+        inputLength: params.inputLength,
+        outputLength: params.outputLength,
+        maxLength: params.maxLength,
+    });
+}
+export function traceReviewerDecisionRejected(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "decision.rejected", {
+        ...baseFields(params.diagnostic),
+        validationStage: "domain_parser",
+        ...(params.selectedAction ? { selectedAction: params.selectedAction } : {}),
+        issueCount: params.issues.length,
+        issues: boundedIssues(params.issues),
+        truncatedIssueCount: Math.max(0, params.issues.length - REVIEWER_LOG_ISSUE_LIMIT),
+    });
+}
+export function traceReviewerModelStarted(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "model.started", {
+        ...baseFields(params.diagnostic),
+        messageCount: params.messageCount,
+        messageCharacterCount: params.messageCharacterCount,
+        allowedActions: ["pass", "report_gaps"],
+    });
+}
+export function traceReviewerModelCompleted(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "model.completed", {
+        ...baseFields(params.diagnostic),
+        durationMs: params.durationMs,
+        selectedAction: params.decision.action,
+        decisionSerializedLength: JSON.stringify(params.decision).length,
+        summaryLength: params.decision.summary.length,
+        gapCount: params.decision.gaps.length,
+    });
+}
+export function traceReviewerModelFailed(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "model.failed", {
+        ...baseFields(params.diagnostic),
+        durationMs: params.durationMs,
+        errorType: params.errorType,
+        invalidStructuredOutput: params.invalidStructuredOutput,
+    });
+}
+export function traceReviewerExecutionMapped(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "execution.mapped", {
+        requestId: params.requestId,
+        role: REVIEWER_ROLE_ID,
+        callId: params.call.callId,
+        parentCallId: params.call.parentCallId,
+        depth: params.call.depth,
+        invocationAttempt: params.call.activationCount,
+        sourceRevision: params.sourceRevision,
+        selectedAction: params.decision.action,
+        gapCount: params.decision.gaps.length,
+        serializedLength: params.serializedLength,
+        mappedOutcome: "completed",
+    });
+}
+export function traceReviewerSnapshotProjected(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "snapshot.projected", {
+        requestId: params.requestId,
+        role: REVIEWER_ROLE_ID,
+        callId: params.call.callId,
+        parentCallId: params.call.parentCallId,
+        depth: params.call.depth,
+        invocationAttempt: params.call.activationCount,
+        reviewScopeId: params.snapshot.reviewScopeId,
+        sourceRevision: params.snapshot.sourceRevision,
+        projectionComplete: params.snapshot.projectionComplete,
+        freshness: params.snapshot.freshness,
+        callerObjectiveSource: params.callerObjectiveSource,
+        subjectCount: params.snapshot.subjects.length,
+        factCount: params.snapshot.facts.length,
+        factStatusCounts: countFactStatuses(params.snapshot),
+        evidenceCount: params.snapshot.evidence.length,
+        sourceCapabilityExecutionCount: params.finalEvidence.sourceExecutionCount,
+        supersededCapabilityExecutionCount: params.finalEvidence.supersededExecutionCount,
+        retainedFailedCapabilityExecutionCount: params.finalEvidence.retainedFailedExecutionCount,
+        retainedUntargetedCapabilityExecutionCount: params.finalEvidence.retainedUntargetedExecutionCount,
+        sourceReferenceDataCount: params.finalEvidence.sourceReferenceDataCount,
+        sourceReferenceDataChars: params.finalEvidence.sourceReferenceDataChars,
+        retainedReferenceDataCount: params.finalEvidence.retainedReferenceDataCount,
+        retainedReferenceDataChars: params.finalEvidence.retainedReferenceDataChars,
+        omittedReferenceDataCount: params.finalEvidence.omittedReferenceDataCount,
+        omittedReferenceDataChars: params.finalEvidence.omittedReferenceDataChars,
+        evidenceEffectCounts: countEvidenceEffects(params.snapshot),
+    });
+}
+export function traceReviewerSnapshotRejected(params) {
+    traceDebug(REVIEWER_LOG_SCOPE, "snapshot.rejected", {
+        requestId: params.requestId,
+        role: REVIEWER_ROLE_ID,
+        callId: params.call.callId,
+        parentCallId: params.call.parentCallId,
+        depth: params.call.depth,
+        invocationAttempt: params.call.activationCount,
+        issueCode: params.issueCode,
+    });
+}
+function baseFields(diagnostic) {
+    return {
+        requestId: diagnostic.requestId,
+        role: REVIEWER_ROLE_ID,
+        modelStep: diagnostic.modelStep,
+        callId: diagnostic.callId,
+        parentCallId: diagnostic.parentCallId,
+        depth: diagnostic.depth,
+        invocationAttempt: diagnostic.invocationAttempt,
+    };
+}
+function boundedIssues(issues) {
+    return issues
+        .slice(0, REVIEWER_LOG_ISSUE_LIMIT)
+        .map(({ code, path }) => ({ code, path }));
+}
+function sumCounts(values) {
+    return values.reduce((total, value) => total + value.length, 0);
+}
+function sumLengths(values) {
+    return values.reduce((total, value) => total + value.length, 0);
+}
+function countFactStatuses(snapshot) {
+    const counts = {
+        satisfied: 0,
+        missing: 0,
+        mismatched: 0,
+        contradictory: 0,
+        indeterminate: 0,
+        informational: 0,
+    };
+    for (const { status } of snapshot.facts) {
+        counts[status] += 1;
+    }
+    return Object.freeze(counts);
+}
+function countEvidenceEffects(snapshot) {
+    const counts = {
+        none: 0,
+        observation: 0,
+        mutation: 0,
+        indeterminate: 0,
+    };
+    for (const { effect } of snapshot.evidence) {
+        counts[effect] += 1;
+    }
+    return Object.freeze(counts);
+}

package/dist/src/runtime/steps/reviewer-decision/final-evidence.d.ts

@@ -0,0 +1,42 @@
+import type { ModelTokenEstimationConfig } from "../../../model-gateway/types.js";
+import type { RoleCapabilityObservedEffect, RoleCapabilityResultReference } from "../../orchestration/role-calls/index.js";
+import { type ReviewerEvidence } from "./contracts.js";
+export type ReviewerReferenceDataBudget = Readonly<{
+    maxTokens: number;
+    tokenEstimation?: ModelTokenEstimationConfig;
+}>;
+export type ReviewerEvidenceCandidate = Readonly<{
+    executionId: string;
+    outcome: "succeeded" | "failed";
+    observedEffect: RoleCapabilityObservedEffect;
+    summary: string;
+    referenceData?: string;
+    references?: readonly RoleCapabilityResultReference[];
+    subjectRef: string;
+}>;
+export type ReviewerFinalEvidenceProjection = Readonly<{
+    evidence: readonly ReviewerEvidence[];
+    projectionComplete: boolean;
+    sourceExecutionCount: number;
+    supersededExecutionCount: number;
+    retainedFailedExecutionCount: number;
+    retainedUntargetedExecutionCount: number;
+    sourceReferenceDataCount: number;
+    sourceReferenceDataChars: number;
+    retainedReferenceDataCount: number;
+    retainedReferenceDataChars: number;
+    omittedReferenceDataCount: number;
+    omittedReferenceDataChars: number;
+}>;
+/**
+ * Reduces settled execution history to the current effect for each known
+ * logical target. It retains the latest execution, latest state-changing
+ * transition, latest successful mutation, all still-current successful
+ * observations, and each pinned transition's successful precondition
+ * observations. This keeps a bounded transition chain without guessing which
+ * same-target observation is authoritative or reusing stale observations.
+ * Untargeted executions are retained because no sound supersession identity is
+ * available for them.
+ */
+export declare function projectReviewerFinalEvidence(candidates: readonly ReviewerEvidenceCandidate[], referenceDataBudget: ReviewerReferenceDataBudget): ReviewerFinalEvidenceProjection;
+export declare function estimateReferenceDataTokens(referenceData: string, tokenEstimation?: ModelTokenEstimationConfig): number;

package/dist/src/runtime/steps/reviewer-decision/final-evidence.js

@@ -0,0 +1,309 @@
+import { estimateTextTokens } from "../../context/token-estimator.js";
+import { REVIEWER_EVIDENCE_REFERENCE_DATA_MAX_LENGTH, REVIEWER_ITEM_SUMMARY_MAX_LENGTH, REVIEWER_MAX_EVIDENCE, } from "./contracts.js";
+const REVIEWER_SUMMARY_CONTINUATION_KIND = "runtime_reviewer_evidence_summary_continuation_v1";
+/**
+ * Reduces settled execution history to the current effect for each known
+ * logical target. It retains the latest execution, latest state-changing
+ * transition, latest successful mutation, all still-current successful
+ * observations, and each pinned transition's successful precondition
+ * observations. This keeps a bounded transition chain without guessing which
+ * same-target observation is authoritative or reusing stale observations.
+ * Untargeted executions are retained because no sound supersession identity is
+ * available for them.
+ */
+export function projectReviewerFinalEvidence(candidates, referenceDataBudget) {
+    const latestIndexByTarget = new Map();
+    const latestStateChangingIndexByTarget = new Map();
+    const latestSuccessfulMutationIndexByTarget = new Map();
+    const successfulObservationIndexesByTarget = new Map();
+    const stateChangingWitnessIndexesByTarget = new Map();
+    const successfulMutationWitnessIndexesByTarget = new Map();
+    for (let index = 0; index < candidates.length; index += 1) {
+        const candidate = candidates[index];
+        const targets = new Set((candidate.references ?? []).map(({ target }) => target));
+        for (const target of targets) {
+            latestIndexByTarget.set(target, index);
+            if (candidate.observedEffect === "mutation" ||
+                candidate.observedEffect === "indeterminate") {
+                const witnessIndexes = successfulObservationIndexesByTarget.get(target);
+                latestStateChangingIndexByTarget.set(target, index);
+                if (witnessIndexes && witnessIndexes.length > 0) {
+                    stateChangingWitnessIndexesByTarget.set(target, [...witnessIndexes]);
+                }
+                else {
+                    stateChangingWitnessIndexesByTarget.delete(target);
+                }
+                if (candidate.outcome === "succeeded" &&
+                    candidate.observedEffect === "mutation") {
+                    latestSuccessfulMutationIndexByTarget.set(target, index);
+                    if (witnessIndexes && witnessIndexes.length > 0) {
+                        successfulMutationWitnessIndexesByTarget.set(target, [
+                            ...witnessIndexes,
+                        ]);
+                    }
+                    else {
+                        successfulMutationWitnessIndexesByTarget.delete(target);
+                    }
+                }
+                successfulObservationIndexesByTarget.delete(target);
+            }
+            else if (candidate.outcome === "succeeded" &&
+                candidate.observedEffect === "observation") {
+                const observationIndexes = successfulObservationIndexesByTarget.get(target);
+                if (observationIndexes) {
+                    observationIndexes.push(index);
+                }
+                else {
+                    successfulObservationIndexesByTarget.set(target, [index]);
+                }
+            }
+        }
+    }
+    const coreIndexSet = new Set([
+        ...latestIndexByTarget.values(),
+        ...latestStateChangingIndexByTarget.values(),
+        ...latestSuccessfulMutationIndexByTarget.values(),
+        ...[...successfulObservationIndexesByTarget.values()].flat(),
+    ]);
+    const preconditionWitnessIndexes = new Set([
+        ...stateChangingWitnessIndexesByTarget.values(),
+        ...successfulMutationWitnessIndexesByTarget.values(),
+    ].flat());
+    const evidence = [];
+    let projectionComplete = true;
+    let supersededExecutionCount = 0;
+    let retainedFailedExecutionCount = 0;
+    let retainedUntargetedExecutionCount = 0;
+    let sourceReferenceDataCount = 0;
+    let sourceReferenceDataChars = 0;
+    let retainedReferenceDataCount = 0;
+    let retainedReferenceDataChars = 0;
+    let omittedReferenceDataCount = 0;
+    let omittedReferenceDataChars = 0;
+    const currentIndexes = [];
+    const retainedWitnessIndexes = [];
+    const sourceReferenceDataByIndex = new Map();
+    for (let index = 0; index < candidates.length; index += 1) {
+        const sourceReferenceData = projectEvidenceSourceReferenceData(candidates[index]);
+        if (!sourceReferenceData)
+            continue;
+        sourceReferenceDataByIndex.set(index, sourceReferenceData);
+        sourceReferenceDataCount += 1;
+        sourceReferenceDataChars += sourceReferenceData.length;
+    }
+    for (let index = 0; index < candidates.length; index += 1) {
+        const candidate = candidates[index];
+        const targets = (candidate.references ?? []).map(({ target }) => target);
+        const isCore = targets.length === 0 || coreIndexSet.has(index);
+        const isWitness = !isCore && preconditionWitnessIndexes.has(index);
+        if (!isCore && !isWitness) {
+            supersededExecutionCount += 1;
+            continue;
+        }
+        if (candidate.outcome === "failed")
+            retainedFailedExecutionCount += 1;
+        if (targets.length === 0)
+            retainedUntargetedExecutionCount += 1;
+        if (isWitness) {
+            retainedWitnessIndexes.push(index);
+        }
+        else {
+            currentIndexes.push(index);
+        }
+    }
+    const retainedIndexes = [...currentIndexes, ...retainedWitnessIndexes].sort((left, right) => left - right);
+    const projectedCurrentIndexes = currentIndexes.slice(-REVIEWER_MAX_EVIDENCE);
+    const remainingWitnessSlots = Math.max(0, REVIEWER_MAX_EVIDENCE - projectedCurrentIndexes.length);
+    const projectedWitnessIndexes = remainingWitnessSlots > 0
+        ? retainedWitnessIndexes.slice(-remainingWitnessSlots)
+        : [];
+    const projectedIndexes = [
+        ...projectedCurrentIndexes,
+        ...projectedWitnessIndexes,
+    ].sort((left, right) => left - right);
+    const projectedIndexSet = new Set(projectedIndexes);
+    if (projectedIndexes.length !== retainedIndexes.length) {
+        projectionComplete = false;
+    }
+    const projectedReferenceData = allocateReferenceDataFairly(projectedIndexes.flatMap((index) => {
+        const referenceData = sourceReferenceDataByIndex.get(index);
+        return referenceData ? [{ index, referenceData }] : [];
+    }), referenceDataBudget);
+    for (const index of retainedIndexes) {
+        const sourceReferenceData = sourceReferenceDataByIndex.get(index);
+        if (!projectedIndexSet.has(index) && sourceReferenceData) {
+            omittedReferenceDataCount += 1;
+            omittedReferenceDataChars += sourceReferenceData.length;
+        }
+    }
+    for (const index of projectedIndexes) {
+        const candidate = candidates[index];
+        const sourceReferenceData = sourceReferenceDataByIndex.get(index);
+        const referenceProjection = projectedReferenceData.get(index);
+        const referenceData = referenceProjection?.value;
+        if (sourceReferenceData) {
+            if (referenceProjection) {
+                retainedReferenceDataCount += 1;
+                retainedReferenceDataChars += referenceProjection.retainedSourceChars;
+                if (referenceProjection.omittedSourceChars > 0) {
+                    omittedReferenceDataCount += 1;
+                    omittedReferenceDataChars += referenceProjection.omittedSourceChars;
+                    projectionComplete = false;
+                }
+            }
+            else {
+                omittedReferenceDataCount += 1;
+                omittedReferenceDataChars += sourceReferenceData.length;
+                projectionComplete = false;
+            }
+        }
+        evidence.push(Object.freeze({
+            evidenceRef: candidate.executionId,
+            kind: "capability_execution",
+            outcome: candidate.outcome,
+            effect: candidate.observedEffect,
+            subjectRefs: Object.freeze([candidate.subjectRef]),
+            summary: boundedSummary(candidate.summary),
+            ...(candidate.references
+                ? { references: Object.freeze([...candidate.references]) }
+                : {}),
+            ...(referenceData ? { referenceData } : {}),
+        }));
+    }
+    return Object.freeze({
+        evidence: Object.freeze(evidence),
+        projectionComplete,
+        sourceExecutionCount: candidates.length,
+        supersededExecutionCount,
+        retainedFailedExecutionCount,
+        retainedUntargetedExecutionCount,
+        sourceReferenceDataCount,
+        sourceReferenceDataChars,
+        retainedReferenceDataCount,
+        retainedReferenceDataChars,
+        omittedReferenceDataCount,
+        omittedReferenceDataChars,
+    });
+}
+function projectEvidenceSourceReferenceData(candidate) {
+    const summaryProjection = projectBoundedSummary(candidate.summary);
+    const normalizedSummary = summaryProjection.normalized;
+    if (normalizedSummary.length <= REVIEWER_ITEM_SUMMARY_MAX_LENGTH) {
+        return candidate.referenceData;
+    }
+    return JSON.stringify({
+        kind: REVIEWER_SUMMARY_CONTINUATION_KIND,
+        evidenceRef: candidate.executionId,
+        summary: {
+            sourceCharacters: normalizedSummary.length,
+            retainedCharacters: summaryProjection.retained.length,
+            continuation: summaryProjection.continuation,
+        },
+        ...(candidate.referenceData
+            ? { originalReferenceData: candidate.referenceData }
+            : {}),
+    });
+}
+function allocateReferenceDataFairly(sources, budget) {
+    const allocations = new Map();
+    let remainingTokens = Math.max(0, Math.floor(budget.maxTokens));
+    let pending = [...sources];
+    while (pending.length > 0 && remainingTokens > 0) {
+        const equalShare = Math.floor(remainingTokens / pending.length);
+        if (equalShare <= 0)
+            break;
+        const fullyFitting = pending.filter(({ referenceData }) => estimateReferenceDataTokens(referenceData, budget.tokenEstimation) <=
+            equalShare);
+        if (fullyFitting.length > 0) {
+            const fittingIndexes = new Set(fullyFitting.map(({ index }) => index));
+            for (const source of fullyFitting) {
+                const cost = estimateReferenceDataTokens(source.referenceData, budget.tokenEstimation);
+                allocations.set(source.index, {
+                    value: source.referenceData,
+                    retainedSourceChars: source.referenceData.length,
+                    omittedSourceChars: 0,
+                });
+                remainingTokens -= cost;
+            }
+            pending = pending.filter(({ index }) => !fittingIndexes.has(index));
+            continue;
+        }
+        const remainder = remainingTokens % pending.length;
+        for (let index = 0; index < pending.length; index += 1) {
+            const source = pending[index];
+            const tokenShare = equalShare + (index < remainder ? 1 : 0);
+            const projection = projectReferenceDataWithinBudget(source.referenceData, tokenShare, budget.tokenEstimation);
+            if (projection)
+                allocations.set(source.index, projection);
+        }
+        break;
+    }
+    return allocations;
+}
+function projectReferenceDataWithinBudget(source, maxTokens, tokenEstimation) {
+    if (source.length <= REVIEWER_EVIDENCE_REFERENCE_DATA_MAX_LENGTH &&
+        estimateReferenceDataTokens(source, tokenEstimation) <= maxTokens) {
+        return {
+            value: source,
+            retainedSourceChars: source.length,
+            omittedSourceChars: 0,
+        };
+    }
+    let low = 0;
+    let high = Math.min(source.length, REVIEWER_EVIDENCE_REFERENCE_DATA_MAX_LENGTH);
+    let best;
+    while (low <= high) {
+        const retainedSourceChars = Math.floor((low + high) / 2);
+        const value = createTruncatedReferenceData(source, retainedSourceChars);
+        const fits = value.length <= REVIEWER_EVIDENCE_REFERENCE_DATA_MAX_LENGTH &&
+            estimateReferenceDataTokens(value, tokenEstimation) <= maxTokens;
+        if (fits) {
+            best = {
+                value,
+                retainedSourceChars,
+                omittedSourceChars: source.length - retainedSourceChars,
+            };
+            low = retainedSourceChars + 1;
+        }
+        else {
+            high = retainedSourceChars - 1;
+        }
+    }
+    return best;
+}
+function createTruncatedReferenceData(source, retainedSourceChars) {
+    const omittedSourceChars = source.length - retainedSourceChars;
+    const marker = `[runtime projection omitted ${omittedSourceChars} of ${source.length} source characters]`;
+    if (retainedSourceChars === 0)
+        return marker;
+    const headLength = Math.ceil(retainedSourceChars / 2);
+    const tailLength = retainedSourceChars - headLength;
+    return `${source.slice(0, headLength)}\n${marker}\n${tailLength > 0 ? source.slice(-tailLength) : ""}`;
+}
+export function estimateReferenceDataTokens(referenceData, tokenEstimation) {
+    return estimateTextTokens(JSON.stringify({ referenceData }), tokenEstimation);
+}
+function boundedSummary(value) {
+    return projectBoundedSummary(value).retained;
+}
+function projectBoundedSummary(value) {
+    const normalized = value.trim();
+    let boundary = Math.min(normalized.length, REVIEWER_ITEM_SUMMARY_MAX_LENGTH);
+    if (boundary > 0 &&
+        boundary < normalized.length &&
+        isHighSurrogate(normalized.charCodeAt(boundary - 1)) &&
+        isLowSurrogate(normalized.charCodeAt(boundary))) {
+        boundary -= 1;
+    }
+    return Object.freeze({
+        normalized,
+        retained: normalized.slice(0, boundary),
+        continuation: normalized.slice(boundary),
+    });
+}
+function isHighSurrogate(value) {
+    return value >= 0xd800 && value <= 0xdbff;
+}
+function isLowSurrogate(value) {
+    return value >= 0xdc00 && value <= 0xdfff;
+}

package/dist/src/runtime/steps/reviewer-decision/format.d.ts

@@ -0,0 +1,3 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import { type ReviewerReviewSnapshot } from "./contracts.js";
+export declare function createReviewerDecisionFormat(snapshot: ReviewerReviewSnapshot): ModelGatewayJsonSchemaFormat;