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

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

@@ -0,0 +1,296 @@
+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((header) => `<th>${escapeHtml(header)}</th>`).join("")}</tr></thead><tbody>${rows
+        .map((row) => `<tr>${row.map((cell) => `<td>${escapeHtml(cell)}</td>`).join("")}</tr>`)
+        .join("")}</tbody></table>`;
+}
+function boundedListNote(list) {
+    return `<p class="muted">Displayed ${list.displayedCount} of ${list.totalCount} (omitted ${list.omittedCount}).</p>`;
+}
+function renderRatioMetricTable(label, metric) {
+    if (metric.availability !== "available") {
+        return `<h4>${escapeHtml(label)}</h4>${table(["Availability", "Reason"], [[metric.availability, metric.reason ?? ""]])}`;
+    }
+    return `<h4>${escapeHtml(label)}</h4>${table(["Availability", "Numerator", "Denominator", "Rate", "Percentage"], [
+        [
+            metric.availability,
+            String(metric.numerator),
+            String(metric.denominator),
+            String(metric.rate),
+            `${String(metric.rate * 100)}%`,
+        ],
+    ])}`;
+}
+function renderCountMetricTable(label, metric) {
+    if (metric.availability !== "available") {
+        return `<h4>${escapeHtml(label)}</h4>${table(["Availability", "Reason"], [[metric.availability, metric.reason ?? ""]])}`;
+    }
+    return `<h4>${escapeHtml(label)}</h4>${table(["Availability", "Count"], [[metric.availability, String(metric.count)]])}`;
+}
+function renderStrategySection(strategy, index) {
+    const artifactRows = strategy.artifacts.items.map((artifact) => [
+        artifact.sourceInstance,
+        artifact.artifactKind,
+        artifact.sourcePath,
+        artifact.schemaVersion,
+        artifact.role ?? "",
+    ]);
+    const executionIssueRows = strategy.execution.issues.items.map((issue) => [
+        issue.code,
+        issue.fieldPath ?? "",
+        issue.message,
+    ]);
+    const expectationMatchRows = strategy.evaluation.expectationMatches.items.map((match) => [
+        match.expectationId,
+        match.inclusion,
+        match.sourceArtifact,
+        match.category,
+        match.targetKey,
+        match.outcome,
+    ]);
+    const observedEvidenceRows = strategy.evaluation.observedEvidence.items.map((evidence) => [
+        evidence.sourceArtifact,
+        evidence.sourceInstance,
+        evidence.category,
+        evidence.targetKey,
+        evidence.sourceFieldPath,
+    ]);
+    const metricsHtml = strategy.evaluation.metrics
+        ? `
+    ${renderRatioMetricTable("Required Evidence Recall", strategy.evaluation.metrics.requiredEvidenceRecall)}
+    ${renderRatioMetricTable("Allowed Evidence Coverage", strategy.evaluation.metrics.allowedEvidenceCoverage)}
+    ${renderRatioMetricTable("Forbidden Evidence Inclusion", strategy.evaluation.metrics.forbiddenEvidenceInclusion)}
+    ${renderCountMetricTable("Irrelevant File Inclusion", strategy.evaluation.metrics.irrelevantFileInclusion)}
+    ${renderCountMetricTable("Irrelevant Instruction Inclusion", strategy.evaluation.metrics.irrelevantInstructionInclusion)}
+    ${renderRatioMetricTable("Required Provenance Recall", strategy.evaluation.metrics.requiredProvenanceRecall)}
+    ${renderCountMetricTable("Considered But Unselected Reads", strategy.evaluation.metrics.consideredButUnselectedReads)}
+    ${renderCountMetricTable("Unnecessary Reads", strategy.evaluation.metrics.unnecessaryReads)}
+    ${renderCountMetricTable("Target Immutability (Evaluation)", strategy.evaluation.metrics.targetImmutability)}
+    <h4>Responsibility Mapping</h4>
+    ${boundedListNote(strategy.evaluation.metrics.responsibilityMappingCompleteness)}
+    ${table(["Source", "Instance", "Requested", "Operational", "Mapped", "Partially Mapped", "Unmapped", "Not Applicable", "Denominator", "Mapped Rate"], strategy.evaluation.metrics.responsibilityMappingCompleteness.items.map((mapping) => [
+            mapping.sourceArtifact,
+            mapping.sourceInstance,
+            String(mapping.requested),
+            String(mapping.operational),
+            String(mapping.mappedCount),
+            String(mapping.partiallyMappedCount),
+            String(mapping.unmappedCount),
+            String(mapping.notApplicableCount),
+            String(mapping.denominator),
+            String(mapping.mappedRate),
+        ]))}
+    <h4>State Comparisons</h4>
+    ${boundedListNote(strategy.evaluation.metrics.stateComparisons)}
+    ${table(["Source", "Instance", "Expectation Field", "Artifact Field", "Availability", "Expected", "Actual", "Matched"], strategy.evaluation.metrics.stateComparisons.items.map((comparison) => [
+            comparison.sourceArtifact,
+            comparison.sourceInstance,
+            comparison.expectationFieldPath,
+            comparison.artifactFieldPath ?? "",
+            comparison.availability,
+            JSON.stringify(comparison.expected),
+            JSON.stringify(comparison.actual),
+            String(comparison.matched),
+        ]))}
+    <h4>Context Size</h4>
+    ${table(["Total Characters", "Total Estimated Tokens", "Formula"], [[
+                String(strategy.evaluation.metrics.contextSize.totalCharacterCount),
+                String(strategy.evaluation.metrics.contextSize.totalEstimatedTokenCount),
+                strategy.evaluation.metrics.contextSize.tokenEstimateFormula,
+            ]])}
+    ${boundedListNote(strategy.evaluation.metrics.contextSize.sources)}
+    ${table(["Instance", "Kind", "Characters", "Estimated Tokens"], strategy.evaluation.metrics.contextSize.sources.items.map((source) => [
+            source.sourceInstance,
+            source.sourceKind,
+            String(source.characterCount),
+            String(source.estimatedTokenCount),
+        ]))}`
+        : "<p>Metrics unavailable.</p>";
+    const targetImmutabilityRows = strategy.assurance.runRecords.items.map((record) => [
+        String(record.runNumber),
+        record.targetImmutabilityAvailability,
+        record.targetImmutabilityStatus ?? "",
+        record.newMutationCount === null ? "unavailable" : String(record.newMutationCount),
+        record.targetImmutabilityReason ?? "",
+    ]);
+    const mutationRows = strategy.assurance.runRecords.items.flatMap((record) => record.mutations.items.map((mutation) => [
+        String(record.runNumber),
+        mutation.id,
+        mutation.kind,
+        mutation.fieldPath,
+        JSON.stringify(mutation.before),
+        JSON.stringify(mutation.after),
+    ]));
+    const determinism = strategy.assurance.determinism;
+    const determinismRows = determinism.availability === "available"
+        ? [
+            [
+                determinism.availability,
+                String(determinism.repeatCount),
+                String(determinism.deterministic),
+                determinism.baselineSha256 ?? "",
+                determinism.mismatchRunNumbers.join(", "),
+            ],
+        ]
+        : [[determinism.availability, String(determinism.repeatCount), "", "", determinism.reason ?? ""]];
+    const assuranceIssueRows = strategy.assurance.issues.items.map((issue) => [
+        issue.code,
+        issue.runNumber === null ? "" : String(issue.runNumber),
+        issue.fieldPath ?? "",
+        issue.message,
+    ]);
+    return `
+  <section>
+    <h3>Strategy ${index + 1}: ${escapeHtml(strategy.strategyId)}</h3>
+
+    <h4>Artifacts</h4>
+    ${boundedListNote(strategy.artifacts)}
+    ${table(["Instance", "Kind", "Path", "Schema", "Role"], artifactRows)}
+
+    <h4>Execution</h4>
+    ${table(["Status"], [[strategy.execution.status]])}
+    ${boundedListNote(strategy.execution.issues)}
+    ${table(["Code", "Field Path", "Message"], executionIssueRows)}
+
+    <h4>Evaluation</h4>
+    ${table(["Status", "Reason"], [[strategy.evaluation.status, strategy.evaluation.reason ?? ""]])}
+    ${metricsHtml}
+
+    <h4>Expectation Matches</h4>
+    ${boundedListNote(strategy.evaluation.expectationMatches)}
+    ${table(["Expectation ID", "Inclusion", "Source Artifact", "Category", "Target Key", "Outcome"], expectationMatchRows)}
+
+    <h4>Observed Evidence</h4>
+    ${boundedListNote(strategy.evaluation.observedEvidence)}
+    ${table(["Source Artifact", "Instance", "Category", "Target Key", "Source Field Path"], observedEvidenceRows)}
+
+    <h4>Target Immutability</h4>
+    ${boundedListNote(strategy.assurance.runRecords)}
+    ${table(["Run", "Availability", "Status", "New Mutation Count", "Reason"], targetImmutabilityRows)}
+    ${table(["Run", "Mutation ID", "Kind", "Field Path", "Before", "After"], mutationRows)}
+
+    <h4>Repeated-Run Determinism</h4>
+    ${table(["Availability", "Repeat Count", "Deterministic", "Baseline SHA-256", "Mismatch Run Numbers / Reason"], determinismRows)}
+    ${determinism.availability === "available" ? boundedListNote(determinism.runDigests) : ""}
+    ${determinism.availability === "available"
+        ? table(["Run", "SHA-256"], determinism.runDigests.items.map((digest) => [String(digest.runNumber), digest.sha256]))
+        : ""}
+
+    <h4>Run Assurance</h4>
+    ${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>`;
+    }
+    if (report.summary.strategyCount === 0) {
+        return `<section><h2>V0.4.3 Stage-Context Evidence</h2><p>No v0.4.3 stage-context strategies were selected.</p></section>`;
+    }
+    const summaryRows = [
+        [
+            String(report.summary.strategyCount),
+            String(report.summary.completedExecutionCount),
+            String(report.summary.invalidInputExecutionCount),
+            String(report.summary.failedExecutionCount),
+            String(report.summary.completedEvaluationCount),
+            String(report.summary.notApplicableEvaluationCount),
+            String(report.summary.failedEvaluationCount),
+            String(report.summary.passedAssuranceCount),
+            String(report.summary.failedAssuranceCount),
+            String(report.summary.notApplicableAssuranceCount),
+        ],
+    ];
+    return `
+<section>
+  <h2>V0.4.3 Stage-Context Evidence</h2>
+  ${table([
+        "Strategies",
+        "Completed Executions",
+        "Invalid-Input Executions",
+        "Failed Executions",
+        "Completed Evaluations",
+        "Not-Applicable Evaluations",
+        "Failed Evaluations",
+        "Passed Assurance",
+        "Failed Assurance",
+        "Not-Applicable Assurance",
+    ], summaryRows)}
+  <p>${escapeHtml(report.interpretation.summary)}</p>
+  <ul>
+    ${report.interpretation.limitations.map((limitation) => `<li>${escapeHtml(limitation)}</li>`).join("")}
+  </ul>
+  ${report.strategies.map((strategy, index) => renderStrategySection(strategy, index)).join("")}
+</section>`;
+}

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

@@ -1,3 +1,4 @@
+import { renderContextStrategyComparisonV043Html } from "./renderContextStrategyComparisonV043Html.js";
 export function renderPluginExperimentReportHtml(report) {
     return `<!DOCTYPE html>
 <html lang="en">
@@ -93,6 +94,8 @@ export function renderPluginExperimentReportHtml(report) {
     ]))}
   </section>
 
