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

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/buildContextIntegrityReport.js

@@ -0,0 +1,204 @@
+// v0.4.5 Batch 5: builds the bounded ContextIntegrityReportV1 from already-calculated
+// Batch 1-4 results. Never recalculates allocation, condition coverage, agreement states,
+// hashes, determinism, or immutability -- it only bounds and reshapes values the caller
+// already computed via evaluateProducerReadinessBridge, verifyFixtureHashes, and
+// calculateStageContextDeterminism.
+import { V043_REPORT_DETAIL_LIMIT } from "./contextStrategyComparisonV043ReportModel.js";
+const CORRECTED_REPLAY_LIMITATION = "This corrected-replay fixture is a hand-distilled representation of the exact validated local my-dev-kit v1.10.4 and my-dev-kit-orchestrator v1.2.3 contracts, applied to the same request, target, and active-index identity as the paired failed-run fixture. It is not a live capture of a complete ten-stage AI-authored implementation workflow, and it is not proof that every future run against these contracts will behave identically.";
+function boundItems(source, limit = V043_REPORT_DETAIL_LIMIT) {
+    const items = source.slice(0, limit);
+    return { totalCount: source.length, displayedCount: items.length, omittedCount: source.length - items.length, items };
+}
+function toContradiction(c) {
+    return { code: c.code, fieldPath: c.fieldPath, expected: c.expected, observed: c.observed, reason: c.reason };
+}
+function agreementFromRunIntegrity(component) {
+    return {
+        availability: component.availability,
+        outcome: component.outcome,
+        contradictions: boundItems(component.contradictions.map(toContradiction)),
+        reason: component.reason
+    };
+}
+function unavailableAgreement(reason) {
+    return { availability: "unavailable", outcome: "insufficient-evidence", contradictions: boundItems([]), reason };
+}
+export function buildContextIntegrityReport(input) {
+    const { manifest, hashVerification, capsule, bridgeResult } = input;
+    const side = bridgeResult.implementation ?? bridgeResult.testImplementation;
+    const runIntegrity = bridgeResult.runIntegrityEvaluation;
+    const derivedCount = manifest.artifacts.filter((a) => a.derived).length;
+    const byteExactCount = manifest.artifacts.filter((a) => a.byteExact).length;
+    const allocationAgg = side?.groupAllocationEvaluation.aggregate ?? null;
+    const spillover = side?.groupAllocationEvaluation.spillover ?? null;
+    const conditionCoverage = side?.conditionCoverageEvaluation ?? null;
+    const conditionAwareTruncation = side?.conditionAwareTruncationEvaluation ?? null;
+    const unavailableSections = [];
+    const notes = [];
+    if (!side)
+        unavailableSections.push("producer");
+    if (!runIntegrity)
+        unavailableSections.push("run-integrity");
+    if (conditionCoverage?.availability !== "available")
+        unavailableSections.push("condition-coverage");
+    return {
+        schemaVersion: "1.0.0",
+        detailLimit: V043_REPORT_DETAIL_LIMIT,
+        fixture: {
+            fixtureId: manifest.fixtureId,
+            kind: input.fixtureKind,
+            description: manifest.description,
+            myDevKitCommit: manifest.myDevKit.commit,
+            orchestratorCommit: manifest.orchestrator.commit,
+            targetRepositoryIdentity: manifest.targetRepositoryIdentity,
+            activeIndexIdentity: manifest.activeIndexIdentity,
+            manifestSchemaVersion: manifest.manifestSchemaVersion,
+            trackedArtifactCount: manifest.artifacts.length,
+            derivedArtifactCount: derivedCount,
+            byteExactArtifactCount: byteExactCount,
+            artifacts: boundItems(manifest.artifacts.map((a) => ({
+                fixtureRelativePath: a.fixtureRelativePath,
+                role: a.role,
+                derived: a.derived,
+                byteExact: a.byteExact,
+                provenanceOnly: a.provenanceOnly
+            }))),
+            hashVerification: {
+                ok: hashVerification.ok,
+                checkedCount: hashVerification.checkedCount,
+                issues: boundItems(hashVerification.issues.map((i) => ({ code: i.code, fixtureRelativePath: i.fixtureRelativePath, message: i.message })))
+            },
+            correctedReplayLimitation: input.fixtureKind === "corrected-replay" ? CORRECTED_REPLAY_LIMITATION : ""
+        },
+        producerIdentity: {
+            toolName: capsule?.tool.name ?? null,
+            toolVersion: capsule?.tool.version ?? null,
+            role: capsule?.request.role ?? null,
+            projectRoot: capsule?.index.projectRoot ?? null,
+            indexPath: capsule?.index.indexPath ?? null,
+            roleAdequacyStatus: capsule?.roleAdequacy.status ?? null
+        },
+        allocation: {
+            availability: allocationAgg?.availability ?? "unavailable",
+            groupCount: allocationAgg?.groupCount ?? 0,
+            totalRequiredOmitted: allocationAgg?.totalRequiredOmitted ?? null,
+            totalOptionalOmitted: allocationAgg?.totalOptionalOmitted ?? null,
+            aggregateCapacityUsed: null,
+            aggregateCapacityRemaining: null,
+            groupsWithRequiredOmission: allocationAgg?.groupsWithRequiredOmission ?? [],
+            groupsWithOptionalOnlyOmission: allocationAgg?.groupsWithOptionalOnlyOmission ?? [],
+            perGroup: boundItems((side?.groupAllocationEvaluation.perGroup ?? []).map((g) => ({
+                groupId: g.groupId,
+                availability: g.availability,
+                required: g.required,
+                reservation: g.reservation,
+                initiallySelectedCount: g.initiallySelectedCount,
+                unusedReservationContributed: g.unusedReservationContributed,
+                borrowedCapacity: g.borrowedCapacity,
+                requiredOmittedCount: g.requiredOmittedCount,
+                optionalOmittedCount: g.optionalOmittedCount,
+                adequacyAffected: g.adequacyAffected
+            })))
+        },
+        spillover: {
+            availability: spillover?.availability ?? "unavailable",
+            groupsContributing: spillover?.groupsContributing ?? [],
+            groupsBorrowing: spillover?.groupsBorrowing ?? [],
+            totalContributed: spillover?.totalContributed ?? null,
+            totalBorrowed: spillover?.totalBorrowed ?? null,
+            contributionCoversBorrowing: spillover?.contributionCoversBorrowing ?? null,
+            reason: spillover?.reason ?? null
+        },
+        truncation: {
+            availability: conditionAwareTruncation?.availability ?? "unavailable",
+            state: conditionAwareTruncation?.state ?? "unsupported-legacy-diagnostics",
+            requiredEvidenceLost: conditionAwareTruncation?.requiredEvidenceLost ?? null,
+            requiredOmittedTotal: conditionAwareTruncation?.requiredOmittedTotal ?? null,
+            optionalOmittedTotal: conditionAwareTruncation?.optionalOmittedTotal ?? null,
+            lostRequiredConditionIds: conditionAwareTruncation?.lostRequiredConditionIds ?? [],
+            contradictions: boundItems((conditionAwareTruncation?.contradictionCodes ?? []).map((code) => ({ code, fieldPath: "truncation", expected: null, observed: null, reason: conditionAwareTruncation?.reason ?? "" })))
+        },
+        conditionCoverage: {
+            availability: conditionCoverage?.availability ?? "unavailable",
+            requiredConditionsTotal: conditionCoverage?.requiredConditionsTotal.count ?? null,
+            requiredConditionsSatisfied: conditionCoverage?.requiredConditionsSatisfied.count ?? null,
+            requiredConditionsMissing: conditionCoverage?.requiredConditionsMissing.evidenceKeys ?? [],
+            requiredConditionsLost: conditionCoverage?.requiredConditionsLost.evidenceKeys ?? [],
+            lastWitnessLossCount: conditionCoverage?.lastWitnessLoss.count ?? null,
+            witnessEvidence: boundItems((conditionCoverage?.witnessEvidence ?? []).map((w) => ({
+                conditionId: w.conditionId,
+                required: w.required,
+                coverageState: w.coverageState,
+                retainedWitnessCount: w.retainedWitnessCount,
+                retainedWitnessIds: boundItems(w.retainedWitnessIds),
+                adequateWitnessRemains: w.adequateWitnessRemains,
+                lossReason: w.lossReason,
+                evidenceGroupIds: w.evidenceGroupIds
+            }))),
+            reason: conditionCoverage?.reason ?? null
+        },
+        producerConditionAgreement: side
+            ? {
+                availability: side.producerConditionAgreement.availability,
+                outcome: side.producerConditionAgreement.outcome,
+                contradictions: boundItems(side.producerConditionAgreement.contradictionCodes.map((code) => ({ code, fieldPath: "roleAdequacy", expected: null, observed: null, reason: side.producerConditionAgreement.reason ?? "" }))),
+                reason: side.producerConditionAgreement.reason
+            }
+            : unavailableAgreement("No producer side was supplied."),
+        requiredEvidenceLossAgreement: side
+            ? {
+                availability: side.requiredEvidenceLossAgreement.availability,
+                outcome: side.requiredEvidenceLossAgreement.outcome,
+                contradictions: boundItems(side.requiredEvidenceLossAgreement.contradictionCodes.map((code) => ({ code, fieldPath: "truncation.requiredEvidenceLost", expected: null, observed: null, reason: side.requiredEvidenceLossAgreement.reason ?? "" }))),
+                reason: side.requiredEvidenceLossAgreement.reason
+            }
+            : unavailableAgreement("No producer side was supplied."),
+        capsuleAuditAgreement: side
+            ? {
+                availability: side.capsuleAuditConditionAgreement.availability,
+                consistent: side.capsuleAuditConditionAgreement.consistent,
+                contradictingFieldPaths: side.capsuleAuditConditionAgreement.contradictingFieldPaths
+            }
+            : { availability: "unavailable", consistent: null, contradictingFieldPaths: [] },
+        supplementalRawAgreement: side?.packetAgreement || side?.reportAgreement
+            ? {
+                availability: "available",
+                contradictingFields: [...(side.packetAgreement?.contradictions ?? []), ...(side.reportAgreement?.contradictions ?? [])].map((f) => f.field),
+                upstreamProducerParityPreserved: side.packetAgreement?.upstreamProducerParityPreserved ?? side.reportAgreement?.upstreamProducerParityPreserved ?? null
+            }
+            : null,
+        producerReadinessAgreement: bridgeResult.producerReadinessRelationship
+            ? {
+                availability: bridgeResult.producerReadinessRelationship.availability,
+                outcome: bridgeResult.producerReadinessRelationship.outcome,
+                contradictions: boundItems(bridgeResult.producerReadinessRelationship.contradictionCodes.map((code) => ({ code, fieldPath: "readiness", expected: null, observed: null, reason: bridgeResult.producerReadinessRelationship.reason ?? "" }))),
+                reason: bridgeResult.producerReadinessRelationship.reason
+            }
+            : unavailableAgreement("No producer/readiness relationship was calculated."),
+        readinessPromptAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.readinessPrompt) : unavailableAgreement("No run-integrity evidence was supplied."),
+        readinessExpectedJudgeAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.readinessExpectedJudge) : unavailableAgreement("No run-integrity evidence was supplied."),
+        expectedActualJudgeAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.expectedActualJudge) : unavailableAgreement("No run-integrity evidence was supplied."),
+        judgeCorrectionAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.judgeCorrection) : unavailableAgreement("No run-integrity evidence was supplied."),
+        judgeFinalEligibilityAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.judgeFinalEligibility) : unavailableAgreement("No run-integrity evidence was supplied."),
+        eligibilityFinalArtifactAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.eligibilityFinalArtifact) : unavailableAgreement("No run-integrity evidence was supplied."),
+        lifecycleIntegrityAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.lifecycleIntegrity) : unavailableAgreement("No run-integrity evidence was supplied."),
+        endToEnd: runIntegrity
+            ? { category: runIntegrity.endToEndSummary.category, componentOutcomes: runIntegrity.endToEndSummary.componentOutcomes, contradictingComponents: runIntegrity.endToEndSummary.contradictingComponents }
+            : null,
+        determinism: input.determinism
+            ? {
+                availability: input.determinism.availability,
+                repeatCount: input.determinism.repeatCount,
+                deterministic: input.determinism.deterministic,
+                baselineSha256: input.determinism.baselineSha256,
+                mismatchRunNumbers: input.determinism.mismatchRunNumbers,
+                reason: input.determinism.reason
+            }
+            : { availability: "not-applicable", repeatCount: 1, deterministic: null, baselineSha256: null, mismatchRunNumbers: [], reason: "Determinism was not evaluated for this report." },
+        immutability: {
+            fixtureSelfImmutable: input.fixtureSelfImmutable ?? null,
+            fixtureImmutabilityReason: input.fixtureSelfImmutableReason ?? (input.fixtureSelfImmutable === undefined ? "Fixture self-immutability was not checked for this report." : null)
+        },
+        limitations: { unavailableSections, notes }
+    };
+}

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/contextIntegrityReportModel.js

