@dailephd/my-dev-kit-lab 0.4.3 → 0.4.4

package/dist/src/evaluation/upstreamArtifacts/validateSupplementalContextDocumentV1.js

@@ -0,0 +1,148 @@
+import { makeFailure } from "./runtimeValidation.js";
+import { parseSupplementalContextText } from "./supplementalContextTextParser.js";
+import { REQUIRED_METADATA_BY_DOCUMENT_KIND, REQUIRED_SECTIONS_BY_DOCUMENT_KIND, ROLE_BY_DOCUMENT_KIND, SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR, SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR, VALID_ADEQUACY_VALUES, VALID_DECLARED_STATUSES, VALID_FRESHNESS_VALUES, VALID_REPOSITORY_SCOPES, VALID_TRUNCATION_VALUES, isRetrievalReportKind, isTestKind } from "./supplementalContextTypes.js";
+const SCHEMA_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+function supportedMajorForKind(kind) {
+    return isRetrievalReportKind(kind)
+        ? SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR
+        : SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR;
+}
+function literalOrFail(artifactKind, sourcePath, fieldPath, value, allowed, errorCode = "INVALID_LITERAL_VALUE") {
+    if (allowed.includes(value))
+        return value;
+    return {
+        ok: false,
+        artifactKind,
+        sourcePath,
+        code: errorCode,
+        message: `Field "${fieldPath}" in artifact "${artifactKind}" at "${sourcePath}" has invalid value "${value}". Expected one of: ${allowed.join(", ")}.`,
+        fieldPath,
+        expected: allowed.join(" | "),
+        actual: value
+    };
+}
+function isFailure(value) {
+    return typeof value === "object" && value !== null && value.ok === false;
+}
+export function validateSupplementalContextDocumentV1(artifactKind, expectedKind, text, sourcePath) {
+    const parsed = parseSupplementalContextText(text);
+    if (parsed.metadataOrder.length === 0 && parsed.sectionOrder.length === 0) {
+        return makeFailure(artifactKind, sourcePath, "MALFORMED_TEXT_ARTIFACT", `Artifact "${artifactKind}" at "${sourcePath}" contains no recognizable "Key: value" metadata or "## Heading" sections.`);
+    }
+    // Kind/role identity is checked before general required-metadata/section completeness so
+    // that feeding one document kind's file to another kind's reader is reported as a
+    // structural identity mismatch (DOCUMENT_KIND_MISMATCH / DOCUMENT_ROLE_MISMATCH) rather
+    // than as an incidental "missing metadata key" from the wrong kind's required-field list.
+    const declaredKind = parsed.metadata["Document kind"];
+    if (declaredKind !== expectedKind) {
+        return makeFailure(artifactKind, sourcePath, "DOCUMENT_KIND_MISMATCH", `Artifact "${artifactKind}" at "${sourcePath}" declares document kind "${declaredKind}" but this reader expects "${expectedKind}".`, "Document kind", expectedKind, declaredKind);
+    }
+    const expectedRole = ROLE_BY_DOCUMENT_KIND[expectedKind];
+    const declaredRole = parsed.metadata["Role"];
+    if (declaredRole !== expectedRole) {
+        return makeFailure(artifactKind, sourcePath, "DOCUMENT_ROLE_MISMATCH", `Artifact "${artifactKind}" at "${sourcePath}" declares role "${declaredRole}" but this reader expects "${expectedRole}".`, "Role", expectedRole, declaredRole);
+    }
+    const requiredMetadata = REQUIRED_METADATA_BY_DOCUMENT_KIND[expectedKind];
+    for (const key of requiredMetadata) {
+        if (!(key in parsed.metadata)) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_METADATA", `Artifact "${artifactKind}" at "${sourcePath}" is missing required metadata key "${key}".`, key, "present");
+        }
+    }
+    const requiredSections = REQUIRED_SECTIONS_BY_DOCUMENT_KIND[expectedKind];
+    for (const heading of requiredSections) {
+        if (!(heading in parsed.sections)) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_SECTION", `Artifact "${artifactKind}" at "${sourcePath}" is missing required section heading "## ${heading}".`, heading, "present");
+        }
+    }
+    const schemaVersion = parsed.metadata["Schema version"];
+    if (!SCHEMA_VERSION_PATTERN.test(schemaVersion)) {
+        return makeFailure(artifactKind, sourcePath, "INVALID_SCHEMA_VERSION", `Artifact "${artifactKind}" at "${sourcePath}" has an invalid "Schema version": expected strict "x.y.z" semantic version.`, "Schema version", "^[0-9]+\\.[0-9]+\\.[0-9]+$", schemaVersion);
+    }
+    const major = Number(schemaVersion.split(".")[0]);
+    const supportedMajor = supportedMajorForKind(expectedKind);
+    if (major !== supportedMajor) {
+        return makeFailure(artifactKind, sourcePath, "UNSUPPORTED_SCHEMA_MAJOR", `Artifact "${artifactKind}" at "${sourcePath}" has unsupported schema major "${major}" in "Schema version": supported major is ${supportedMajor}.`, "Schema version", String(supportedMajor), schemaVersion);
+    }
+    const status = literalOrFail(artifactKind, sourcePath, "Status", parsed.metadata["Status"], VALID_DECLARED_STATUSES, "UNKNOWN_STATUS_VALUE");
+    if (isFailure(status))
+        return status;
+    const repositoryScope = literalOrFail(artifactKind, sourcePath, "Repository scope", parsed.metadata["Repository scope"], VALID_REPOSITORY_SCOPES);
+    if (isFailure(repositoryScope))
+        return repositoryScope;
+    const freshness = literalOrFail(artifactKind, sourcePath, "Freshness", parsed.metadata["Freshness"], VALID_FRESHNESS_VALUES);
+    if (isFailure(freshness))
+        return freshness;
+    const adequacy = literalOrFail(artifactKind, sourcePath, "Adequacy", parsed.metadata["Adequacy"], VALID_ADEQUACY_VALUES);
+    if (isFailure(adequacy))
+        return adequacy;
+    const requiredEvidenceTruncated = literalOrFail(artifactKind, sourcePath, "Required evidence truncated", parsed.metadata["Required evidence truncated"], VALID_TRUNCATION_VALUES);
+    if (isFailure(requiredEvidenceTruncated))
+        return requiredEvidenceTruncated;
+    const indexIdentity = parsed.metadata["Index identity"];
+    if (!indexIdentity || indexIdentity.length === 0) {
+        return makeFailure(artifactKind, sourcePath, "MISSING_CANONICAL_IDENTITY", `Artifact "${artifactKind}" at "${sourcePath}" is missing a non-empty canonical "Index identity".`, "Index identity", "present");
+    }
+    const document = {
+        documentKind: expectedKind,
+        role: expectedRole,
+        schemaVersion,
+        schemaMajor: 1,
+        status,
+        repositoryScope,
+        freshness,
+        adequacy,
+        requiredEvidenceTruncated,
+        contextCapsuleSchemaVersion: parsed.metadata["Context capsule schema version"],
+        retrievalAuditSchemaVersion: parsed.metadata["Retrieval audit schema version"],
+        toolName: parsed.metadata["Tool name"],
+        toolVersion: parsed.metadata["Tool version"],
+        indexIdentity,
+        rawMetadata: parsed.metadata,
+        sections: parsed.sections,
+        sectionOrder: parsed.sectionOrder,
+        metadataOrder: parsed.metadataOrder,
+        warnings: []
+    };
+    if (isRetrievalReportKind(expectedKind)) {
+        document.requestSchemaVersion = parsed.metadata["Request schema version"];
+        const fullFileFallbackUsed = literalOrFail(artifactKind, sourcePath, "Full-file fallback used", parsed.metadata["Full-file fallback used"], VALID_TRUNCATION_VALUES);
+        if (isFailure(fullFileFallbackUsed))
+            return fullFileFallbackUsed;
+        document.fullFileFallbackUsed = fullFileFallbackUsed;
+        const determinismChecked = literalOrFail(artifactKind, sourcePath, "Determinism checked", parsed.metadata["Determinism checked"], VALID_TRUNCATION_VALUES);
+        if (isFailure(determinismChecked))
+            return determinismChecked;
+        document.determinismChecked = determinismChecked;
+    }
+    if (isTestKind(expectedKind)) {
+        const responsibilityMappingsTruncated = literalOrFail(artifactKind, sourcePath, "Responsibility mappings truncated", parsed.metadata["Responsibility mappings truncated"], VALID_TRUNCATION_VALUES);
+        if (isFailure(responsibilityMappingsTruncated))
+            return responsibilityMappingsTruncated;
+        document.responsibilityMappingsTruncated = responsibilityMappingsTruncated;
+        // Preserved verbatim, never validated against the orchestrator's internal
+        // CriticalResponsibilityMappingState enum -- see supplementalContextTypes.ts.
+        const criticalStatus = parsed.metadata["Critical responsibility mapping status"];
+        if (!criticalStatus || criticalStatus.length === 0) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_METADATA", `Artifact "${artifactKind}" at "${sourcePath}" is missing a non-empty "Critical responsibility mapping status".`, "Critical responsibility mapping status", "present");
+        }
+        document.criticalResponsibilityMappingStatus = criticalStatus;
+    }
+    if (parsed.duplicateMetadataKeys.length > 0) {
+        document.warnings.push(`Duplicate metadata keys were ignored (first occurrence kept): ${parsed.duplicateMetadataKeys.join(", ")}.`);
+    }
+    if (parsed.duplicateSectionHeadings.length > 0) {
+        document.warnings.push(`Duplicate section headings were ignored (first occurrence kept): ${parsed.duplicateSectionHeadings.join(", ")}.`);
+    }
+    if (parsed.emptyMetadataKeys.length > 0) {
+        document.warnings.push(`Metadata keys had empty values: ${parsed.emptyMetadataKeys.join(", ")}.`);
+    }
+    return {
+        ok: true,
+        artifactKind,
+        sourcePath,
+        schemaVersion,
+        schemaMajor: 1,
+        artifact: document,
+        rawArtifact: { metadata: parsed.metadata, sections: parsed.sections }
+    };
+}