+  ${renderContextStrategyComparisonV043Html(report.contextStrategyComparisonV043)}
+
   <section>
     <h2>Warnings, Skips, And Failures</h2>
     ${report.findings.length ? table(["Severity", "Code", "Message", "Variant", "Case"], report.findings.map((finding) => [

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

@@ -0,0 +1,292 @@
+function sanitizeScalar(value) {
+    const text = String(value);
+    let result = "";
+    for (const ch of text) {
+        const code = ch.codePointAt(0) ?? 0;
+        if (code === 13 || code === 10 || code === 9) {
+            result += " ";
+            continue;
+        }
+        if (code <= 8)
+            continue;
+        if (code === 11 || code === 12)
+            continue;
+        if (code >= 14 && code <= 31)
+            continue;
+        if (code === 127)
+            continue;
+        result += ch;
+    }
+    return result;
+}
+function fieldLine(label, value) {
+    if (value === null || value === undefined)
+        return `${label}: unavailable`;
+    return `${label}: ${sanitizeScalar(value)}`;
+}
+function pushSection(lines, title) {
+    lines.push(title);
+}
+function pushDashList(lines, items) {
+    if (items.length === 0) {
+        lines.push("- none");
+        return;
+    }
+    for (const item of items) {
+        lines.push(`- ${sanitizeScalar(item)}`);
+    }
+}
+function pushBoundedList(lines, list, renderItem) {
+    lines.push(`Displayed: ${list.displayedCount} of ${list.totalCount}`);
+    lines.push(`Omitted: ${list.omittedCount}`);
+    if (list.totalCount === 0) {
+        lines.push("- none");
+        return;
+    }
+    for (const item of list.items) {
+        lines.push(`- ${sanitizeScalar(renderItem(item))}`);
+    }
+}
+function pushRatioMetric(lines, label, metric) {
+    lines.push(label);
+    lines.push(`Availability: ${metric.availability}`);
+    if (metric.availability === "available") {
+        lines.push(`Numerator: ${metric.numerator}`);
+        lines.push(`Denominator: ${metric.denominator}`);
+        lines.push(`Rate: ${metric.rate}`);
+        lines.push(`Percentage: ${String(metric.rate * 100)}%`);
+    }
+    else {
+        lines.push(`Reason: ${sanitizeScalar(metric.reason ?? "")}`);
+    }
+    lines.push("Matched Expectation IDs:");
+    pushBoundedList(lines, metric.matchedExpectationIds, (id) => id);
+    lines.push("Missing Expectation IDs:");
+    pushBoundedList(lines, metric.missingExpectationIds, (id) => id);
+}
+function pushCountMetric(lines, label, metric) {
+    lines.push(label);
+    lines.push(`Availability: ${metric.availability}`);
+    if (metric.availability === "available") {
+        lines.push(`Count: ${metric.count}`);
+    }
+    else {
+        lines.push(`Reason: ${sanitizeScalar(metric.reason ?? "")}`);
+    }
+    lines.push("Evidence Keys:");
+    pushBoundedList(lines, metric.evidenceKeys, (key) => key);
+}
+function renderStrategy(lines, strategy, index) {
+    pushSection(lines, `Strategy ${index + 1}: ${strategy.strategyId}`);
+    pushSection(lines, "Artifacts");
+    pushBoundedList(lines, strategy.artifacts, (artifact) => `${artifact.sourceInstance} [${artifact.artifactKind}] path=${artifact.sourcePath} schema=${artifact.schemaVersion}`);
+    pushSection(lines, "Execution");
+    lines.push(fieldLine("Status", strategy.execution.status));
+    lines.push("Issues:");
+    pushBoundedList(lines, strategy.execution.issues, (issue) => `${issue.code} ${issue.fieldPath ?? ""} ${issue.message}`);
+    pushSection(lines, "Evaluation Metrics");
+    lines.push(fieldLine("Status", strategy.evaluation.status));
+    lines.push(fieldLine("Reason", strategy.evaluation.reason));
+    lines.push("Warnings:");
+    pushBoundedList(lines, strategy.evaluation.warnings, (warning) => warning);
+    if (strategy.evaluation.metrics) {
+        const metrics = strategy.evaluation.metrics;
+        pushRatioMetric(lines, "Required Evidence Recall", metrics.requiredEvidenceRecall);
+        pushRatioMetric(lines, "Allowed Evidence Coverage", metrics.allowedEvidenceCoverage);
+        pushRatioMetric(lines, "Forbidden Evidence Inclusion", metrics.forbiddenEvidenceInclusion);
+        pushCountMetric(lines, "Irrelevant File Inclusion", metrics.irrelevantFileInclusion);
+        pushCountMetric(lines, "Irrelevant Instruction Inclusion", metrics.irrelevantInstructionInclusion);
+        pushRatioMetric(lines, "Required Provenance Recall", metrics.requiredProvenanceRecall);
+        pushCountMetric(lines, "Considered But Unselected Reads", metrics.consideredButUnselectedReads);
+        pushCountMetric(lines, "Unnecessary Reads", metrics.unnecessaryReads);
+        pushCountMetric(lines, "Target Immutability (Evaluation)", metrics.targetImmutability);
+    }
+    pushSection(lines, "Expectation Matches");
+    pushBoundedList(lines, strategy.evaluation.expectationMatches, (match) => `${match.expectationId} inclusion=${match.inclusion} outcome=${match.outcome} sourceArtifact=${match.sourceArtifact} targetKey=${match.targetKey}`);
+    pushSection(lines, "Observed Evidence");
+    pushBoundedList(lines, strategy.evaluation.observedEvidence, (evidence) => `${evidence.sourceArtifact}.${evidence.sourceInstance} category=${evidence.category} targetKey=${evidence.targetKey} field=${evidence.sourceFieldPath}`);
+    pushSection(lines, "State Comparisons");
+    if (strategy.evaluation.metrics) {
+        pushBoundedList(lines, strategy.evaluation.metrics.stateComparisons, (comparison) => `${comparison.sourceArtifact}.${comparison.sourceInstance} expectationFieldPath=${comparison.expectationFieldPath} artifactFieldPath=${comparison.artifactFieldPath ?? "null"} availability=${comparison.availability} expected=${JSON.stringify(comparison.expected)} actual=${JSON.stringify(comparison.actual)} matched=${comparison.matched}`);
+    }
+    else {
+        lines.push("Displayed: 0 of 0");
+        lines.push("Omitted: 0");
+        lines.push("- none");
+    }
+    pushSection(lines, "Responsibility Mapping");
+    if (strategy.evaluation.metrics) {
+        pushBoundedList(lines, strategy.evaluation.metrics.responsibilityMappingCompleteness, (mapping) => `${mapping.sourceArtifact}.${mapping.sourceInstance} requested=${mapping.requested} operational=${mapping.operational} mapped=${mapping.mappedCount} partiallyMapped=${mapping.partiallyMappedCount} unmapped=${mapping.unmappedCount} notApplicable=${mapping.notApplicableCount} denominator=${mapping.denominator} mappedRate=${mapping.mappedRate}`);
+    }
+    else {
+        lines.push("Displayed: 0 of 0");
+        lines.push("Omitted: 0");
+        lines.push("- none");
+    }
+    pushSection(lines, "Context Size");
+    if (strategy.evaluation.metrics) {
+        const size = strategy.evaluation.metrics.contextSize;
+        lines.push(fieldLine("Total Character Count", size.totalCharacterCount));
+        lines.push(fieldLine("Total Estimated Token Count (estimate)", size.totalEstimatedTokenCount));
+        lines.push(fieldLine("Token Estimate Formula", size.tokenEstimateFormula));
+        pushBoundedList(lines, size.sources, (source) => `${source.sourceInstance} kind=${source.sourceKind} characters=${source.characterCount} estimatedTokens=${source.estimatedTokenCount}`);
+    }
+    else {
+        lines.push("Displayed: 0 of 0");
+        lines.push("Omitted: 0");
+        lines.push("- none");
+    }
+    pushSection(lines, "Target Immutability");
+    pushBoundedList(lines, strategy.assurance.runRecords, (record) => {
+        if (record.targetImmutabilityAvailability === "unavailable") {
+            return `run=${record.runNumber} availability=unavailable reason=${record.targetImmutabilityReason ?? ""}`;
+        }
+        return `run=${record.runNumber} availability=available status=${record.targetImmutabilityStatus} newMutationCount=${record.newMutationCount} mutations=${record.mutations.totalCount}`;
+    });
+    pushSection(lines, "Repeated-Run Determinism");
+    const determinism = strategy.assurance.determinism;
+    lines.push(fieldLine("Availability", determinism.availability));
+    lines.push(fieldLine("Repeat Count", determinism.repeatCount));
+    if (determinism.availability === "available") {
+        lines.push(fieldLine("Deterministic", determinism.deterministic));
+        lines.push(fieldLine("Baseline SHA-256", determinism.baselineSha256));
+        lines.push("Run Digests:");
+        pushBoundedList(lines, determinism.runDigests, (digest) => `run=${digest.runNumber} sha256=${digest.sha256}`);
+        lines.push(`Mismatch Run Numbers: ${determinism.mismatchRunNumbers.join(", ") || "none"}`);
+    }
+    else {
+        lines.push(fieldLine("Reason", determinism.reason));
+    }
+    pushSection(lines, "Run Assurance");
+    lines.push(fieldLine("Status", strategy.assurance.status));
+    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) {
+        lines.push("Not applicable to this plugin.");
+        return;
+    }
+    if (section.summary.strategyCount === 0) {
+        lines.push("No v0.4.3 stage-context strategies were selected.");
+        return;
+    }
+    lines.push(fieldLine("Strategy Count", section.summary.strategyCount));
+    lines.push(fieldLine("Completed Executions", section.summary.completedExecutionCount));
+    lines.push(fieldLine("Invalid-Input Executions", section.summary.invalidInputExecutionCount));
+    lines.push(fieldLine("Failed Executions", section.summary.failedExecutionCount));
+    lines.push(fieldLine("Completed Evaluations", section.summary.completedEvaluationCount));
+    lines.push(fieldLine("Not-Applicable Evaluations", section.summary.notApplicableEvaluationCount));
+    lines.push(fieldLine("Failed Evaluations", section.summary.failedEvaluationCount));
+    lines.push(fieldLine("Passed Assurance", section.summary.passedAssuranceCount));
+    lines.push(fieldLine("Failed Assurance", section.summary.failedAssuranceCount));
+    lines.push(fieldLine("Not-Applicable Assurance", section.summary.notApplicableAssuranceCount));
+    lines.push(fieldLine("Interpretation Summary", section.interpretation.summary));
+    lines.push("Limitations:");
+    pushDashList(lines, section.interpretation.limitations);
+    for (let index = 0; index < section.strategies.length; index += 1) {
+        renderStrategy(lines, section.strategies[index], index);
+    }
+}
+export function renderPluginExperimentReportText(report) {
+    const lines = [];
+    pushSection(lines, "Plugin Experiment Report");
+    pushSection(lines, "Report Metadata");
+    lines.push(fieldLine("Generated At", report.metadata.generatedAt));
+    lines.push(fieldLine("Run ID", report.metadata.runId));
+    lines.push(fieldLine("Started At", report.metadata.startedAt));
+    lines.push(fieldLine("Completed At", report.metadata.completedAt));
+    lines.push(fieldLine("Status", report.metadata.status));
+    lines.push(fieldLine("Output Root", report.metadata.outputRoot));
+    pushSection(lines, "Plugin And Target");
+    lines.push(fieldLine("Plugin ID", report.plugin.id));
+    lines.push(fieldLine("Plugin Name", report.plugin.name));
+    lines.push(fieldLine("Plugin Schema Version", report.plugin.schemaVersion));
+    lines.push(fieldLine("Mode", report.target.mode));
+    lines.push(fieldLine("Tool Root", report.target.toolRoot));
+    lines.push(fieldLine("Target Root", report.target.targetRoot));
+    pushSection(lines, "Interpretation");
+    lines.push(fieldLine("Summary", report.interpretation.summary));
+    lines.push(fieldLine("Recommended Next Step", report.interpretation.recommendedNextStep));
+    pushSection(lines, "Variants");
+    pushDashList(lines, report.variants.map((variant) => `${variant.name} (${variant.id}) completed=${variant.completedOutcomes} partial=${variant.partialOutcomes} failed=${variant.failedOutcomes} skipped=${variant.skippedOutcomes}`));
+    pushSection(lines, "Cases");
+    pushDashList(lines, report.cases.map((experimentCase) => `${experimentCase.name} (${experimentCase.id}) status=${experimentCase.status} completed=${experimentCase.completedOutcomes} partial=${experimentCase.partialOutcomes} failed=${experimentCase.failedOutcomes} skipped=${experimentCase.skippedOutcomes}`));
+    pushSection(lines, "Metrics");
+    pushDashList(lines, report.metrics.map((metric) => `${metric.name} (${metric.id}) value=${metric.value ?? "unavailable"} unit=${metric.unit ?? ""}`));
+    pushSection(lines, "V0.4.3 Stage-Context Evidence");
+    renderV043Section(lines, report.contextStrategyComparisonV043);
+    pushSection(lines, "Warnings, Skips, And Failures");
+    pushDashList(lines, report.findings.map((finding) => `${finding.severity} ${finding.code} ${finding.message} variant=${finding.variantId ?? ""} case=${finding.caseId ?? ""}`));
+    pushSection(lines, "Artifacts");
+    pushDashList(lines, report.artifacts.map((artifact) => `${artifact.label} (${artifact.id}) kind=${artifact.kind} path=${artifact.path ?? ""}`));
+    return `${lines.join("\n")}\n`;
+}

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

@@ -3,6 +3,7 @@ import path from "node:path";
 import { resolveWithinRoot } from "../../core/pathSafety.js";
 import { buildPluginExperimentReport } from "./buildPluginExperimentReport.js";
 import { renderPluginExperimentReportHtml } from "./renderPluginExperimentReportHtml.js";
+import { renderPluginExperimentReportText } from "./renderPluginExperimentReportText.js";
 export async function writePluginExperimentReports(args) {
     const rawOutDir = args.outputRoot ?? readString(args.run.metadata?.outputRoot);
     if (!rawOutDir) {
@@ -13,6 +14,7 @@ export async function writePluginExperimentReports(args) {
         outDir,
         jsonPath: resolveWithinRoot(outDir, "report.json"),
         htmlPath: resolveWithinRoot(outDir, "report.html"),
+        textPath: resolveWithinRoot(outDir, "report.txt"),
     };
     await mkdir(outputPaths.outDir, { recursive: true });
     const report = buildPluginExperimentReport({
@@ -23,6 +25,7 @@ export async function writePluginExperimentReports(args) {
     });
     await writeFile(outputPaths.jsonPath, `${JSON.stringify({ report, outputPaths }, null, 2)}\n`, "utf8");
     await writeFile(outputPaths.htmlPath, renderPluginExperimentReportHtml(report), "utf8");
+    await writeFile(outputPaths.textPath, renderPluginExperimentReportText(report), "utf8");
     return { report, outputPaths };
 }
 function readString(value) {