@@ -0,0 +1 @@
+export {};

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

@@ -6,3 +6,8 @@ export * from "./contextStrategyComparisonV043ReportModel.js";
 export { buildContextStrategyComparisonV043Report } from "./buildContextStrategyComparisonV043Report.js";
 export { renderContextStrategyComparisonV043Html } from "./renderContextStrategyComparisonV043Html.js";
 export { renderPluginExperimentReportText } from "./renderPluginExperimentReportText.js";
+export * from "./contextIntegrityReportModel.js";
+export { buildContextIntegrityReport } from "./buildContextIntegrityReport.js";
+export { renderContextIntegrityJsonReport } from "./renderContextIntegrityJsonReport.js";
+export { renderContextIntegrityText } from "./renderContextIntegrityText.js";
+export { renderContextIntegrityHtml } from "./renderContextIntegrityHtml.js";

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

@@ -0,0 +1,98 @@
+function escapeHtml(value) {
+    return String(value ?? "")
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function table(headers, rows) {
+    return `<table><thead><tr>${headers.map((h) => `<th>${escapeHtml(h)}</th>`).join("")}</tr></thead><tbody>${rows
+        .map((row) => `<tr>${row.map((cell) => `<td>${escapeHtml(cell)}</td>`).join("")}</tr>`)
+        .join("")}</tbody></table>`;
+}
+function renderAgreementSection(label, agreement) {
+    const rows = agreement.contradictions.items.map((c) => [c.code, c.fieldPath, c.expected ?? "", c.observed ?? "", c.reason]);
+    return `<section><h3>${escapeHtml(label)}</h3>${table(["Availability", "Outcome", "Reason"], [[agreement.availability, agreement.outcome, agreement.reason ?? ""]])}${agreement.contradictions.totalCount > 0
+        ? `<p class="muted">Contradictions displayed ${agreement.contradictions.displayedCount} of ${agreement.contradictions.totalCount} (omitted ${agreement.contradictions.omittedCount}).</p>${table(["Code", "Field path", "Expected", "Observed", "Reason"], rows)}`
+        : ""}</section>`;
+}
+export function renderContextIntegrityHtml(report) {
+    const endToEndLabel = report.endToEnd?.category ?? "unavailable";
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Context-integrity report: ${escapeHtml(report.fixture.fixtureId)}</title>
+<style>
+body { font-family: system-ui, sans-serif; margin: 2rem; color: #1a1a1a; }
+table { border-collapse: collapse; margin: 0.5rem 0 1rem; width: 100%; }
+th, td { border: 1px solid #ccc; padding: 0.35rem 0.5rem; text-align: left; font-size: 0.9rem; }
+.muted { color: #666; font-size: 0.85rem; }
+.badge { display: inline-block; padding: 0.15rem 0.5rem; border-radius: 0.25rem; font-weight: 600; }
+.badge-full-agreement { background: #d7f5dd; color: #1b6b32; }
+.badge-contradiction-present { background: #fbdada; color: #8f1d1d; }
+.badge-insufficient-evidence, .badge-unsupported-legacy-evidence { background: #eee; color: #444; }
+section { margin-bottom: 1.5rem; }
+</style>
+</head>
+<body>
+<h1>Context-integrity report: ${escapeHtml(report.fixture.fixtureId)} (${escapeHtml(report.fixture.kind)})</h1>
+<p>End-to-end result: <span class="badge badge-${escapeHtml(endToEndLabel)}">${escapeHtml(endToEndLabel)}</span></p>
+${report.fixture.correctedReplayLimitation ? `<p class="muted"><strong>Limitation:</strong> ${escapeHtml(report.fixture.correctedReplayLimitation)}</p>` : ""}
+
+<section><h2>Fixture and provenance</h2>${table(["Field", "Value"], [
+        ["my-dev-kit commit", report.fixture.myDevKitCommit ?? ""],
+        ["orchestrator commit", report.fixture.orchestratorCommit ?? ""],
+        ["Target repository identity", report.fixture.targetRepositoryIdentity ?? ""],
+        ["Active index identity", report.fixture.activeIndexIdentity ?? ""],
+        ["Tracked artifacts", String(report.fixture.trackedArtifactCount)],
+        ["Derived artifacts", String(report.fixture.derivedArtifactCount)],
+        ["Byte-exact artifacts", String(report.fixture.byteExactArtifactCount)],
+        ["Hash verification", report.fixture.hashVerification.ok ? "PASS" : "FAIL"]
+    ])}</section>
+
+<section><h2>Producer allocation and omissions</h2>${table(["Field", "Value"], [
+        ["Role adequacy status", report.producerIdentity.roleAdequacyStatus ?? "(unavailable)"],
+        ["Groups evaluated", String(report.allocation.groupCount)],
+        ["Total required omitted", String(report.allocation.totalRequiredOmitted ?? "(unavailable)")],
+        ["Total optional omitted", String(report.allocation.totalOptionalOmitted ?? "(unavailable)")],
+        ["Groups with required omission", report.allocation.groupsWithRequiredOmission.join(", ") || "(none)"],
+        ["Groups with optional-only omission", report.allocation.groupsWithOptionalOnlyOmission.join(", ") || "(none)"],
+        ["Truncation state", report.truncation.state],
+        ["requiredEvidenceLost", String(report.truncation.requiredEvidenceLost)]
+    ])}</section>
+
+<section><h2>Condition coverage</h2>${table(["Field", "Value"], [
+        ["Availability", report.conditionCoverage.availability],
+        ["Required conditions total", String(report.conditionCoverage.requiredConditionsTotal ?? "(unavailable)")],
+        ["Required conditions satisfied", String(report.conditionCoverage.requiredConditionsSatisfied ?? "(unavailable)")],
+        ["Required conditions missing", report.conditionCoverage.requiredConditionsMissing.join(", ") || "(none)"],
+        ["Required conditions lost", report.conditionCoverage.requiredConditionsLost.join(", ") || "(none)"],
+        ["Last-witness-loss count", String(report.conditionCoverage.lastWitnessLossCount ?? "(unavailable)")]
+    ])}</section>
+
+${renderAgreementSection("Producer-condition agreement", report.producerConditionAgreement)}
+${renderAgreementSection("requiredEvidenceLost agreement", report.requiredEvidenceLossAgreement)}
+${renderAgreementSection("Producer/readiness relationship", report.producerReadinessAgreement)}
+<p class="muted">Note: the orchestrator does not expose a literal upstream <code>promptMode</code> field. <code>stageMayRenderNormalPrompt</code> (derived from structured blocked-stage evidence) is the bounded substitute used below.</p>
+${renderAgreementSection("Readiness/prompt agreement", report.readinessPromptAgreement)}
+${renderAgreementSection("Readiness/expected-judge agreement", report.readinessExpectedJudgeAgreement)}
+${renderAgreementSection("Expected/actual-judge agreement", report.expectedActualJudgeAgreement)}
+${renderAgreementSection("Judge/correction agreement", report.judgeCorrectionAgreement)}
+${renderAgreementSection("Judge/final-eligibility agreement", report.judgeFinalEligibilityAgreement)}
+${renderAgreementSection("Eligibility/final-artifact agreement", report.eligibilityFinalArtifactAgreement)}
+${renderAgreementSection("Lifecycle-integrity agreement", report.lifecycleIntegrityAgreement)}
+
+<section><h2>Determinism and immutability</h2>${table(["Field", "Value"], [
+        ["Determinism availability", report.determinism.availability],
+        ["Repeat count", String(report.determinism.repeatCount)],
+        ["Deterministic", String(report.determinism.deterministic)],
+        ["Fixture self-immutable", String(report.immutability.fixtureSelfImmutable)]
+    ])}</section>
+
+<section><h2>Limitations</h2>${report.limitations.notes.length > 0 ? `<ul>${report.limitations.notes.map((n) => `<li>${escapeHtml(n)}</li>`).join("")}</ul>` : "<p>(none)</p>"}</section>
+</body>
+</html>
+`;
+}

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

@@ -0,0 +1,3 @@
+export function renderContextIntegrityJsonReport(report) {
+    return JSON.stringify(report, null, 2);
+}