package/dist/src/experiments/plugins/contextStrategyComparison/loadV043StrategyArtifacts.js

@@ -1,4 +1,4 @@
-import { readMyDevKitContextCapsuleV1, readMyDevKitRetrievalAuditRecordV1, readOrchestratorWorkflowInstructionPacketV1 } from "../../../evaluation/upstreamArtifacts/index.js";
+import { readImplementationContextPacketV1, readImplementationContextRetrievalReportV1, readMyDevKitContextCapsuleV1, readMyDevKitRetrievalAuditRecordV1, readOrchestratorWorkflowInstructionPacketV1, readTestContextPacketV1, readTestContextRetrievalReportV1, validateOrchestratorContextReadinessResultV1 } from "../../../evaluation/upstreamArtifacts/index.js";
 import { checkMyDevKitContextArtifactConsistency } from "../../../evaluation/stageContextSelectors/index.js";
 import { readStageContextExpectationFixtureV1 } from "../../../evaluation/stageContextExpectations/index.js";
 import { readV043FullWorkflowLibraryFixture } from "./readV043FullWorkflowLibraryFixture.js";
@@ -265,20 +265,131 @@ export async function loadV043StrategyArtifacts(input) {
                     details: packetResult
                 });
             }
+            // v0.4.4 Batch 3: producer-readiness bridge inputs -- every one is optional (section
+            // 11.2). Only a supplied-but-unreadable source becomes a load failure; an absent
+            // source is simply left off the payload for the bridge evaluator to treat as
+            // unavailable/not-applicable.
+            let implementationContextPacketSourcePath;
+            let implementationContextPacket;
+            if (input.implementationContextPacketPath !== undefined) {
+                const result = await readImplementationContextPacketV1(input.implementationContextPacketPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "IMPLEMENTATION_CONTEXT_PACKET_READ_FAILED",
+                        fieldPath: "implementationContextPacket",
+                        message: `Failed to read implementation-context packet: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    implementationContextPacketSourcePath = result.sourcePath;
+                    implementationContextPacket = result.artifact;
+                }
+            }
+            let implementationContextRetrievalReportSourcePath;
+            let implementationContextRetrievalReport;
+            if (input.implementationContextRetrievalReportPath !== undefined) {
+                const result = await readImplementationContextRetrievalReportV1(input.implementationContextRetrievalReportPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "IMPLEMENTATION_CONTEXT_RETRIEVAL_REPORT_READ_FAILED",
+                        fieldPath: "implementationContextRetrievalReport",
+                        message: `Failed to read implementation-context retrieval report: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    implementationContextRetrievalReportSourcePath = result.sourcePath;
+                    implementationContextRetrievalReport = result.artifact;
+                }
+            }
+            let testContextPacketSourcePath;
+            let testContextPacket;
+            if (input.testContextPacketPath !== undefined) {
+                const result = await readTestContextPacketV1(input.testContextPacketPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "TEST_CONTEXT_PACKET_READ_FAILED",
+                        fieldPath: "testContextPacket",
+                        message: `Failed to read test-context packet: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    testContextPacketSourcePath = result.sourcePath;
+                    testContextPacket = result.artifact;
+                }
+            }
+            let testContextRetrievalReportSourcePath;
+            let testContextRetrievalReport;
+            if (input.testContextRetrievalReportPath !== undefined) {
+                const result = await readTestContextRetrievalReportV1(input.testContextRetrievalReportPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "TEST_CONTEXT_RETRIEVAL_REPORT_READ_FAILED",
+                        fieldPath: "testContextRetrievalReport",
+                        message: `Failed to read test-context retrieval report: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    testContextRetrievalReportSourcePath = result.sourcePath;
+                    testContextRetrievalReport = result.artifact;
+                }
+            }
+            let readiness;
+            if (input.readiness !== undefined) {
+                const readinessResult = validateOrchestratorContextReadinessResultV1(input.readiness, "programmatic-input:readiness");
+                if (!readinessResult.ok) {
+                    issues.push({
+                        code: "READINESS_INPUT_INVALID",
+                        fieldPath: "readiness",
+                        message: `Readiness programmatic input is invalid: ${readinessResult.message}`,
+                        details: readinessResult
+                    });
+                }
+                else {
+                    readiness = readinessResult.artifact;
+                }
+            }
             if (issues.length > 0 || !expectationsResult.ok || !packetResult.ok || pairs.length !== input.contextArtifacts.length) {
                 return buildFailureResult(input, issues);
             }
