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

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);
+}

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/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

@@ -358,3 +358,86 @@ Implemented in `src/evaluation/stageContextMetrics` (`calculateOwnerMetrics.ts`,
   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.4",
+  "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/",
@@ -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"
+    }
+  ]
+}