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

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

@@ -0,0 +1,111 @@
+function line(label, value) {
+    return `  ${label}: ${value === null || value === undefined ? "(unavailable)" : String(value)}`;
+}
+function renderAgreement(label, agreement) {
+    const lines = [`${label}: ${agreement.outcome} (availability: ${agreement.availability})`];
+    if (agreement.reason)
+        lines.push(`  reason: ${agreement.reason}`);
+    if (agreement.contradictions.totalCount > 0) {
+        lines.push(`  contradictions (${agreement.contradictions.displayedCount} of ${agreement.contradictions.totalCount}, omitted ${agreement.contradictions.omittedCount}):`);
+        for (const c of agreement.contradictions.items) {
+            lines.push(`    - [${c.code}] ${c.fieldPath}: expected=${c.expected ?? "(n/a)"} observed=${c.observed ?? "(n/a)"} -- ${c.reason}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function renderContextIntegrityText(report) {
+    const sections = [];
+    sections.push([
+        "=== 1. Context-integrity summary ===",
+        line("Fixture ID", report.fixture.fixtureId),
+        line("Fixture kind", report.fixture.kind),
+        line("End-to-end category", report.endToEnd?.category ?? "(unavailable)"),
+        line("Contradicting components", report.endToEnd ? report.endToEnd.contradictingComponents.join(", ") || "(none)" : "(unavailable)")
+    ].join("\n"));
+    sections.push([
+        "=== 2. Fixture and provenance ===",
+        line("Description", report.fixture.description),
+        line("my-dev-kit commit", report.fixture.myDevKitCommit),
+        line("orchestrator commit", report.fixture.orchestratorCommit),
+        line("Target repository identity", report.fixture.targetRepositoryIdentity),
+        line("Active index identity", report.fixture.activeIndexIdentity),
+        line("Manifest schema version", report.fixture.manifestSchemaVersion),
+        line("Tracked artifacts", report.fixture.trackedArtifactCount),
+        line("Derived artifacts", report.fixture.derivedArtifactCount),
+        line("Byte-exact artifacts", report.fixture.byteExactArtifactCount),
+        line("Hash verification", `${report.fixture.hashVerification.ok ? "PASS" : "FAIL"} (${report.fixture.hashVerification.checkedCount} checked)`),
+        ...(report.fixture.correctedReplayLimitation ? [`  LIMITATION: ${report.fixture.correctedReplayLimitation}`] : [])
+    ].join("\n"));
+    sections.push([
+        "=== 3. Producer allocation and omissions ===",
+        line("Producer tool", `${report.producerIdentity.toolName ?? "(unavailable)"} ${report.producerIdentity.toolVersion ?? ""}`.trim()),
+        line("Role adequacy status", report.producerIdentity.roleAdequacyStatus),
+        line("Allocation availability", report.allocation.availability),
+        line("Groups evaluated", report.allocation.groupCount),
+        line("Total required omitted", report.allocation.totalRequiredOmitted),
+        line("Total optional omitted", report.allocation.totalOptionalOmitted),
+        line("Groups with required omission", report.allocation.groupsWithRequiredOmission.join(", ") || "(none)"),
+        line("Groups with optional-only omission", report.allocation.groupsWithOptionalOnlyOmission.join(", ") || "(none)"),
+        line("Spillover availability", report.spillover.availability),
+        line("Groups contributing capacity", report.spillover.groupsContributing.join(", ") || "(none)"),
+        line("Groups borrowing capacity", report.spillover.groupsBorrowing.join(", ") || "(none)"),
+        line("Truncation state", report.truncation.state),
+        line("requiredEvidenceLost", report.truncation.requiredEvidenceLost)
+    ].join("\n"));
+    sections.push([
+        "=== 4. Condition coverage ===",
+        line("Availability", report.conditionCoverage.availability),
+        line("Required conditions total", report.conditionCoverage.requiredConditionsTotal),
+        line("Required conditions satisfied", report.conditionCoverage.requiredConditionsSatisfied),
+        line("Required conditions missing", report.conditionCoverage.requiredConditionsMissing.join(", ") || "(none)"),
+        line("Required conditions lost", report.conditionCoverage.requiredConditionsLost.join(", ") || "(none)"),
+        line("Last-witness-loss count", report.conditionCoverage.lastWitnessLossCount)
+    ].join("\n"));
+    sections.push([
+        "=== 5. Producer/readiness agreement ===",
+        renderAgreement("Producer-condition agreement", report.producerConditionAgreement),
+        renderAgreement("requiredEvidenceLost agreement", report.requiredEvidenceLossAgreement),
+        renderAgreement("Producer/readiness relationship", report.producerReadinessAgreement)
+    ].join("\n"));
+    sections.push([
+        "=== 6. Prompt and judge agreement ===",
+        "Note: the orchestrator does not expose a literal upstream promptMode field. stageMayRenderNormalPrompt (a boolean derived from structured blocked-stage evidence) is the bounded substitute used here.",
+        renderAgreement("Readiness/prompt agreement", report.readinessPromptAgreement),
+        renderAgreement("Readiness/expected-judge agreement", report.readinessExpectedJudgeAgreement),
+        renderAgreement("Expected/actual-judge agreement", report.expectedActualJudgeAgreement)
+    ].join("\n"));
+    sections.push([
+        "=== 7. Correction and final-report agreement ===",
+        renderAgreement("Judge/correction agreement", report.judgeCorrectionAgreement),
+        renderAgreement("Judge/final-eligibility agreement", report.judgeFinalEligibilityAgreement),
+        renderAgreement("Eligibility/final-artifact agreement", report.eligibilityFinalArtifactAgreement)
+    ].join("\n"));
+    sections.push(["=== 8. Lifecycle integrity ===", renderAgreement("Lifecycle-integrity agreement", report.lifecycleIntegrityAgreement)].join("\n"));
+    sections.push([
+        "=== 9. Determinism and immutability ===",
+        line("Determinism availability", report.determinism.availability),
+        line("Repeat count", report.determinism.repeatCount),
+        line("Deterministic", report.determinism.deterministic),
+        line("Fixture self-immutable", report.immutability.fixtureSelfImmutable),
+        line("Fixture immutability reason", report.immutability.fixtureImmutabilityReason)
+    ].join("\n"));
+    const allContradictionCounts = [
+        report.producerConditionAgreement,
+        report.requiredEvidenceLossAgreement,
+        report.producerReadinessAgreement,
+        report.readinessPromptAgreement,
+        report.readinessExpectedJudgeAgreement,
+        report.expectedActualJudgeAgreement,
+        report.judgeCorrectionAgreement,
+        report.judgeFinalEligibilityAgreement,
+        report.eligibilityFinalArtifactAgreement,
+        report.lifecycleIntegrityAgreement
+    ].reduce((sum, a) => sum + a.contradictions.totalCount, 0);
+    sections.push([
+        "=== 10. Contradictions and unavailable evidence ===",
+        line("Total contradiction count across all components", allContradictionCounts),
+        line("Unavailable sections", report.limitations.unavailableSections.join(", ") || "(none)")
+    ].join("\n"));
+    sections.push(["=== 11. Limitations ===", ...(report.limitations.notes.length > 0 ? report.limitations.notes.map((n) => `  - ${n}`) : ["  (none)"])].join("\n"));
+    return sections.join("\n\n") + "\n";
+}

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>`;

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

@@ -162,6 +162,73 @@ function renderStrategy(lines, strategy, index) {
     lines.push(fieldLine("Repeat Count", strategy.assurance.repeatCount));
     lines.push("Issues:");
     pushBoundedList(lines, strategy.assurance.issues, (issue) => `${issue.code} run=${issue.runNumber ?? ""} field=${issue.fieldPath ?? ""} ${issue.message}`);
+    if (strategy.producerReadinessBridge) {
+        renderProducerReadinessBridge(lines, strategy.producerReadinessBridge);
+    }
+}
+function renderProducerReadinessSide(lines, label, side) {
+    pushSection(lines, `Producer-Readiness Bridge: ${label}`);
+    if (side === null) {
+        lines.push("- not supplied");
+        return;
+    }
+    pushRatioMetric(lines, "Expected Owner Present", side.ownerEvaluation.expectedOwnerPresent);
+    pushRatioMetric(lines, "Forbidden Owner Present", side.ownerEvaluation.forbiddenOwnerPresent);
+    pushCountMetric(lines, "Owner False Positives", side.ownerEvaluation.falsePositiveCount);
+    pushCountMetric(lines, "Owner False Negatives", side.ownerEvaluation.falseNegativeCount);
+    pushSection(lines, "Truncation Classification");
+    pushBoundedList(lines, side.truncationEvaluation, (t) => `group=${t.groupId} cause=${t.cause} availability=${t.availability} limit=${t.limit} used=${t.used}`);
+    for (const [agreementLabel, agreement] of [
+        ["Packet/Raw Agreement", side.packetAgreement],
+        ["Report/Raw Agreement", side.reportAgreement],
+    ]) {
+        pushSection(lines, agreementLabel);
+        if (agreement === null) {
+            lines.push("- unavailable");
+            continue;
+        }
+        lines.push(`Producer Parity Preserved: ${agreement.upstreamProducerParityPreserved === null ? "unavailable" : agreement.upstreamProducerParityPreserved}`);
+        lines.push("Contradictions:");
+        pushDashList(lines, agreement.contradictions.map((c) => `${c.field}: raw=${sanitizeScalar(c.rawValue)} supplemental=${sanitizeScalar(c.supplementalValue)}`));
+    }
+}
+function renderProducerReadinessBridge(lines, bridge) {
+    pushSection(lines, "Producer-Readiness Bridge");
+    lines.push(fieldLine("Status", bridge.status));
+    if (bridge.status === "not-applicable") {
+        lines.push(fieldLine("Reason", bridge.reason));
+        return;
+    }
+    renderProducerReadinessSide(lines, "Implementation", bridge.implementation);
+    renderProducerReadinessSide(lines, "Test", bridge.testImplementation);
+    pushSection(lines, "Readiness Agreement");
+    if (bridge.readinessAgreement === null) {
+        lines.push("- not supplied");
+    }
+    else {
+        const decision = bridge.readinessAgreement.decisionAgreement;
+        lines.push(fieldLine("Observed Decision", decision.observedDecision));
+        lines.push(fieldLine("Decision Agreement", decision.decisionAgreement));
+        lines.push(fieldLine("Issue-Code Agreement", decision.issueCodesAgreement));
+        lines.push("Observed Issue Codes:");
+        pushDashList(lines, decision.observedIssueCodes);
+        lines.push(fieldLine("Invalid Ready", bridge.readinessAgreement.invalidReady.invalidReady));
+        lines.push(fieldLine("Valid Blocked", bridge.readinessAgreement.validBlocked.validBlocked));
+        lines.push(fieldLine("Valid Refresh-Required", bridge.readinessAgreement.validBlocked.validRefreshRequired));
+    }
+    pushSection(lines, "Criticality Evaluation");
+    if (bridge.criticalityEvaluation === null) {
+        lines.push("- not supplied");
+    }
+    else {
+        pushRatioMetric(lines, "Mapped Critical Completeness", bridge.criticalityEvaluation.mappedCriticalCompleteness);
+        lines.push(`Fully Mapped: ${bridge.criticalityEvaluation.fullyMappedCriticalIds.join(", ") || "none"}`);
+        lines.push(`Partially Mapped: ${bridge.criticalityEvaluation.partiallyMappedCriticalIds.join(", ") || "none"}`);
+        lines.push(`Unmapped: ${bridge.criticalityEvaluation.unmappedCriticalIds.join(", ") || "none"}`);
+        lines.push(`Conflicting: ${bridge.criticalityEvaluation.conflictingCriticalityResponsibilityIds.join(", ") || "none"}`);
+    }
+    pushSection(lines, "Producer-Readiness Bridge Warnings");
+    pushBoundedList(lines, bridge.warnings, (w) => w);
 }
 function renderV043Section(lines, section) {
     if (section === null) {

package/dist/src/securityValidation/packageChecks/requiredPackageContents.js

@@ -0,0 +1,33 @@
+export const REQUIRED_PACKAGE_CONTENTS = [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "dist/scripts/run-final-demo.js",
+    "dist/src/index.js",
+    "package.json",
+];
+function normalizeTarballPath(file) {
+    const normalized = file.replace(/\\/g, "/");
+    return normalized.startsWith("package/")
+        ? normalized.slice("package/".length)
+        : normalized;
+}
+export function detectMissingRequiredContents(options) {
+    const present = new Set(options.files.map(normalizeTarballPath));
+    const required = [...(options.requiredFiles ?? REQUIRED_PACKAGE_CONTENTS)]
+        .map(normalizeTarballPath)
+        .sort((left, right) => left.localeCompare(right));
+    const missing = required.filter((file) => !present.has(file));
+    const findings = missing.map((file, index) => ({
+        id: `${options.checkId}-required-missing-${index}`,
+        title: `Required file missing from npm tarball: package/${file}`,
+        severity: "blocker",
+        category: "package-content",
+        description: `The required release file 'package/${file}' is absent from the npm package inventory`,
+        evidence: `Missing required path: package/${file}`,
+        affectedFiles: [file],
+        recommendation: `Include '${file}' in the package files allowlist or restore the expected build output`,
+        releaseImpact: "Blocker: the npm package is incomplete and must not be published",
+    }));
+    return { missing, findings };
+}

package/dist/src/securityValidation/packageChecks/runPackageChecks.js

@@ -3,6 +3,7 @@ import { runSecurityCommand, resolveNpmCommand } from "../commandRunner.js";
 import { writeCheckResult } from "../artifacts.js";
 import { parseNpmPackDryRun } from "./parseNpmPackDryRun.js";
 import { detectForbiddenContents } from "./forbiddenPackageContents.js";
+import { detectMissingRequiredContents } from "./requiredPackageContents.js";
 // Run npm pack --dry-run and inspect the resulting file list for forbidden contents.
 // Does not publish anything.
 export async function runPackageChecks(options) {
@@ -32,7 +33,12 @@ export async function runPackageChecks(options) {
         allowedExceptions: allowedPackageExceptions,
         checkId: "npm-pack",
     });
-    allFindings.push(...contentFindings);
+    const { findings: missingRequiredFindings } = detectMissingRequiredContents({
+        files: parsed.files,
+        checkId: "npm-pack",
+    });
+    const packageFindings = [...contentFindings, ...missingRequiredFindings];
+    allFindings.push(...packageFindings);
     const packCheck = {
         id: "npm-pack-dry-run",
         name: "npm pack --dry-run (tarball file list)",
@@ -41,18 +47,18 @@ export async function runPackageChecks(options) {
             ? "failed"
             : parsed.parseError && parsed.files.length === 0
                 ? "warning"
-                : contentFindings.length > 0
+                : packageFindings.length > 0
                     ? "failed"
                     : "passed",
-        severity: contentFindings.length > 0
-            ? contentFindings.some((f) => f.severity === "blocker")
+        severity: packageFindings.length > 0
+            ? packageFindings.some((f) => f.severity === "blocker")
                 ? "blocker"
                 : "major"
             : "informational",
         startedAt,
         finishedAt,
         durationMs: cmd.durationMs,
-        findings: contentFindings,
+        findings: packageFindings,
         skippedReason: undefined,
         command: "npm pack --dry-run",
     };

package/docs/METRICS.md

@@ -330,3 +330,114 @@ Every ratio metric below reports `availability` (`available`, `unavailable`, or
   Caveat: reports `unavailable` when no target-immutability configuration was supplied for the run; a configured, unchanged target reports an available count of zero.
 
 Repeated-run determinism (`StageContextDeterminismResultV1` in `src/evaluation/stageContextDeterminism`) reports whether repeated canonical runs (`repeatCount` 1 through 10, run 1 as baseline) produce identical canonicalized run values via SHA-256 digest comparison. A single run reports `not-applicable`; a canonicalization failure (for example a circular reference) reports `unavailable`.
+
+## Producer-readiness bridge metrics (v0.4.4)
+
+Implemented in `src/evaluation/stageContextMetrics` (`calculateOwnerMetrics.ts`, `calculateAllocationMetrics.ts`, `calculateTruncationClassification.ts`, `calculateSupplementalRawAgreement.ts`, `calculateReadinessAgreement.ts`, `calculateCriticalityMetrics.ts`) and composed once per run by `evaluateProducerReadinessBridge.ts`. These metrics read only evidence Batch 1's readers and the existing `v0.4.3` `ContextCapsule`/`RetrievalAuditRecord` readers already preserve; none reimplement upstream owner selection, evidence allocation, producer parity, or orchestrator readiness. Every metric below uses the same `available`/`unavailable`/`not-applicable` availability model as the `v0.4.3` metrics above; unavailable and not-applicable remain distinct from an available zero.
+
+- `selectedOwnerEvidence` / `expectedOwnerPresent` / `forbiddenOwnerPresent` / owner false positives / false negatives
+  Meaning: the owner identities the frozen my-dev-kit producer already selected (`ContextCapsule.selectedOwners`), compared against explicit fixture-declared required/allowed/forbidden owner expectations.
+  Caveat: with no owner expectations declared, all four ratio/count metrics report `not-applicable`, not zero. An owner outside a fixture-declared closed set (or explicitly forbidden) is a false positive only when that closed set or forbidden set actually exists.
+- `requiredGroupCapacity` / `usedReservation` / `borrowedCapacity` / `unusedCapacity`
+  Meaning: per evidence-group allocation facts read directly from `ContextCapsule.evidenceGroups` (`limit`, `usedCount`).
+  Caveat: `borrowedCapacity` always reports `unavailable` — no frozen my-dev-kit artifact field exposes cross-group capacity borrowing. `unusedCapacity` is computed (`limit - usedCount`) only when a limit is declared and the result is non-negative; a negative result reports `unavailable` with a diagnostic reason rather than a negative number.
+- `requiredEvidenceOmitted`
+  Meaning: fixture-required evidence absent from observed evidence.
+  Caveat: `requiredEvidenceOmittedEntries[].groupId` is always `null` under the current expectation model — expectation items do not declare a group, so group linkage cannot be derived without inventing a mapping.
+- Truncation classification (`avoidable` / `genuine-hard-limit` / `unresolved` / `none`)
+  Meaning: classifies each `TruncationRecord` using only `limit`, `used`, and `requiredEvidenceLost`. `avoidable` when required evidence was lost while `used` remained below the declared `limit`; `genuine-hard-limit` when `used` reached or exceeded the limit; `unresolved` when no limit is declared; `none` when no required evidence was lost.
+  Caveat: missing required evidence alone never proves `avoidable` — it requires the authoritative `requiredEvidenceLost` and `limit`/`used` evidence together.
+- Supplemental/raw agreement
+  Meaning: per-field comparison between a Batch 1 supplemental document and the raw `ContextCapsule`/`RetrievalAuditRecord`, limited to fields whose vocabularies are directly, losslessly comparable (canonical repository identity, role, freshness, and truncation-as-yes/no).
+  Caveat: adequacy agreement always reports `unavailable` — my-dev-kit's four-sentence `ContextAdequacyStatus` values have no verified mapping onto the orchestrator's five-slug `DeclaredAdequacy` vocabulary, and none is invented. Missing evidence on one side reports `unavailable`, never a forced contradiction. `upstreamProducerParityPreserved` reflects that a successfully read raw pair is itself observed evidence the frozen `assertRawEvidenceParity()` write-time guard already held — it is never recomputed by comparing fields.
+- Readiness agreement (`decisionAgreement`, `invalidReady`, `validBlocked`)
+  Meaning: compares the observed `OrchestratorContextReadinessResultV1` against an explicit fixture-declared readiness expectation. `invalidReady` is available `true` only when the observed decision is `ready` while the fixture explicitly requires blocking behavior with expected issue codes. `validBlocked` requires the observed decision, allowed decisions, and issue codes to all agree with the fixture.
+  Caveat: with no readiness expectation, all three report `not-applicable`. With no readiness input, all three report `unavailable`. None of these ever call or reimplement the frozen orchestrator's `contextReadiness.ts`.
+- Criticality-overlay agreement / `mappedCriticalCompleteness`
+  Meaning: compares fixture-declared expected criticality per responsibility ID against the `criticality`/`mappingStatus` fields my-dev-kit's own `ResponsibilityMapping` already carries. `mappedCriticalCompleteness` counts only applicable, full-mapping-required, expected-critical responsibilities with resolvable mapping status; partially mapped and unmapped responsibilities never count as complete.
+  Caveat: a responsibility with no matching raw mapping entry reports `unavailable`/`missingMappingEvidenceCriticalIds`, and is excluded from the denominator rather than treated as unmapped. With zero resolvable denominator entries, `mappedCriticalCompleteness` reports `not-applicable`, not an available zero.
+
+No composite score, grade, ranking, or lab-generated readiness verdict is calculated anywhere in this section.
+
+## Context-integrity metrics (v0.4.5)
+
+Implemented in `src/evaluation/stageContextMetrics` and composed once per run by the same `evaluateProducerReadinessBridge.ts` used by the `v0.4.4` metrics above. These metrics read only condition-aware producer evidence mirrored exactly from the published `my-dev-kit` `v1.10.4` contract and run-integrity evidence mirrored exactly from the published `my-dev-kit-orchestrator` `v1.2.3` contract; none reimplement upstream witness-adequacy, allocation, judge, correction, or lifecycle policy. Every metric below uses the same `available`/`unavailable`/`not-applicable` availability model as the `v0.4.3`/`v0.4.4` metrics; agreement-style metrics additionally report one of the shared `AgreementOutcomeV1` values (`agreement`, `contradiction`, `insufficient-evidence`, `unsupported-legacy-evidence`, `not-applicable`), never a lab-derived pass/fail verdict.
+
+**Allocation and spillover** (`calculateAllocationMetrics.ts`, per-group and aggregate over `ContextCapsule.groupTruncation`):
+
+- `requiredGroupCapacity` / `usedReservation` / `unusedCapacity`
+  Meaning: per-group hard limit, used count, and computed unused capacity (`limit - usedCount`) read from `EvidenceGroup`.
+  Caveat: `requiredGroupCapacity`/`unusedCapacity` report `unavailable` when no hard limit is declared; a negative computed remainder is treated as a data inconsistency and reported `unavailable` with a diagnostic reason rather than a negative number.
+- `borrowedCapacity`
+  Meaning: cross-group capacity borrowing.
+  Caveat: always reports `unavailable` — no frozen `my-dev-kit` artifact field exposes cross-group borrowing; this is never inferred from other fields.
+- Per-group allocation fields (`reservation`, `initiallySelectedCount`, `unusedReservationContributed`, `borrowedCapacity`, `governingHardBound`, `requiredOmittedCount`, `optionalOmittedCount`, `adequacyAffected`, `aggregateCapacityUsed`, `aggregateCapacityRemaining`)
+  Meaning: read directly, field-for-field, from each `GroupTruncationEntry`.
+  Caveat: a group entry with none of these additive fields set reports `unavailable` for the whole entry (legacy schema-major-1 evidence), never zero.
+- Aggregate allocation totals (`totalReservation`, `totalInitiallySelected`, `totalUnusedReservationContributed`, `totalBorrowedCapacity`, `totalRequiredOmitted`, `totalOptionalOmitted`, `totalDropped`) and group lists (`groupsContributingUnusedReservation`, `groupsBorrowingCapacity`, `groupsWithRequiredOmission`, `groupsWithOptionalOnlyOmission`, `groupsWithAdequacyAffected`)
+  Meaning: sums and group-ID lists across all evidence groups.
+  Caveat: `not-applicable` when there are no evidence groups; `unavailable` when no group exposes allocation diagnostics; a total is reported `null` (`partial: true`) rather than partially summed when any contributing group lacks a needed field.
+- `requiredEvidenceOmitted`
+  Meaning: fixture-required evidence (from `StageContextExpectationFixtureV1`) missing from observed evidence.
+  Caveat: `groupId` on each omitted-evidence entry is always `null` — expectation items do not declare a group, so group linkage is never invented. `not-applicable` when nothing required is missing.
+- Truncation classification (`avoidable` / `genuine-hard-limit` / `unresolved` / `none`)
+  Meaning: classifies each `TruncationRecord` using only `limit`, `used`, and `requiredEvidenceLost` — unchanged from the `v0.4.4` classification, now composed alongside the `v0.4.5` allocation/spillover evidence.
+- Spillover diagnostics (`groupsContributing`, `groupsBorrowing`, `totalContributed`, `totalBorrowed`, `contributionCoversBorrowing`)
+  Meaning: which groups contributed unused reservation versus borrowed capacity, and whether total contribution covers total borrowing.
+  Caveat: `unavailable` when no group exposes `v1.10.3`/`v1.10.4` allocation diagnostics.
+
+**Condition coverage** (`calculateConditionCoverageMetrics.ts`, over `roleConditionCoverage`):
+
+- `requiredConditionsTotal` / `requiredConditionsSatisfied` / `requiredConditionsMissing` / `requiredConditionsLost`
+  Meaning: counts of required conditions by coverage state — `satisfied` (`conditionSatisfied`), `lost-to-allocation` (`lostRequiredCondition`), or `missing-evidence` (neither).
+- `optionalConditionsTotal` / `optionalConditionsSatisfied` / `optionalConditionsMissing`
+  Meaning: the same breakdown for non-required conditions.
+- `witnessEvidence`
+  Meaning: per-condition witness detail (`witnessPolicy`, `requiredWitnessCount`, `availableWitnessCount`, `retainedWitnessCount`, `retainedWitnessIds`, `adequateWitnessRemains`, `coverageState`, `lossReason`, `evidenceGroupIds`) read directly from each `RoleConditionCoverage` entry.
+  Caveat: retained-witness identifiers are never fabricated from counts alone; only IDs the producer actually supplied are reported.
+- `lastWitnessLossCount`
+  Meaning: count of required conditions that lost their last adequate witness (`lostRequiredCondition`).
+  Caveat: a real, available zero (no last-witness loss) is distinct from `unavailable` (no condition-coverage evidence at all).
+- `conditionToGroupMapping`
+  Meaning: whether each condition's `evidenceGroupIds` reference known evidence groups (`mapped`, `unknownGroupIds`).
+- Overall availability
+  Caveat: the entire metric block reports `unavailable` when `roleConditionCoverage` is absent — this is the expected, documented case for the `v0.4.5` failed-run fixture, which predates condition-level diagnostics (legacy schema-major-1 producer evidence), never treated as an evaluated-empty result.
+
+**Agreement metrics** (comparing producer evidence against itself, and producer evidence against orchestrator run-integrity evidence):
+
+- `producerConditionAgreement`
+  Meaning: compares `roleAdequacy.status` against condition-coverage evidence; flags `PRODUCER_INADEQUATE_BUT_ALL_REQUIRED_CONDITIONS_RETAINED` and `PRODUCER_ADEQUATE_BUT_REQUIRED_CONDITION_LOST` contradictions.
+  Caveat: reports `unsupported-legacy-evidence` (not `contradiction` or `agreement`) when condition-coverage evidence itself is unavailable — this is the case for the failed-run fixture.
+- `requiredEvidenceLossAgreement`
+  Meaning: compares `truncation.requiredEvidenceLost` against explicit condition-loss/required-omission evidence; flags `REQUIRED_EVIDENCE_LOST_FALSE_BUT_CONDITION_LOSS_DETECTED` and `REQUIRED_EVIDENCE_LOST_TRUE_BUT_NO_CONDITION_OR_GROUP_LOSS_DETECTED`.
+- `capsuleAuditConditionAgreement`
+  Meaning: whether the context capsule and retrieval audit record agree on `roleConditionCoverage`, `truncation`, and `roleAdequacy`, using the existing capsule/audit consistency selector.
+- `readinessPromptAgreement`
+  Meaning: compares `gate.readinessClassification` against `stageMayRenderNormalPrompt` (derived from structured blocked-stage evidence — **not** a literal upstream `promptMode` field, which the orchestrator does not expose) for context-sensitive stages (`implementation`, `test-implementation`); flags `READY_BUT_PROMPT_NOT_NORMAL` and `REFRESH_REQUIRED_BUT_PROMPT_NORMAL`.
+  Caveat: `not-applicable` for non-context-sensitive stages.
+- `readinessExpectedJudgeAgreement`
+  Meaning: checks the gate's own `contextReady`/`expectedJudgeVerdict` invariant; flags `CONTEXT_READY_BUT_EXPECTED_NOT_PASS` and `CONTEXT_NOT_READY_BUT_EXPECTED_NOT_NEED_CONTEXT`.
+- `expectedActualJudgeAgreement`
+  Meaning: compares the gate's `expectedJudgeVerdict` against the parsed `authoredJudgeVerdict`; flags malformed/missing judge verdicts and the upstream `JUDGE_VERDICT_CONTRADICTS_RUN_INTEGRITY` code (preserved verbatim when the orchestrator's own `blockingCodes` include it) when an authored `PASS` contradicts a canonical `NEED_CONTEXT` requirement.
+  Caveat: `insufficient-evidence` when no `judgeIntegrity` evidence was supplied. A syntactically valid, accepted verdict that legitimately differs from the expected one (e.g. a correction-route or terminal blocked verdict) is not itself flagged as a contradiction.
+- `judgeCorrectionAgreement`
+  Meaning: checks that a `PASS` verdict has no active correction route, that a corrective verdict requiring correction has one, and that `acceptedCorrectionStage` matches the structured route's `routedStage`; flags `PASS_WITH_ACTIVE_CORRECTION_ROUTE`, `CORRECTIVE_VERDICT_WITHOUT_ROUTE`, and `CORRECTION_DESTINATION_MISMATCH`.
+- `judgeFinalEligibilityAgreement`
+  Meaning: checks that `finalReportEligible` only holds when the authored verdict is `PASS`, parsed, accepted, and matches the expected verdict; flags `ELIGIBLE_WITH_NON_PASS_JUDGE`, `ELIGIBLE_WITH_MALFORMED_OR_MISSING_JUDGE`, `ELIGIBLE_WITH_UNACCEPTED_JUDGE`, and `ELIGIBLE_WITH_UNMATCHED_EXPECTED_VERDICT`.
+- `eligibilityFinalArtifactAgreement`
+  Meaning: checks eligibility against final-artifact presence and verdict; flags `ELIGIBLE_BUT_ARTIFACT_MISSING`, `INELIGIBLE_BUT_ARTIFACT_PRESENT`, `NEED_CONTEXT_FOLLOWED_BY_FINAL_PASS` (or the more general `INELIGIBLE_WITH_FINAL_PASS`), and `FINAL_ARTIFACT_MALFORMED_VERDICT`. This is the metric that surfaces the real historical `v1.11.0` Batch 1 failed-run's contradiction: a `NEED_CONTEXT` gate followed by a final report with verdict `PASS`.
+- `lifecycleIntegrityAgreement`
+  Meaning: per-stage lifecycle entries (`completionBasis`: `not-complete` / `artifact-presence-only` / `manual-record`) checked against expected run-integrity blocking; flags `MANUAL_MARK_COMPLETE_BYPASS_SUCCEEDED` when a stage that should be blocked (by `gate.blockedStageNames` or final-report ineligibility) resolved to `complete` anyway, whether through a manual mark-complete record or artifact presence alone.
+  Caveat: `not-applicable` when no lifecycle evidence was supplied.
+- `endToEndSummary` (`category`: `full-agreement` / `contradiction-present` / `insufficient-evidence` / `unsupported-legacy-evidence`)
+  Meaning: aggregates all component agreement outcomes above (plus `producerReadiness` from the `v0.4.4` bridge) — any contradiction anywhere makes the category `contradiction-present`; otherwise any `insufficient-evidence` or `unsupported-legacy-evidence` component determines the category; only when every component agrees is the category `full-agreement`.
+  Caveat: this is an aggregation of agreement/contradiction state, not a composite score, grade, ranking, or release verdict — no such value is calculated anywhere in this section.
+
+**Fixture assurance:**
+
+- Fixture hash verification (`src/evaluation/ecosystemFixtures/verifyFixtureHashes.ts`)
+  Meaning: SHA-256 comparison of tracked fixture files against the manifest's recorded hashes.
+  Interpretation: `ok: false` means the on-disk fixture bytes no longer match what was frozen; evaluation results built from a failed hash check should not be trusted.
+- Determinism and fixture self-immutability
+  Meaning: reuses `calculateStageContextDeterminism`/`canonicalizeStageContextRun` (`v0.4.3`) to confirm repeated evaluations of the same fixture produce identical canonicalized results, and re-runs fixture hash verification to confirm the frozen bytes were not mutated by evaluation.
+  Caveat: this is fixture-level self-immutability, not the `v0.4.3` live-target-mutation check — no live target repository is exercised by this evaluation path.

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@dailephd/my-dev-kit-lab",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "type": "module",
   "description": "Evidence, benchmark, and evaluation companion for my-dev-kit.",
   "bin": {
     "my-dev-kit-lab": "dist/scripts/run-final-demo.js"
   },
   "files": [
+    "CHANGELOG.md",
     "dist/scripts/",
     "!dist/scripts/docs/",
     "dist/src/",
@@ -72,7 +73,7 @@
     "test:visualization-demos": "vitest run tests/visualizationDemos tests/commands/runVisualizationDemosCommand.spec.ts",
     "verify:benchmarks": "tsx scripts/verify-benchmarks.ts",
     "docs:check": "node scripts/check-docs.mjs",
-    "verify": "npm run build && npm run test && npm run test:benchmarks && npm run test:report && npm run test:screenshot && npm run test:evaluation && npm run test:agents && npm run test:experiments && npm run test:plots && npm run test:visualization-demos && npm run test:gallery && npm run test:demo && npm run test:integration && npm run test:e2e && npm run verify:benchmarks",
+    "verify": "npm run build && npm run verify:benchmarks",
     "security:deps": "tsx scripts/security/runDependencyChecks.ts",
     "security:package": "tsx scripts/security/runPackageChecks.ts",
     "security:codeql": "tsx scripts/security/runCodeql.ts",
@@ -80,7 +81,8 @@
     "test:security": "vitest run tests/security/",
     "test:fuzz:smoke": "tsx scripts/security/runFuzzSmoke.ts",
     "security:validate": "tsx scripts/security/validate.ts",
-    "audit": "tsx scripts/audits/runAudit.ts"
+    "audit": "tsx scripts/audits/runAudit.ts",
+    "report:context-integrity-smoke": "tsx scripts/report-context-integrity-smoke.ts"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/tests/fixtures/ecosystem/context-integrity/v0.4.5/corrected-replay/derived/run-integrity-evidence.json

@@ -0,0 +1,99 @@
+{
+  "_derivationNote": "LAB-DERIVED, not a byte-exact capture. Built for the same run identity/target/index/request shape as ../../failed-run using the exact local my-dev-kit v1.10.4 (commit d09068f) condition-aware contract and the exact local my-dev-kit-orchestrator v1.2.3 (commit 2cb82f0) RunIntegrityGate/JudgeIntegrity/FinalReportEligibility contract, following the same hand-distillation convention the orchestrator's own tests/fixtures/v123-batch4/corrected-run fixture uses (see manifests/corrected-replay-manifest.json for full provenance).",
+  "schemaVersion": "1.0.0",
+  "runFolder": "Z:/Users/newuser/Projects/my-dev-kit-v1/.my-dev-kit-orchestrator/runs/20260730T113740-implement-my-dev-kit-v1-11-0-b",
+  "gate": {
+    "schemaVersion": "1.0.0",
+    "mode": "feature",
+    "contextRequired": true,
+    "applicableContextKinds": ["implementation", "test"],
+    "implementationContext": {
+      "schemaVersion": "1.0.0",
+      "kind": "implementation",
+      "role": "implementation",
+      "decision": "ready",
+      "classification": "ready",
+      "stageId": "stage.feature.implementation",
+      "packetPath": "artifacts/implementation-context-packet.txt",
+      "reportPath": "reports/implementation-context-retrieval-report.txt",
+      "issues": [],
+      "warnings": [],
+      "blockingIssueCodes": [],
+      "affectedResponsibilityIds": [],
+      "evaluatedFreshness": "fresh",
+      "evaluatedAdequacy": "sufficient-with-assumptions",
+      "requiredEvidenceTruncated": "no",
+      "readyWithAssumptions": true,
+      "provenanceSummary": "resolved from the corrected v1.10.4 condition-aware producer contract",
+      "indexIdentity": "Z:/Users/newuser/Projects/my-dev-kit-v1/.my-dev-kit-context/v1.11.0-batch-1-compose-artifact-foundation/implementation"
+    },
+    "contextReady": true,
+    "readinessClassification": "ready",
+    "blockedStageNames": [],
+    "blockingCodes": [],
+    "recommendedCorrectionStage": null,
+    "expectedJudgeVerdict": "PASS",
+    "warnings": []
+  },
+  "judgeIntegrity": {
+    "schemaVersion": "1.0.0",
+    "judgeArtifactPresent": true,
+    "judgeVerdictParseStatus": "parsed",
+    "authoredJudgeVerdict": "PASS",
+    "expectedJudgeVerdict": "PASS",
+    "judgeVerdictMatchesExpected": true,
+    "judgeVerdictAccepted": true,
+    "correctionRequired": false,
+    "correctionBlocked": false,
+    "acceptedCorrectionStage": null,
+    "finalReportEligible": true,
+    "blockingCodes": [],
+    "acceptedCorrectionRoute": null
+  },
+  "finalReportEligibility": {
+    "eligible": true,
+    "contextReady": true,
+    "priorArtifactsValid": true,
+    "judgeIntegrity": {
+      "schemaVersion": "1.0.0",
+      "judgeArtifactPresent": true,
+      "judgeVerdictParseStatus": "parsed",
+      "authoredJudgeVerdict": "PASS",
+      "expectedJudgeVerdict": "PASS",
+      "judgeVerdictMatchesExpected": true,
+      "judgeVerdictAccepted": true,
+      "correctionRequired": false,
+      "correctionBlocked": false,
+      "acceptedCorrectionStage": null,
+      "finalReportEligible": true,
+      "blockingCodes": [],
+      "acceptedCorrectionRoute": null
+    },
+    "blockingCodes": []
+  },
+  "finalArtifactPresent": true,
+  "finalArtifactVerdict": "PASS",
+  "lifecycle": [
+    {
+      "artifactFile": "artifacts/implementation-report.txt",
+      "stageName": "implementation",
+      "fileExists": true,
+      "manualRecord": null,
+      "resolvedState": "complete"
+    },
+    {
+      "artifactFile": "artifacts/test-implementation-report.txt",
+      "stageName": "test-implementation",
+      "fileExists": true,
+      "manualRecord": null,
+      "resolvedState": "complete"
+    },
+    {
+      "artifactFile": "artifacts/final-report.txt",
+      "stageName": "final-report",
+      "fileExists": true,
+      "manualRecord": null,
+      "resolvedState": "complete"
+    }
+  ]
+}