@abot-ai/runtime 1.1.0 → 1.2.0

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

@@ -0,0 +1,10 @@
+import { type ReviewerDecisionValidationIssue, type ReviewerReviewSnapshot } from "./contracts.js";
+export declare const REVIEWER_AUDIT_FINDING_MAX_LENGTH = 512;
+export type ReviewerAuditCoverage = Readonly<{
+    requiresGapVerdict: boolean;
+    completionEvidenceRefCount: number;
+}>;
+export declare function createReviewerAuditCoverageSchema(snapshot: ReviewerReviewSnapshot, options: Readonly<{
+    minimumCompletionEvidenceRefs: number;
+}>): Record<string, unknown>;
+export declare function parseReviewerAuditCoverage(value: unknown, snapshot: ReviewerReviewSnapshot, issues: ReviewerDecisionValidationIssue[]): ReviewerAuditCoverage | undefined;

package/dist/src/runtime/steps/reviewer-decision/audit-coverage.js

@@ -0,0 +1,186 @@
+import { REVIEWER_MAX_EVIDENCE, } from "./contracts.js";
+export const REVIEWER_AUDIT_FINDING_MAX_LENGTH = 512;
+const EVIDENCE_ASSESSMENT_STATUSES = Object.freeze([
+    "supports",
+    "does_not_establish",
+    "contradicts",
+]);
+const COMPLETION_ASSESSMENT_STATUSES = Object.freeze([
+    "satisfied",
+    "gap",
+    "indeterminate",
+]);
+export function createReviewerAuditCoverageSchema(snapshot, options) {
+    const evidenceRefs = snapshot.evidence.map(({ evidenceRef }) => evidenceRef);
+    return exactObject({
+        evidenceAssessments: {
+            type: "array",
+            minItems: evidenceRefs.length,
+            maxItems: evidenceRefs.length,
+            items: exactObject({
+                evidenceRef: enumString(evidenceRefs),
+                status: enumString(EVIDENCE_ASSESSMENT_STATUSES),
+                finding: boundedText(REVIEWER_AUDIT_FINDING_MAX_LENGTH),
+            }),
+        },
+        completionAssessment: exactObject({
+            status: enumString(COMPLETION_ASSESSMENT_STATUSES),
+            evidenceRefs: {
+                type: "array",
+                minItems: options.minimumCompletionEvidenceRefs,
+                maxItems: evidenceRefs.length,
+                items: enumString(evidenceRefs),
+            },
+            finding: boundedText(REVIEWER_AUDIT_FINDING_MAX_LENGTH),
+        }),
+    });
+}
+export function parseReviewerAuditCoverage(value, snapshot, issues) {
+    const record = asRecord(value);
+    if (!record) {
+        issues.push(issue("reviewer_audit_invalid", "decision.audit"));
+        return undefined;
+    }
+    exactKeys(record, ["evidenceAssessments", "completionAssessment"], "decision.audit", issues);
+    const evidenceAssessment = parseEvidenceAssessments(record.evidenceAssessments, snapshot, issues);
+    const completionAssessment = parseCompletionAssessment(record.completionAssessment, snapshot, issues);
+    if (!evidenceAssessment || !completionAssessment)
+        return undefined;
+    return Object.freeze({
+        requiresGapVerdict: evidenceAssessment.hasContradiction ||
+            completionAssessment.status !== "satisfied",
+        completionEvidenceRefCount: completionAssessment.evidenceRefCount,
+    });
+}
+function parseEvidenceAssessments(value, snapshot, issues) {
+    if (!Array.isArray(value) ||
+        value.length !== snapshot.evidence.length ||
+        value.length > REVIEWER_MAX_EVIDENCE) {
+        issues.push(issue("reviewer_evidence_assessment_coverage_invalid", "decision.audit.evidenceAssessments"));
+        return undefined;
+    }
+    const allowedRefs = new Set(snapshot.evidence.map(({ evidenceRef }) => evidenceRef));
+    const assessedRefs = new Set();
+    let hasContradiction = false;
+    value.forEach((entry, index) => {
+        const path = `decision.audit.evidenceAssessments[${index}]`;
+        const assessment = asRecord(entry);
+        if (!assessment) {
+            issues.push(issue("reviewer_evidence_assessment_invalid", path));
+            return;
+        }
+        exactKeys(assessment, ["evidenceRef", "status", "finding"], path, issues);
+        const evidenceRef = assessment.evidenceRef;
+        if (typeof evidenceRef !== "string" || !allowedRefs.has(evidenceRef)) {
+            issues.push(issue("reviewer_evidence_assessment_ref_unknown", `${path}.evidenceRef`));
+        }
+        else if (assessedRefs.has(evidenceRef)) {
+            issues.push(issue("reviewer_evidence_assessment_ref_duplicate", `${path}.evidenceRef`));
+        }
+        else {
+            assessedRefs.add(evidenceRef);
+        }
+        const status = assessment.status;
+        if (!isEvidenceAssessmentStatus(status)) {
+            issues.push(issue("reviewer_evidence_assessment_status_invalid", `${path}.status`));
+        }
+        else if (status === "contradicts") {
+            hasContradiction = true;
+        }
+        parseFinding(assessment.finding, `${path}.finding`, issues);
+    });
+    if (assessedRefs.size !== allowedRefs.size) {
+        issues.push(issue("reviewer_evidence_assessment_coverage_invalid", "decision.audit.evidenceAssessments"));
+    }
+    return Object.freeze({ hasContradiction });
+}
+function parseCompletionAssessment(value, snapshot, issues) {
+    const record = asRecord(value);
+    if (!record) {
+        issues.push(issue("reviewer_completion_assessment_invalid", "decision.audit.completionAssessment"));
+        return undefined;
+    }
+    exactKeys(record, ["status", "evidenceRefs", "finding"], "decision.audit.completionAssessment", issues);
+    const status = record.status;
+    if (!isCompletionAssessmentStatus(status)) {
+        issues.push(issue("reviewer_completion_assessment_status_invalid", "decision.audit.completionAssessment.status"));
+    }
+    const evidenceRefCount = parseEvidenceRefs(record.evidenceRefs, snapshot, "decision.audit.completionAssessment.evidenceRefs", issues);
+    parseFinding(record.finding, "decision.audit.completionAssessment.finding", issues);
+    return isCompletionAssessmentStatus(status)
+        ? Object.freeze({ status, evidenceRefCount })
+        : undefined;
+}
+function parseEvidenceRefs(value, snapshot, path, issues) {
+    if (!Array.isArray(value) || value.length > snapshot.evidence.length) {
+        issues.push(issue("reviewer_audit_evidence_refs_invalid", path));
+        return 0;
+    }
+    const allowed = new Set(snapshot.evidence.map(({ evidenceRef }) => evidenceRef));
+    const seen = new Set();
+    value.forEach((entry, index) => {
+        if (typeof entry !== "string" || !allowed.has(entry)) {
+            issues.push(issue("reviewer_audit_evidence_ref_unknown", `${path}[${index}]`));
+        }
+        else if (seen.has(entry)) {
+            issues.push(issue("reviewer_audit_evidence_ref_duplicate", `${path}[${index}]`));
+        }
+        else {
+            seen.add(entry);
+        }
+    });
+    return seen.size;
+}
+function parseFinding(value, path, issues) {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    if (normalized.length === 0 ||
+        /[\u0000-\u001F\u007F\uD800-\uDFFF]/u.test(normalized)) {
+        issues.push(issue("reviewer_audit_finding_invalid", path));
+    }
+}
+function isEvidenceAssessmentStatus(value) {
+    return (typeof value === "string" &&
+        EVIDENCE_ASSESSMENT_STATUSES.includes(value));
+}
+function isCompletionAssessmentStatus(value) {
+    return (typeof value === "string" &&
+        COMPLETION_ASSESSMENT_STATUSES.includes(value));
+}
+function exactObject(properties) {
+    return {
+        type: "object",
+        properties,
+        required: Object.keys(properties),
+        additionalProperties: false,
+    };
+}
+function boundedText(maxLength) {
+    return { type: "string", minLength: 1, maxLength };
+}
+function enumString(values) {
+    const uniqueValues = [...new Set(values)];
+    return {
+        type: "string",
+        enum: uniqueValues.length > 0 ? uniqueValues : ["__none__"],
+    };
+}
+function exactKeys(record, keys, path, issues) {
+    const expected = new Set(keys);
+    const actual = Object.keys(record);
+    if (actual.length !== expected.size ||
+        actual.some((key) => !expected.has(key))) {
+        issues.push(issue("reviewer_audit_shape_invalid", path));
+    }
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function issue(code, path) {
+    return {
+        code,
+        path,
+        message: `Reviewer audit failed ${code}.`,
+    };
+}

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

@@ -1,4 +1,4 @@
-import { type RoleCapabilityResultReference, type RoleCallFrame } from "../../orchestration/role-calls/index.js";
+import { type RoleCapabilityResultReference, type RoleCallFrame, type RoleCallReviewerVerdictGap } from "../../orchestration/role-calls/index.js";
 export declare const REVIEWER_DECISION_MODEL_STEP: "reviewer.decision";
 export declare const REVIEWER_ROLE_ID: "reviewer";
 export declare const REVIEWER_DECISION_ACTIONS: readonly ["pass", "report_gaps"];
@@ -17,6 +17,7 @@ export declare const REVIEWER_EVIDENCE_REFERENCE_DATA_MAX_LENGTH = 32768;
 export declare const REVIEWER_DECISION_SUMMARY_MAX_LENGTH = 256;
 export declare const REVIEWER_GAP_SUMMARY_MAX_LENGTH = 224;
 export declare const REVIEWER_DECISION_RESULT_MAX_LENGTH = 8192;
+export declare function resolveCanonicalReviewerCompletionTargetText(source: string): string;
 export type ReviewerFactStatus = "satisfied" | "missing" | "mismatched" | "contradictory" | "indeterminate" | "informational";
 export type ReviewerEvidenceOutcome = "succeeded" | "failed";
 export type ReviewerEvidenceEffect = "none" | "observation" | "mutation" | "indeterminate";
@@ -56,13 +57,7 @@ export type ReviewerReviewSnapshot = Readonly<{
     facts: readonly ReviewerFact[];
     evidence: readonly ReviewerEvidence[];
 }>;
-export type ReviewerGap = Readonly<{
-    kind: string;
-    subjectRefs: readonly string[];
-    factRefs: readonly string[];
-    evidenceRefs: readonly string[];
-    summary: string;
-}>;
+export type ReviewerGap = RoleCallReviewerVerdictGap;
 export type ReviewerPassDecision = Readonly<{
     action: "pass";
     reviewScopeId: string;

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

@@ -1,5 +1,5 @@
 import { MODEL_STEPS } from "../../../shared/model-steps.js";
-import { ROLE_CALL_OBJECTIVE_MAX_LENGTH, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+import { ROLE_CALL_OBJECTIVE_MAX_LENGTH, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, ROLE_CALL_REVIEWER_VERDICT_GAP_SUMMARY_MAX_LENGTH, ROLE_CALL_REVIEWER_VERDICT_KIND_MAX_LENGTH, ROLE_CALL_REVIEWER_VERDICT_MAX_GAPS, ROLE_CALL_REVIEWER_VERDICT_MAX_REFS_PER_GAP, ROLE_CALL_REVIEWER_VERDICT_REFERENCE_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
 export const REVIEWER_DECISION_MODEL_STEP = MODEL_STEPS.REVIEWER_DECISION;
 export const REVIEWER_ROLE_ID = "reviewer";
 export const REVIEWER_DECISION_ACTIONS = Object.freeze([
@@ -9,18 +9,24 @@ export const REVIEWER_DECISION_ACTIONS = Object.freeze([
 export const REVIEWER_MAX_SUBJECTS = 64;
 export const REVIEWER_MAX_FACTS = 64;
 export const REVIEWER_MAX_EVIDENCE = 64;
-export const REVIEWER_MAX_GAPS = 5;
+export const REVIEWER_MAX_GAPS = ROLE_CALL_REVIEWER_VERDICT_MAX_GAPS;
 export const REVIEWER_MAX_GAP_KINDS = 64;
-export const REVIEWER_MAX_REFS_PER_GAP = 1;
+export const REVIEWER_MAX_REFS_PER_GAP = ROLE_CALL_REVIEWER_VERDICT_MAX_REFS_PER_GAP;
 export const REVIEWER_MAX_SNAPSHOT_LINK_REFS = 64;
-export const REVIEWER_REFERENCE_MAX_LENGTH = 256;
-export const REVIEWER_KIND_MAX_LENGTH = 160;
+export const REVIEWER_REFERENCE_MAX_LENGTH = ROLE_CALL_REVIEWER_VERDICT_REFERENCE_MAX_LENGTH;
+export const REVIEWER_KIND_MAX_LENGTH = ROLE_CALL_REVIEWER_VERDICT_KIND_MAX_LENGTH;
 export const REVIEWER_ITEM_SUMMARY_MAX_LENGTH = 2_048;
 export const REVIEWER_COMPLETION_TARGET_MAX_LENGTH = ROLE_CALL_OBJECTIVE_MAX_LENGTH;
 export const REVIEWER_EVIDENCE_REFERENCE_DATA_MAX_LENGTH = ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH;
 export const REVIEWER_DECISION_SUMMARY_MAX_LENGTH = 256;
-export const REVIEWER_GAP_SUMMARY_MAX_LENGTH = 224;
+export const REVIEWER_GAP_SUMMARY_MAX_LENGTH = ROLE_CALL_REVIEWER_VERDICT_GAP_SUMMARY_MAX_LENGTH;
 export const REVIEWER_DECISION_RESULT_MAX_LENGTH = ROLE_CALL_RESULT_MAX_LENGTH;
+export function resolveCanonicalReviewerCompletionTargetText(source) {
+    const normalized = source.trim();
+    if (!normalized)
+        throw new Error("reviewer_completion_target_missing");
+    return normalized.slice(0, REVIEWER_COMPLETION_TARGET_MAX_LENGTH);
+}
 export function projectReviewerDecisionCallIdentity(call) {
     if (call.roleId !== REVIEWER_ROLE_ID ||
         call.parentCallId === null ||

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

@@ -0,0 +1,24 @@
+import { type RoleCallFrame, type RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type ReviewerFact, type ReviewerSubject } from "./contracts.js";
+export type ReviewerDelegatedContextProjection = Readonly<{
+    subjects: readonly ReviewerSubject[];
+    facts: readonly ReviewerFact[];
+    subjectBindings: readonly Readonly<{
+        callId: string;
+        subjectRef: string;
+    }>[];
+    scopedTopLevelCallIds: readonly string[];
+    excludedReviewerCallIds: readonly string[];
+    projectionComplete: boolean;
+}>;
+/**
+ * Projects only the exact canonical dependency results attached to the active
+ * Reviewer call. The projection describes prior work without granting it
+ * user-intent, routing, verdict, or completion authority.
+ */
+export declare function projectReviewerDelegatedContext(params: Readonly<{
+    head: RoleCallLedgerHead;
+    reviewer: RoleCallFrame;
+    subjectCapacity: number;
+    factCapacity: number;
+}>): ReviewerDelegatedContextProjection;

package/dist/src/runtime/steps/reviewer-decision/delegated-context.js

@@ -0,0 +1,70 @@
+import { projectRoleCallDependencyResults, } from "../../orchestration/role-calls/index.js";
+import { REVIEWER_ITEM_SUMMARY_MAX_LENGTH, } from "./contracts.js";
+/**
+ * Projects only the exact canonical dependency results attached to the active
+ * Reviewer call. The projection describes prior work without granting it
+ * user-intent, routing, verdict, or completion authority.
+ */
+export function projectReviewerDelegatedContext(params) {
+    const dependencies = projectRoleCallDependencyResults(params.head, params.reviewer);
+    const subjects = [];
+    const facts = [];
+    const subjectBindings = [];
+    const scopedTopLevelCallIds = [];
+    const excludedReviewerCallIds = [];
+    let projectionComplete = true;
+    for (const dependency of dependencies) {
+        const producer = params.head.state.calls.find(({ callId }) => callId === dependency.producerCallId);
+        if (!producer)
+            throw new Error("reviewer_dependency_producer_missing");
+        scopedTopLevelCallIds.push(producer.callId);
+        if (producer.roleId === "reviewer") {
+            excludedReviewerCallIds.push(producer.callId);
+        }
+        const subjectRef = `call:${producer.callId}`;
+        const objective = producer.objective ?? `${producer.roleId} work`;
+        projectionComplete =
+            !isSummaryTruncated(objective) && projectionComplete;
+        if (subjects.length >= params.subjectCapacity) {
+            projectionComplete = false;
+            continue;
+        }
+        subjects.push({
+            subjectRef,
+            kind: `${producer.roleId}_result`,
+            summary: boundedSummary(objective),
+        });
+        subjectBindings.push({ callId: producer.callId, subjectRef });
+        projectionComplete =
+            !isSummaryTruncated(dependency.summary) && projectionComplete;
+        if (facts.length >= params.factCapacity) {
+            projectionComplete = false;
+            continue;
+        }
+        facts.push({
+            factRef: dependency.resultRef,
+            kind: "role_result",
+            status: dependency.outcome === "completed" ? "informational" : "missing",
+            subjectRefs: Object.freeze([subjectRef]),
+            evidenceRefs: Object.freeze([]),
+            summary: boundedSummary(dependency.summary),
+        });
+    }
+    return Object.freeze({
+        subjects: Object.freeze(subjects),
+        facts: Object.freeze(facts),
+        subjectBindings: Object.freeze(subjectBindings),
+        scopedTopLevelCallIds: Object.freeze(scopedTopLevelCallIds),
+        excludedReviewerCallIds: Object.freeze(excludedReviewerCallIds),
+        projectionComplete,
+    });
+}
+function boundedSummary(value) {
+    const normalized = value.trim();
+    return normalized.length <= REVIEWER_ITEM_SUMMARY_MAX_LENGTH
+        ? normalized
+        : normalized.slice(0, REVIEWER_ITEM_SUMMARY_MAX_LENGTH);
+}
+function isSummaryTruncated(value) {
+    return value.trim().length > REVIEWER_ITEM_SUMMARY_MAX_LENGTH;
+}

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

@@ -13,7 +13,7 @@ export function traceReviewerContextProjected(params) {
         historyMessageCount: 0,
         attachmentCount: 0,
         referenceMessageCount: params.referenceMessageCount,
-        modelContextContract: "runtime_reviewer_audit_v2",
+        modelContextContract: "runtime_reviewer_audit_v4",
         auditCapsuleCharacterCount: params.auditCapsuleCharacterCount,
         evidenceAppendixCharacterCount: params.evidenceAppendixCharacterCount,
         continuationMessageCount: 0,

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

@@ -1,10 +1,18 @@
-import { createStructuredDecisionEnvelopeSchema, structuredDecisionVariantSchemaPath, } from "../../model/structured-decision-envelope.js";
+import { createStructuredDecisionEnvelopeSchema, } from "../../model/structured-decision-envelope.js";
+import { createReviewerAuditCoverageSchema } from "./audit-coverage.js";
+import { projectReviewerVerificationCoverage } from "./verification-coverage.js";
 import { REVIEWER_DECISION_SUMMARY_MAX_LENGTH, REVIEWER_GAP_SUMMARY_MAX_LENGTH, REVIEWER_MAX_GAPS, REVIEWER_MAX_REFS_PER_GAP, } from "./contracts.js";
 export function createReviewerDecisionFormat(snapshot) {
-    const passAllowed = snapshot.projectionComplete && snapshot.freshness !== "unavailable";
+    const verificationCoverage = projectReviewerVerificationCoverage(snapshot);
+    const passAllowed = snapshot.projectionComplete &&
+        snapshot.freshness !== "unavailable" &&
+        verificationCoverage.complete;
     const passVariant = exactObject({
         action: literal("pass"),
         reviewScopeId: literal(snapshot.reviewScopeId),
+        audit: createReviewerAuditCoverageSchema(snapshot, {
+            minimumCompletionEvidenceRefs: Math.min(2, snapshot.evidence.length),
+        }),
         summary: boundedText(REVIEWER_DECISION_SUMMARY_MAX_LENGTH),
         gaps: {
             type: "array",
@@ -15,10 +23,13 @@ export function createReviewerDecisionFormat(snapshot) {
                 enum: ["__none__"],
             },
         },
-    }, ["action", "reviewScopeId", "summary", "gaps"]);
+    }, ["action", "reviewScopeId", "audit", "summary", "gaps"]);
     const reportGapsVariant = exactObject({
         action: literal("report_gaps"),
         reviewScopeId: literal(snapshot.reviewScopeId),
+        audit: createReviewerAuditCoverageSchema(snapshot, {
+            minimumCompletionEvidenceRefs: 0,
+        }),
         summary: boundedText(REVIEWER_DECISION_SUMMARY_MAX_LENGTH),
         gaps: {
             type: "array",
@@ -32,34 +43,17 @@ export function createReviewerDecisionFormat(snapshot) {
                 summary: boundedText(REVIEWER_GAP_SUMMARY_MAX_LENGTH),
             }, ["kind", "subjectRefs", "factRefs", "evidenceRefs", "summary"]),
         },
-    }, ["action", "reviewScopeId", "summary", "gaps"]);
+    }, ["action", "reviewScopeId", "audit", "summary", "gaps"]);
     const variants = passAllowed
         ? [passVariant, reportGapsVariant]
         : [reportGapsVariant];
-    const reportGapsIndex = passAllowed ? 1 : 0;
+    const schema = createStructuredDecisionEnvelopeSchema(variants);
     return {
         type: "json_schema",
         name: "reviewer_decision",
         strict: true,
-        postValidatedSchemaConstraints: [
-            ...(passAllowed
-                ? [
-                    {
-                        keyword: "maxLength",
-                        path: `${structuredDecisionVariantSchemaPath(0, variants.length)}/properties/summary/maxLength`,
-                    },
-                ]
-                : []),
-            {
-                keyword: "maxLength",
-                path: `${structuredDecisionVariantSchemaPath(reportGapsIndex, variants.length)}/properties/summary/maxLength`,
-            },
-            {
-                keyword: "maxLength",
-                path: `${structuredDecisionVariantSchemaPath(reportGapsIndex, variants.length)}/properties/gaps/items/properties/summary/maxLength`,
-            },
-        ],
-        schema: createStructuredDecisionEnvelopeSchema(variants),
+        postValidatedSchemaConstraints: collectMaxLengths(schema),
+        schema,
     };
 }
 function referenceArray(values) {
@@ -95,3 +89,22 @@ function boundedText(maxLength) {
         maxLength,
     };
 }
+function collectMaxLengths(value, path = "") {
+    if (Array.isArray(value)) {
+        return value.flatMap((entry, index) => collectMaxLengths(entry, `${path}/${index}`));
+    }
+    if (!isRecord(value))
+        return [];
+    return [
+        ...(Object.hasOwn(value, "maxLength")
+            ? [{ keyword: "maxLength", path: `${path}/maxLength` }]
+            : []),
+        ...Object.entries(value).flatMap(([key, child]) => collectMaxLengths(child, `${path}/${escapePointer(key)}`)),
+    ];
+}
+function escapePointer(value) {
+    return value.replace(/~/gu, "~0").replace(/\//gu, "~1");
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -97,7 +97,7 @@ export function assessReviewerDecisionInputBudget(request, options) {
 }
 function createReviewerDecisionInputParts(request, options) {
     const format = createReviewerDecisionFormat(options.snapshot);
-    const modelContext = projectReviewerModelContext(options.snapshot);
+    const modelContext = projectReviewerModelContext(options.snapshot, options.call);
     const configuredInstructionMetadata = resolveConfiguredStepInstructionMetadata({
         runnerConfig: request.runnerConfig,
         modelStep: REVIEWER_DECISION_MODEL_STEP,

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

@@ -1,6 +1,7 @@
 import type { ChatMessage } from "../../../model-gateway/types.js";
-import type { ReviewerReviewSnapshot } from "./contracts.js";
-export declare const REVIEWER_AUDIT_CONTEXT_KIND: "runtime_reviewer_audit_v2";
+import type { RoleCallFrame } from "../../orchestration/role-calls/index.js";
+import { type ReviewerReviewSnapshot } from "./contracts.js";
+export declare const REVIEWER_AUDIT_CONTEXT_KIND: "runtime_reviewer_audit_v4";
 export declare const REVIEWER_EVIDENCE_APPENDIX_KIND: "runtime_reviewer_evidence_v1";
 export type ReviewerModelContextProjection = Readonly<{
     referenceMessages: readonly ChatMessage[];
@@ -14,4 +15,4 @@ export type ReviewerModelContextProjection = Readonly<{
  * Large evidence bodies are pinned before the final compact audit capsule so
  * they remain available without displacing the completion target from recency.
  */
-export declare function projectReviewerModelContext(snapshot: ReviewerReviewSnapshot): ReviewerModelContextProjection;
+export declare function projectReviewerModelContext(snapshot: ReviewerReviewSnapshot, reviewerCall: RoleCallFrame): ReviewerModelContextProjection;

package/dist/src/runtime/steps/reviewer-decision/model-context.js

@@ -1,4 +1,6 @@
-export const REVIEWER_AUDIT_CONTEXT_KIND = "runtime_reviewer_audit_v2";
+import { projectReviewerDecisionCallIdentity, } from "./contracts.js";
+import { projectReviewerVerificationCoverage } from "./verification-coverage.js";
+export const REVIEWER_AUDIT_CONTEXT_KIND = "runtime_reviewer_audit_v4";
 export const REVIEWER_EVIDENCE_APPENDIX_KIND = "runtime_reviewer_evidence_v1";
 const REVIEWER_CANDIDATE_SUPPORT_RELATION = "candidate_support";
 /**
@@ -6,15 +8,63 @@ const REVIEWER_CANDIDATE_SUPPORT_RELATION = "candidate_support";
  * Large evidence bodies are pinned before the final compact audit capsule so
  * they remain available without displacing the completion target from recency.
  */
-export function projectReviewerModelContext(snapshot) {
+export function projectReviewerModelContext(snapshot, reviewerCall) {
+    const reviewerIdentity = projectReviewerDecisionCallIdentity(reviewerCall);
+    if (reviewerIdentity.callId !== snapshot.reviewerCallId ||
+        reviewerIdentity.parentCallId !== snapshot.callerCallId) {
+        throw new Error("reviewer_assignment_binding_invalid");
+    }
     const completionTargets = snapshot.subjects.filter(({ kind }) => kind === "caller_objective");
     if (completionTargets.length !== 1) {
         throw new Error("reviewer_completion_target_invalid");
     }
     const completionTarget = completionTargets[0];
+    const verificationCoverage = projectReviewerVerificationCoverage(snapshot);
+    const dependencyFactsBySubjectRef = projectDependencyFactsBySubjectRef(snapshot);
+    const dependencySubjects = snapshot.subjects.flatMap((subject) => {
+        const dependencyFact = dependencyFactsBySubjectRef.get(subject.subjectRef);
+        if (!dependencyFact)
+            return [];
+        const producerCallId = subject.subjectRef.startsWith("call:")
+            ? subject.subjectRef.slice("call:".length)
+            : "";
+        const roleId = subject.kind.endsWith("_result")
+            ? subject.kind.slice(0, -"_result".length)
+            : "";
+        if (!producerCallId || !roleId) {
+            throw new Error("reviewer_dependency_subject_invalid");
+        }
+        return [
+            {
+                authority: "canonical_role_call_dependency_result",
+                presenceEffect: "passive_support_not_user_intent_pending_work_completion_or_verdict",
+                subjectRef: subject.subjectRef,
+                resultRef: dependencyFact.factRef,
+                producerCallId,
+                roleId,
+                objective: subject.summary,
+                summary: dependencyFact.summary,
+                outcome: dependencyFact.status === "informational" ? "completed" : "failed",
+            },
+        ];
+    });
+    const supportSubjects = snapshot.subjects.flatMap((subject) => subject.subjectRef === completionTarget.subjectRef ||
+        dependencyFactsBySubjectRef.has(subject.subjectRef)
+        ? []
+        : [
+            {
+                authority: "canonical_review_snapshot",
+                presenceEffect: "passive_support_descriptor_not_user_intent_pending_work_or_completion",
+                subjectRef: subject.subjectRef,
+                kind: subject.kind,
+                summary: subject.summary,
+            },
+        ]);
     const candidateSupportSubjectRefs = new Set([...snapshot.facts, ...snapshot.evidence].flatMap(({ subjectRefs }) => subjectRefs));
+    const passiveReviewerDependencySubjectRefs = new Set(dependencySubjects.flatMap(({ roleId, subjectRef }) => roleId === "reviewer" ? [subjectRef] : []));
     const candidateSupportEdges = snapshot.subjects.flatMap((subject) => subject.subjectRef !== completionTarget.subjectRef &&
-        candidateSupportSubjectRefs.has(subject.subjectRef)
+        candidateSupportSubjectRefs.has(subject.subjectRef) &&
+        !passiveReviewerDependencySubjectRefs.has(subject.subjectRef)
         ? [
             {
                 sourceSubjectRef: subject.subjectRef,
@@ -44,13 +94,17 @@ export function projectReviewerModelContext(snapshot) {
             }),
         ]
         : []);
-    const claims = snapshot.facts.map((item) => ({
-        claimRef: item.factRef,
-        status: item.status,
-        summary: item.summary,
-        subjectRefs: item.subjectRefs,
-        evidenceRefs: item.evidenceRefs,
-    }));
+    const claims = snapshot.facts.flatMap((item) => item.kind === "role_result"
+        ? []
+        : [
+            {
+                claimRef: item.factRef,
+                status: item.status,
+                summary: item.summary,
+                subjectRefs: item.subjectRefs,
+                evidenceRefs: item.evidenceRefs,
+            },
+        ]);
     const effects = snapshot.evidence.map((item) => ({
         evidenceRef: item.evidenceRef,
         outcome: item.outcome,
@@ -70,6 +124,20 @@ export function projectReviewerModelContext(snapshot) {
                 ? "current_revision"
                 : snapshot.freshness,
         },
+        verificationCoverage: {
+            authority: "runtime_projection",
+            presenceEffect: "pass_eligibility_only_not_semantic_completion_proof_or_user_intent",
+            ...verificationCoverage,
+        },
+        assignment: {
+            authority: "canonical_reviewer_call",
+            callId: reviewerIdentity.callId,
+            purpose: "audit_supplied_completion_target",
+            presenceEffect: "active_reviewer_assignment_only",
+            completionTargetRef: completionTarget.subjectRef,
+        },
+        dependencySubjects,
+        supportSubjects,
         candidateSupportPolicy: {
             authority: "runtime_projection",
             sourceClaimsAndEffectsMaySupportTarget: true,
@@ -93,3 +161,17 @@ export function projectReviewerModelContext(snapshot) {
         evidenceAppendixCharacterCount: referenceMessages.reduce((total, message) => total + message.content.length, 0),
     });
 }
+function projectDependencyFactsBySubjectRef(snapshot) {
+    const projected = new Map();
+    for (const fact of snapshot.facts) {
+        if (fact.kind !== "role_result")
+            continue;
+        if (fact.subjectRefs.length !== 1 ||
+            (fact.status !== "informational" && fact.status !== "missing") ||
+            projected.has(fact.subjectRefs[0])) {
+            throw new Error("reviewer_dependency_fact_invalid");
+        }
+        projected.set(fact.subjectRefs[0], fact);
+    }
+    return projected;
+}