+            const payload = {
+                contextArtifacts: pairs,
+                workflowInstructionPacketSourcePath: packetResult.sourcePath,
+                workflowInstructionPacket: packetResult.artifact
+            };
+            if (implementationContextPacket !== undefined) {
+                payload.implementationContextPacketSourcePath = implementationContextPacketSourcePath;
+                payload.implementationContextPacket = implementationContextPacket;
+            }
+            if (implementationContextRetrievalReport !== undefined) {
+                payload.implementationContextRetrievalReportSourcePath = implementationContextRetrievalReportSourcePath;
+                payload.implementationContextRetrievalReport = implementationContextRetrievalReport;
+            }
+            if (testContextPacket !== undefined) {
+                payload.testContextPacketSourcePath = testContextPacketSourcePath;
+                payload.testContextPacket = testContextPacket;
+            }
+            if (testContextRetrievalReport !== undefined) {
+                payload.testContextRetrievalReportSourcePath = testContextRetrievalReportSourcePath;
+                payload.testContextRetrievalReport = testContextRetrievalReport;
+            }
+            if (readiness !== undefined) {
+                payload.readiness = readiness;
+            }
             return {
                 status: "completed",
                 strategyId: input.strategyId,
                 input,
                 expectationsSourcePath: expectationsResult.sourcePath,
                 expectations: expectationsResult.fixture,
-                payload: {
-                    contextArtifacts: pairs,
-                    workflowInstructionPacketSourcePath: packetResult.sourcePath,
-                    workflowInstructionPacket: packetResult.artifact
-                },
+                payload,
                 warnings: []
             };
         }

