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

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/docs/METRICS.md

@@ -330,3 +330,31 @@ 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dailephd/my-dev-kit-lab",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "type": "module",
   "description": "Evidence, benchmark, and evaluation companion for my-dev-kit.",
   "bin": {
@@ -72,7 +72,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",

package/tests/fixtures/upstream-artifacts/my-dev-kit-1.10.2-identity/PROVENANCE.txt

@@ -0,0 +1,13 @@
+Artifact source: real local my-dev-kit `context` command
+Producer package version: 1.10.2
+Producer CLI version: 1.10.2
+Producer branch: fix/v1.10.3-context-readiness
+Producer base commit: 9f1c7c5392e2dde9a1aae80e330134950e6e101f
+Producer final commit: e2d8c66075036824c8eeb5290b630979ab7cee79
+Context capsule schema version: 1.0.0
+Retrieval audit schema version: 1.0.0
+Source repository: Z:/Users/newuser/Projects/my-dev-kit-orchestrator
+Expected evaluator result: consistent
+Context capsule SHA-256: 2AA664F02A4830D0698FBF6D4C8203F99EE1EA420142EB58A5EDF284ED26EE66
+Retrieval audit SHA-256: 5D5B0129EC3FAF92F87AD58A846EECB930FE6DD2CE66C0D26F5F51CD08879585
+Copy policy: both JSON files are byte-for-byte copies and must not be hand-edited.