package/dist/src/experiments/plugins/contextStrategyComparison/runV043StageContextStrategyWithAssurance.js

@@ -1,6 +1,6 @@
 import { captureTargetSnapshot, compareTargetSnapshots } from "../../../evaluation/targetImmutability/index.js";
 import { calculateStageContextDeterminism } from "../../../evaluation/stageContextDeterminism/index.js";
-import { evaluateV043StageContextExecution } from "../../../evaluation/stageContextMetrics/index.js";
+import { buildProducerReadinessBridgeInputFromCombinedPayload, evaluateProducerReadinessBridge, evaluateV043StageContextExecution } from "../../../evaluation/stageContextMetrics/index.js";
 import { executeV043StageContextStrategy } from "./executeV043StageContextStrategy.js";
 async function buildRunWithTargetImmutability(targetConfig, input) {
     if (targetConfig === undefined) {
@@ -57,6 +57,15 @@ async function buildRunWithTargetImmutability(targetConfig, input) {
         targetImmutability: { availability: "available", comparison, reason: null }
     };
 }
+// v0.4.4 Batch 3: computed exactly once per run, immediately after execution, from the
+// already-loaded execution payload -- never rereads artifacts, never reruns the strategy.
+function buildProducerReadinessBridgeResult(execution) {
+    if (execution.status !== "completed" || execution.strategyId !== "combined-bounded-stage-context")
+        return null;
+    const payload = execution.payload;
+    const bridgeInput = buildProducerReadinessBridgeInputFromCombinedPayload(payload, execution.expectations);
+    return evaluateProducerReadinessBridge(bridgeInput);
+}
 function computeStatus(issues, config) {
     if (issues.length > 0)
         return "failed";
@@ -69,23 +78,27 @@ export async function runV043StageContextStrategyWithAssurance(input, config) {
     const issues = [];
     let primaryExecution;
     let primaryEvaluation;
+    let primaryProducerReadinessBridge = null;
     try {
         for (let runNumber = 1; runNumber <= config.repeatCount; runNumber += 1) {
             const { execution, targetImmutability } = await buildRunWithTargetImmutability(config.targetImmutability, input);
             const evaluation = evaluateV043StageContextExecution(execution, { targetImmutability });
+            const producerReadinessBridge = buildProducerReadinessBridgeResult(execution);
             if (runNumber === 1) {
                 primaryExecution = execution;
                 primaryEvaluation = evaluation;
+                primaryProducerReadinessBridge = producerReadinessBridge;
             }
             runRecords.push({
                 runNumber,
                 executionStatus: execution.status,
                 evaluationStatus: evaluation.status,
-                targetImmutability
+                targetImmutability,
+                producerReadinessBridge
             });
             determinismCandidates.push({
                 runNumber,
-                value: { execution, evaluation, targetImmutability }
+                value: { execution, evaluation, targetImmutability, producerReadinessBridge }
             });
             if (execution.status !== "completed") {
                 issues.push({
@@ -147,6 +160,7 @@ export async function runV043StageContextStrategyWithAssurance(input, config) {
             repeatCount: config.repeatCount,
             primaryExecution: primaryExecution,
             primaryEvaluation: primaryEvaluation,
+            primaryProducerReadinessBridge,
             runRecords,
             determinism,
             issues
@@ -175,6 +189,7 @@ export async function runV043StageContextStrategyWithAssurance(input, config) {
             repeatCount: config.repeatCount,
             primaryExecution: fallbackExecution,
             primaryEvaluation: fallbackEvaluation,
+            primaryProducerReadinessBridge,
             runRecords,
             determinism: fallbackDeterminism,
             issues: [

package/dist/src/experiments/plugins/contextStrategyComparison/validateV043StrategyInput.js

@@ -45,7 +45,12 @@ const STRATEGY_CONTRACTS = {
         fields: [
             { name: "expectationsPath", kind: "required-path" },
             { name: "contextArtifacts", kind: "required-array" },
-            { name: "workflowInstructionPacketPath", kind: "required-path" }
+            { name: "workflowInstructionPacketPath", kind: "required-path" },
+            { name: "implementationContextPacketPath", kind: "optional-path" },
+            { name: "implementationContextRetrievalReportPath", kind: "optional-path" },
+            { name: "testContextPacketPath", kind: "optional-path" },
+            { name: "testContextRetrievalReportPath", kind: "optional-path" },
+            { name: "readiness", kind: "optional-object" }
         ]
     }
 };
@@ -93,7 +98,7 @@ export function validateV043StrategyInput(value) {
         }
     }
     for (const field of contract.fields) {
-        if (field.kind !== "optional-path" && root[field.name] === undefined) {
+        if (field.kind !== "optional-path" && field.kind !== "optional-object" && root[field.name] === undefined) {
             issues.push({
                 code: "MISSING_REQUIRED_FIELD",
                 fieldPath: field.name,
@@ -114,6 +119,15 @@ export function validateV043StrategyInput(value) {
                 });
             }
         }
+        else if (field.kind === "optional-object") {
+            if (!isPlainObject(fieldValue)) {
+                issues.push({
+                    code: "INVALID_FIELD_TYPE",
+                    fieldPath: field.name,
+                    message: `"${field.name}" must be an object.`
+                });
+            }
+        }
         else if (typeof fieldValue !== "string") {
             issues.push({
                 code: "INVALID_FIELD_TYPE",
@@ -123,7 +137,7 @@ export function validateV043StrategyInput(value) {
         }
     }
     for (const field of contract.fields) {
-        if (field.kind === "required-array")
+        if (field.kind === "required-array" || field.kind === "optional-object")
             continue;
         const fieldValue = root[field.name];
         if (typeof fieldValue === "string" && fieldValue.length === 0) {

package/dist/src/report/experiments/buildContextStrategyComparisonV043Report.js

@@ -69,12 +69,134 @@ function buildSummary(executions, evaluations, assurances) {
     };
 }
 function buildStrategyReport(execution, evaluation, assurance) {
+    const producerReadinessBridge = buildProducerReadinessBridgeReport(assurance.primaryProducerReadinessBridge);
     return {
         strategyId: assurance.strategyId,
         artifacts: buildArtifactMetadata(execution),
         execution: buildExecutionSummary(execution),
         evaluation: buildEvaluationSummary(evaluation),
         assurance: buildAssuranceSummary(assurance),
+        ...(producerReadinessBridge ? { producerReadinessBridge } : {}),
+    };
+}
+function buildAllocationFactList(source) {
+    return boundItems(source.map((f) => ({ groupId: f.groupId, value: f.value, unit: f.unit, availability: f.availability, reason: f.reason })));
+}
+function buildOwnerEvaluation(owner) {
+    return {
+        selectedOwnerEvidence: boundItems(owner.selectedOwnerEvidence.map((e) => ({ ownerId: e.ownerId, sourceArtifact: e.sourceArtifact, sourceInstance: e.sourceInstance }))),
+        expectedOwnerPresent: buildRatioMetric(owner.expectedOwnerPresent),
+        forbiddenOwnerPresent: buildRatioMetric(owner.forbiddenOwnerPresent),
+        falsePositiveCount: buildCountMetric(owner.falsePositiveCount),
+        falseNegativeCount: buildCountMetric(owner.falseNegativeCount),
+    };
+}
+function buildTruncationList(source) {
+    return boundItems(source.map((t) => ({
+        groupId: t.groupId,
+        cause: t.cause,
+        availability: t.availability,
+        reason: t.reason,
+        omittedRequiredEvidenceIds: t.omittedRequiredEvidenceIds,
+        limit: t.limit,
+        used: t.used,
+        available: t.available,
+    })));
+}
+function buildSupplementalRawAgreement(agreement) {
+    if (agreement === null)
+        return null;
+    return {
+        fields: agreement.fields.map((f) => ({ field: f.field, rawValue: f.rawValue, supplementalValue: f.supplementalValue, agreement: f.agreement, availability: f.availability, reason: f.reason })),
+        contradictions: agreement.contradictions.map((f) => ({ field: f.field, rawValue: f.rawValue, supplementalValue: f.supplementalValue, agreement: f.agreement, availability: f.availability, reason: f.reason })),
+        upstreamProducerParityPreserved: agreement.upstreamProducerParityPreserved,
+    };
+}
+function buildProducerReadinessSide(side) {
+    return {
+        role: side.role,
+        ownerEvaluation: buildOwnerEvaluation(side.ownerEvaluation),
+        allocationEvaluation: {
+            requiredGroupCapacity: buildAllocationFactList(side.allocationEvaluation.requiredGroupCapacity),
+            usedReservation: buildAllocationFactList(side.allocationEvaluation.usedReservation),
+            borrowedCapacity: buildAllocationFactList(side.allocationEvaluation.borrowedCapacity),
+            unusedCapacity: buildAllocationFactList(side.allocationEvaluation.unusedCapacity),
+        },
+        truncationEvaluation: buildTruncationList(side.truncationEvaluation),
+        packetAgreement: buildSupplementalRawAgreement(side.packetAgreement),
+        reportAgreement: buildSupplementalRawAgreement(side.reportAgreement),
+    };
+}
+function buildReadinessAgreement(agreement) {
+    return {
+        structuralAgreement: agreement.structuralAgreement.map((s) => ({
+            field: s.field,
+            expectedValue: s.expectedValue,
+            observedValue: s.observedValue,
+            agreement: s.agreement,
+            availability: s.availability,
+            reason: s.reason,
+        })),
+        decisionAgreement: {
+            availability: agreement.decisionAgreement.availability,
+            observedDecision: agreement.decisionAgreement.observedDecision,
+            allowedDecisions: agreement.decisionAgreement.allowedDecisions,
+            decisionAgreement: agreement.decisionAgreement.decisionAgreement,
+            observedIssueCodes: agreement.decisionAgreement.observedIssueCodes,
+            expectedIssueCodes: agreement.decisionAgreement.expectedIssueCodes,
+            issueCodesAgreement: agreement.decisionAgreement.issueCodesAgreement,
+            observedPrimaryIssueCode: agreement.decisionAgreement.observedPrimaryIssueCode,
+            expectedPrimaryIssueCode: agreement.decisionAgreement.expectedPrimaryIssueCode,
+            primaryIssueAgreement: agreement.decisionAgreement.primaryIssueAgreement,
+            reason: agreement.decisionAgreement.reason,
+        },
+        invalidReady: {
+            availability: agreement.invalidReady.availability,
+            invalidReady: agreement.invalidReady.invalidReady,
+            missingExpectedIssueCodes: agreement.invalidReady.missingExpectedIssueCodes,
+            reason: agreement.invalidReady.reason,
+        },
+        validBlocked: {
+            availability: agreement.validBlocked.availability,
+            validBlocked: agreement.validBlocked.validBlocked,
+            validRefreshRequired: agreement.validBlocked.validRefreshRequired,
+            observedDecision: agreement.validBlocked.observedDecision,
+            reason: agreement.validBlocked.reason,
+        },
+    };
+}
+function buildCriticalityEvaluation(criticality) {
+    return {
+        overlayAgreement: boundItems(criticality.overlayAgreement.map((e) => ({
+            responsibilityId: e.responsibilityId,
+            expectedCriticality: e.expectedCriticality,
+            observedCriticality: e.observedCriticality,
+            agreement: e.agreement,
+            availability: e.availability,
+            reason: e.reason,
+        }))),
+        missingCriticalityResponsibilityIds: criticality.missingCriticalityResponsibilityIds,
+        conflictingCriticalityResponsibilityIds: criticality.conflictingCriticalityResponsibilityIds,
+        unexpectedCriticalityResponsibilityIds: criticality.unexpectedCriticalityResponsibilityIds,
+        mappedCriticalCompleteness: buildRatioMetric(criticality.mappedCriticalCompleteness),
+        fullyMappedCriticalIds: criticality.fullyMappedCriticalIds,
+        partiallyMappedCriticalIds: criticality.partiallyMappedCriticalIds,
+        unmappedCriticalIds: criticality.unmappedCriticalIds,
+        missingMappingEvidenceCriticalIds: criticality.missingMappingEvidenceCriticalIds,
+    };
+}
+function buildProducerReadinessBridgeReport(bridge) {
+    if (bridge === null || bridge === undefined)
+        return null;
+    return {
+        status: bridge.status,
+        reason: bridge.reason,
+        implementation: bridge.implementation ? buildProducerReadinessSide(bridge.implementation) : null,
+        testImplementation: bridge.testImplementation ? buildProducerReadinessSide(bridge.testImplementation) : null,
+        readinessAgreement: bridge.readinessAgreement ? buildReadinessAgreement(bridge.readinessAgreement) : null,
+        criticalityEvaluation: bridge.criticalityEvaluation ? buildCriticalityEvaluation(bridge.criticalityEvaluation) : null,
+        warnings: boundItems(bridge.warnings),
+        evidenceReferences: boundItems(bridge.evidenceReferences),
     };
 }
 function buildExecutionSummary(execution) {

package/dist/src/report/experiments/renderContextStrategyComparisonV043Html.js

@@ -187,8 +187,70 @@ function renderStrategySection(strategy, index) {
     ${table(["Status", "Repeat Count"], [[strategy.assurance.status, String(strategy.assurance.repeatCount)]])}
     ${boundedListNote(strategy.assurance.issues)}
     ${table(["Code", "Run", "Field Path", "Message"], assuranceIssueRows)}
+    ${strategy.producerReadinessBridge ? renderProducerReadinessBridgeSection(strategy.producerReadinessBridge) : ""}
   </section>`;
 }
+function renderProducerReadinessSideSection(label, side) {
+    if (side === null) {
+        return `<h4>${escapeHtml(label)}</h4><p class="muted">Not supplied.</p>`;
+    }
+    const truncationRows = side.truncationEvaluation.items.map((t) => [
+        t.groupId,
+        t.cause,
+        t.availability,
+        String(t.limit),
+        String(t.used),
+        t.reason ?? "",
+    ]);
+    function agreementSection(agreementLabel, agreement) {
+        if (agreement === null) {
+            return `<h5>${escapeHtml(agreementLabel)}</h5><p class="muted">Unavailable.</p>`;
+        }
+        const rows = agreement.contradictions.map((c) => [c.field, String(c.rawValue), String(c.supplementalValue), c.availability]);
+        return `<h5>${escapeHtml(agreementLabel)}</h5>
+      <p>Producer parity preserved: ${escapeHtml(agreement.upstreamProducerParityPreserved)}</p>
+      ${table(["Field", "Raw Value", "Supplemental Value", "Availability"], rows)}`;
+    }
+    return `<h4>${escapeHtml(label)}</h4>
+    ${renderRatioMetricTable("Expected Owner Present", side.ownerEvaluation.expectedOwnerPresent)}
+    ${renderRatioMetricTable("Forbidden Owner Present", side.ownerEvaluation.forbiddenOwnerPresent)}
+    ${renderCountMetricTable("Owner False Positives", side.ownerEvaluation.falsePositiveCount)}
+    ${renderCountMetricTable("Owner False Negatives", side.ownerEvaluation.falseNegativeCount)}
+    <h5>Truncation Classification</h5>
+    ${boundedListNote(side.truncationEvaluation)}
+    ${table(["Group", "Cause", "Availability", "Limit", "Used", "Reason"], truncationRows)}
+    ${agreementSection("Packet/Raw Agreement", side.packetAgreement)}
+    ${agreementSection("Report/Raw Agreement", side.reportAgreement)}`;
+}
+function renderProducerReadinessBridgeSection(bridge) {
+    if (bridge.status === "not-applicable") {
+        return `<h4>Producer-Readiness Bridge</h4><p class="muted">${escapeHtml(bridge.reason)}</p>`;
+    }
+    const criticality = bridge.criticalityEvaluation;
+    return `<h4>Producer-Readiness Bridge</h4>
+    ${renderProducerReadinessSideSection("Implementation", bridge.implementation)}
+    ${renderProducerReadinessSideSection("Test", bridge.testImplementation)}
+    <h5>Readiness Agreement</h5>
+    ${bridge.readinessAgreement === null
+        ? `<p class="muted">Not supplied.</p>`
+        : table(["Observed Decision", "Decision Agreement", "Issue-Code Agreement", "Invalid Ready", "Valid Blocked", "Valid Refresh-Required"], [
+            [
+                String(bridge.readinessAgreement.decisionAgreement.observedDecision),
+                String(bridge.readinessAgreement.decisionAgreement.decisionAgreement),
+                String(bridge.readinessAgreement.decisionAgreement.issueCodesAgreement),
+                String(bridge.readinessAgreement.invalidReady.invalidReady),
+                String(bridge.readinessAgreement.validBlocked.validBlocked),
+                String(bridge.readinessAgreement.validBlocked.validRefreshRequired),
+            ],
+        ])}
+    <h5>Criticality Evaluation</h5>
+    ${criticality === null
+        ? `<p class="muted">Not supplied.</p>`
+        : `${renderRatioMetricTable("Mapped Critical Completeness", criticality.mappedCriticalCompleteness)}
+           <p>Partially mapped (excluded from complete): ${escapeHtml(criticality.partiallyMappedCriticalIds.join(", ") || "none")}</p>
+           <p>Unmapped: ${escapeHtml(criticality.unmappedCriticalIds.join(", ") || "none")}</p>
+           <p>Conflicting: ${escapeHtml(criticality.conflictingCriticalityResponsibilityIds.join(", ") || "none")}</p>`}`;
+}
 export function renderContextStrategyComparisonV043Html(report) {
     if (report === null) {
         return `<section><h2>V0.4.3 Stage-Context Evidence</h2><p>Not applicable to this plugin.</p></section>`;