@dailephd/my-dev-kit-lab 0.6.2 → 0.7.0

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

@@ -0,0 +1,84 @@
+import { CONTEXT_WINDOW_SCALING_PLUGIN_ID } from "../../experiments/plugins/contextWindowScaling/metadata.js";
+import { CONTEXT_WINDOW_SCALING_REPORT_SCHEMA_VERSION, MAX_REPORT_OMITTED_RELEVANT_FILES, } from "./contextWindowScalingReportModel.js";
+/** Fixed wording; the report states observed evidence only and never ranks treatments. */
+export const CONTEXT_WINDOW_SCALING_INTERPRETATION = [
+    "Estimated context tokens use the Lab deterministic heuristic (characters divided by four, rounded up); they are not provider billing telemetry or a provider model tokenizer result.",
+    "The configured budgets are experiment budgets, not claims about actual provider model context-window limits.",
+    "context-too-large is an expected measurement state under a budget and is not an operational execution failure.",
+    "When a context is too large for a budget, evaluation did not occur, so correctness is unavailable; unavailable correctness is not zero and is excluded from mean correctness.",
+    "Success combines context fit with the existing deterministic correctness pass evidence: success is true only when the context fits and correctness passes.",
+    "context-too-large is an available, not-successful outcome for the applicable budget and remains in the success-rate denominator.",
+    "Operational or evidence-unavailable cells are excluded from the success-rate denominator and are counted separately.",
+    "Omitted relevant files are benchmark-expected files that were not observed in the treatment's context provenance.",
+    "Omitted relevant files are not full retrieval precision or recall; no precision, recall, or irrelevant-context measure is calculated.",
+    "The deterministic fake-agent correctness path is context-independent in the current harness: correctness tests the existing answer-key and evaluation pipeline, not semantic model sensitivity to different context content.",
+    "Utilization is estimated context tokens divided by the budget, is not capped at 100 percent, and may exceed 100 for a context that is too large.",
+    "No composite score, winner, or ranking is calculated; the treatments are reported side by side.",
+];
+/**
+ * Presents the aggregate and cell evidence already calculated on the run. It performs no fit,
+ * success, correctness, or utilization calculation of its own.
+ */
+export function buildContextWindowScalingReport(run) {
+    if (run.pluginId !== CONTEXT_WINDOW_SCALING_PLUGIN_ID)
+        return null;
+    const candidate = run;
+    const evidence = candidate.executionEvidence;
+    const aggregate = candidate.aggregate;
+    if (!evidence || !aggregate) {
+        throw new Error("Invalid context-window-scaling report source: execution evidence and aggregate are required.");
+    }
+    if (aggregate.caseTreatmentContextSummaries.length !== evidence.length * aggregate.treatments.length) {
+        throw new Error("Invalid context-window-scaling report source: aggregate and execution evidence are inconsistent.");
+    }
+    const caseTreatmentContexts = aggregate.caseTreatmentContextSummaries.map((summary) => {
+        const relevant = summary.relevantFileEvidence;
+        return {
+            caseId: summary.caseId,
+            caseName: summary.caseName,
+            variantId: summary.variantId,
+            contextStatus: summary.contextStatus,
+            characterCount: summary.characterCount,
+            estimatedTokens: summary.estimatedTokens,
+            tokenCountMethod: summary.tokenCountMethod,
+            observedFileCount: summary.observedFileCount,
+            relevantFileStatus: relevant.status,
+            expectedRelevantFileCount: relevant.expectedRelevantFileCount,
+            observedExpectedFileCount: relevant.observedExpectedFileCount,
+            omittedRelevantFileCount: relevant.omittedRelevantFileCount,
+            omittedRelevantFiles: boundedList(relevant.omittedRelevantFiles),
+            relevantFileReason: relevant.reason,
+        };
+    });
+    const caseBudgetCells = evidence.flatMap((caseEvidence) => caseEvidence.treatments.flatMap((treatment) => treatment.budgetCells.map((cell) => ({
+        caseId: caseEvidence.caseId,
+        variantId: treatment.variantId,
+        contextEstimatedTokens: treatment.context.estimatedTokens,
+        ...structuredClone(cell),
+    }))));
+    return {
+        schemaVersion: CONTEXT_WINDOW_SCALING_REPORT_SCHEMA_VERSION,
+        budgets: [...aggregate.budgets],
+        treatments: [...aggregate.treatments],
+        tokenCountMethod: firstTokenCountMethod(aggregate.caseTreatmentContextSummaries.map((summary) => summary.tokenCountMethod)),
+        runSummary: { ...aggregate.runSummary },
+        budgetTreatmentSummaries: aggregate.budgetTreatmentSummaries.map((summary) => ({ ...summary })),
+        caseTreatmentContexts,
+        caseBudgetCells,
+        relevantFileSummary: { ...aggregate.relevantFileSummary },
+        interpretation: [...CONTEXT_WINDOW_SCALING_INTERPRETATION],
+    };
+}
+function boundedList(items) {
+    const displayed = items.slice(0, MAX_REPORT_OMITTED_RELEVANT_FILES);
+    return {
+        totalCount: items.length,
+        displayedCount: displayed.length,
+        omittedCount: items.length - displayed.length,
+        truncated: items.length > displayed.length,
+        items: [...displayed],
+    };
+}
+function firstTokenCountMethod(methods) {
+    return methods.find((method) => method !== null) ?? null;
+}

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

@@ -0,0 +1,33 @@
+// Dispatches the incremental-change-staleness plugin report by the persisted execution artifact's
+// schemaVersion: V1 artifacts keep the released V1 report semantics untouched (the V1 builder is called
+// as-is), V2 artifacts select the four-treatment V2 model. Historical V1 evidence is never converted.
+import { readFileSync } from "node:fs";
+import { INCREMENTAL_CHANGE_STALENESS_EXECUTION_SCHEMA_VERSION } from "../../experiments/plugins/incrementalChangeStaleness/executionArtifact.js";
+import { INCREMENTAL_CHANGE_STALENESS_EXECUTION_SCHEMA_VERSION_V2 } from "../../experiments/plugins/incrementalChangeStaleness/executionArtifactV2.js";
+import { INCREMENTAL_CHANGE_STALENESS_PLUGIN_ID } from "../../experiments/plugins/incrementalChangeStaleness/plugin.js";
+import { buildIncrementalChangeStalenessReport, readArtifactPath } from "./buildIncrementalChangeStalenessReport.js";
+import { buildIncrementalChangeStalenessReportV2FromArtifact } from "./buildIncrementalChangeStalenessReportV2.js";
+export function buildIncrementalChangeStalenessPluginReport(run) {
+    if (run.pluginId !== INCREMENTAL_CHANGE_STALENESS_PLUGIN_ID)
+        return null;
+    const artifactPath = readArtifactPath(run);
+    if (!artifactPath)
+        return buildIncrementalChangeStalenessReport(run); // throws the established missing-path error
+    let schemaVersion;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(artifactPath, "utf8"));
+        schemaVersion = parsed?.schemaVersion;
+    }
+    catch {
+        // Unreadable or malformed: the V1 builder owns the established, explicit error messages.
+        return buildIncrementalChangeStalenessReport(run);
+    }
+    if (schemaVersion === INCREMENTAL_CHANGE_STALENESS_EXECUTION_SCHEMA_VERSION_V2) {
+        return buildIncrementalChangeStalenessReportV2FromArtifact(parsed);
+    }
+    if (schemaVersion === INCREMENTAL_CHANGE_STALENESS_EXECUTION_SCHEMA_VERSION) {
+        return buildIncrementalChangeStalenessReport(run);
+    }
+    throw new Error(`Invalid incremental-change-staleness report source: unsupported execution artifact schema version ${String(schemaVersion)}.`);
+}

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

@@ -74,7 +74,7 @@ function toReportScenario(record) {
         comparison: { ...record.comparison, reasonCodes: [...record.comparison.reasonCodes] }
     };
 }
-function readArtifactPath(run) {
+export function readArtifactPath(run) {
     const fromMetadata = run.metadata?.executionArtifactPath;
     if (typeof fromMetadata === "string" && fromMetadata)
         return fromMetadata;

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

@@ -0,0 +1,80 @@
+// v0.6.3 -- projects the persisted V2 incremental-change-staleness execution artifact into the V2 report
+// model. A deterministic projection only: no retrieval, fake-agent evaluation, correctness scoring,
+// affected-neighborhood assessment, freshness assessment, refresh-realization or classification
+// recomputation, and no source/index/benchmark reads. The only integrity check is the artifact's own
+// contradiction validator, so a hand-edited or corrupted artifact is rejected rather than presented.
+import { validateIncrementalChangeStalenessScenarioRecordV2 } from "../../experiments/plugins/incrementalChangeStaleness/executionArtifactV2.js";
+import { INCREMENTAL_CHANGE_STALENESS_V2_TREATMENT_IDS } from "../../experiments/plugins/incrementalChangeStaleness/disposableTarget.js";
+import { INCREMENTAL_CHANGE_STALENESS_REPORT_SCHEMA_VERSION_V2 } from "./incrementalChangeStalenessReportModelV2.js";
+// Frozen V2 wording. Every point must appear in report.txt and report.html.
+export const LIMITATIONS_V2 = [
+    "Results are scoped to the executed deterministic benchmark scenarios and the configured upstream my-dev-kit tool.",
+    "Full refresh is a comparison reference, not an asserted optimal strategy.",
+    "A partial treatment that falls back to a full rebuild is not evidence about the requested partial-refresh behavior.",
+    "\"no-observed-regression-relative-to-full\" means only that the executed scenario did not show a regression under the frozen correctness and required-file evidence dimensions. It does not prove general equivalence or safety, and does not show that full refresh is unnecessary.",
+    "Required-file evidence is a bounded answer-key file-presence check, not retrieval precision/recall.",
+    "Correctness remains deterministic fake-agent/harness evidence in v0.6.3.",
+    "Lab affected-neighborhood evidence (changed baseline neighborhood relative to the task) is distinct from upstream refresh execution evidence (what my-dev-kit actually refreshed).",
+    "\"reindexRecommendation\" remains observational evidence; it did not select or trigger any treatment.",
+    "\"changedSymbolCount\" does not mean source-level symbol-diff proof; it retains the released v0.6.1 baseline-symbol-identity definition.",
+    "The experiment does not use graph-diff."
+];
+/** Fixed neutral wording per partial-refresh reference classification. Presentation only. */
+export const PARTIAL_REFERENCE_CLASSIFICATION_EXPLANATIONS = {
+    "observed-regression-relative-to-full": "The persisted comparison observed at least one regression relative to the full-refresh reference under the frozen evidence dimensions: correctness and/or required-file presence.",
+    "no-observed-regression-relative-to-full": "This executed scenario did not show a regression relative to the full-refresh reference under the frozen correctness and required-file evidence dimensions. This does not establish general equivalence or safety, and does not imply that full refresh is unnecessary.",
+    inconclusive: "Available persisted evidence was insufficient to determine whether a regression relative to the full-refresh reference occurred. Inconclusive is not the same as no regression.",
+    "not-comparable-as-partial-refresh": "The requested partial-refresh treatment fell back to a full rebuild, so this run does not provide evidence about the requested partial-refresh behavior."
+};
+/** Presentation order and labels; identity is always resolved by treatment id, never by array position. */
+export const TREATMENT_PRESENTATION = [
+    { id: "stale-index", label: "No Refresh" },
+    { id: "changed-files-refresh", label: "Changed-Files Refresh" },
+    { id: "affected-neighborhood-refresh", label: "Affected-Neighborhood Refresh" },
+    { id: "full-refresh", label: "Full Refresh" }
+];
+export const COMPARISON_PRESENTATION = [
+    { candidate: "stale-index", label: "No Refresh vs Full Refresh" },
+    { candidate: "changed-files-refresh", label: "Changed-Files Refresh vs Full Refresh" },
+    { candidate: "affected-neighborhood-refresh", label: "Affected-Neighborhood Refresh vs Full Refresh" }
+];
+export function findReportTreatment(scenario, treatmentId) {
+    return scenario.treatments.find((treatment) => treatment.treatmentId === treatmentId) ?? null;
+}
+export function findReportComparison(scenario, candidateTreatmentId) {
+    return scenario.referenceComparisons.find((comparison) => comparison.candidateTreatmentId === candidateTreatmentId && comparison.referenceTreatmentId === "full-refresh") ?? null;
+}
+export function buildIncrementalChangeStalenessReportV2FromArtifact(artifact) {
+    for (const scenario of artifact.scenarios)
+        validateIncrementalChangeStalenessScenarioRecordV2(scenario);
+    return {
+        schemaVersion: INCREMENTAL_CHANGE_STALENESS_REPORT_SCHEMA_VERSION_V2,
+        pluginId: artifact.pluginId,
+        summary: { ...artifact.summary },
+        scenarios: artifact.scenarios.map(toReportScenario),
+        limitations: [...LIMITATIONS_V2]
+    };
+}
+function toReportScenario(record) {
+    return {
+        scenarioId: record.scenarioId,
+        category: record.category,
+        benchmarkProjectId: record.benchmarkProjectId,
+        baseCaseId: record.baseCaseId,
+        status: record.status,
+        failureReason: record.failureReason,
+        query: record.query,
+        answerPolicy: record.answerPolicy,
+        expectedFiles: [...record.expectedFiles],
+        expectedSymbols: [...record.expectedSymbols],
+        lifecycle: record.lifecycle ? structuredClone(record.lifecycle) : null,
+        // Persisted order is preserved; consumers resolve identity by id (see findReportTreatment/findReportComparison).
+        treatments: record.treatments.map((treatment) => structuredClone(treatment)),
+        referenceComparisons: record.referenceComparisons.map((comparison) => structuredClone(comparison))
+    };
+}
+/** Kept for callers that need the fixed id list without importing the plugin layer. */
+export const REPORT_TREATMENT_IDS = INCREMENTAL_CHANGE_STALENESS_V2_TREATMENT_IDS;
+export function isV2ReportSection(section) {
+    return section !== null && section.schemaVersion === INCREMENTAL_CHANGE_STALENESS_REPORT_SCHEMA_VERSION_V2;
+}

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

@@ -1,7 +1,11 @@
 import path from "node:path";
 import { buildContextStrategyComparisonV043Report } from "./buildContextStrategyComparisonV043Report.js";
 import { buildWarmIndexReuseReport } from "./buildWarmIndexReuseReport.js";
-import { buildIncrementalChangeStalenessReport } from "./buildIncrementalChangeStalenessReport.js";
+import { buildIncrementalChangeStalenessPluginReport } from "./buildIncrementalChangeStalenessPluginReport.js";
+import { buildContextWindowScalingReport } from "./buildContextWindowScalingReport.js";
+// Bulk context-window-scaling evidence is presented by the typed report section; the complete
+// evidence stays in context-window-scaling-execution.json.
+const CONTEXT_WINDOW_SCALING_BULK_KEYS = ["executionEvidence", "aggregate"];
 const V043_BULK_ARRAY_KEYS = [
     "v043StageContextExecutions",
     "v043StageContextEvaluations",
@@ -12,11 +16,17 @@ export function buildPluginExperimentReport(args) {
     const allOutcomes = args.run.cases.flatMap((experimentCase) => experimentCase.outcomes);
     const contextStrategyComparisonV043 = buildContextStrategyComparisonV043Report(args.run);
     const warmIndexReuse = buildWarmIndexReuseReport(args.run);
-    const incrementalChangeStaleness = buildIncrementalChangeStalenessReport(args.run);
+    const incrementalChangeStaleness = buildIncrementalChangeStalenessPluginReport(args.run);
+    const contextWindowScaling = buildContextWindowScalingReport(args.run);
     const rawRun = { ...args.run, artifacts: relativizeArtifacts(args.run.artifacts, outputRoot) };
     for (const key of V043_BULK_ARRAY_KEYS) {
         delete rawRun[key];
     }
+    if (contextWindowScaling) {
+        for (const key of CONTEXT_WINDOW_SCALING_BULK_KEYS) {
+            delete rawRun[key];
+        }
+    }
     return {
         metadata: {
             generatedAt: args.generatedAt ?? new Date().toISOString(),
@@ -42,8 +52,9 @@ export function buildPluginExperimentReport(args) {
         findings: buildFindings(args.run),
         warmIndexReuse,
         incrementalChangeStaleness,
+        contextWindowScaling,
         contextStrategyComparisonV043,
-        interpretation: buildInterpretation(args.run, contextStrategyComparisonV043, warmIndexReuse),
+        interpretation: buildInterpretation(args.run, contextStrategyComparisonV043, warmIndexReuse, contextWindowScaling),
         rawRun,
     };
 }
@@ -122,7 +133,16 @@ function affectedNeighborhoodSentence(report) {
         `reindex recommendations were recommended=${summary.recommendedReindexCount}, not-indicated=${summary.notIndicatedReindexCount}, unknown=${summary.unknownReindexRecommendationCount}. ` +
         "Affected-neighborhood evidence uses a one-hop baseline graph around confirmed changed indexed files/symbols. It is observational and does not alter retrieval or execution status.");
 }
-function buildInterpretation(run, contextStrategyComparisonV043, warmIndexReuse) {
+function buildInterpretation(run, contextStrategyComparisonV043, warmIndexReuse, contextWindowScaling) {
+    if (contextWindowScaling) {
+        const summary = contextWindowScaling.runSummary;
+        return {
+            summary: `Context-window-scaling evidence covers ${summary.caseCount} case${summary.caseCount === 1 ? "" : "s"}, ${summary.treatmentCount} treatments, and ${summary.budgetCount} budget${summary.budgetCount === 1 ? "" : "s"} ` +
+                `(${summary.totalBudgetCellCount} budget cells): ${summary.evaluatedBudgetCellCount} evaluated, ${summary.contextTooLargeCellCount} context-too-large, ${summary.contextUnavailableCellCount} with unavailable context. ` +
+                "Context-too-large is an expected measurement state, not an execution failure. The treatments are reported side by side and are not ranked.",
+            recommendedNextStep: "Review the budget summary, per-case context sizes, and per-case budget matrix; unavailable correctness and success evidence are excluded from the rates and are never treated as zero.",
+        };
+    }
     if (run.pluginId === "warm-index-reuse" && warmIndexReuse) {
         const summary = warmIndexReuse.summary;
         const campaign = warmIndexReuse.agentCampaign;

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

@@ -0,0 +1,3 @@
+export const CONTEXT_WINDOW_SCALING_REPORT_SCHEMA_VERSION = "my-dev-kit-lab-context-window-scaling-report-v1";
+/** Presentation limit only; the full omitted identities stay in context-window-scaling-execution.json. */
+export const MAX_REPORT_OMITTED_RELEVANT_FILES = 20;

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

@@ -0,0 +1,3 @@
+// v0.6.3 -- plugin-specific presentation model for the four-treatment V2 execution artifact. Types only:
+// projection lives in buildIncrementalChangeStalenessReportV2.ts, rendering in the text/HTML renderers.
+export const INCREMENTAL_CHANGE_STALENESS_REPORT_SCHEMA_VERSION_V2 = "my-dev-kit-lab-incremental-change-staleness-report-v2";

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

@@ -0,0 +1,146 @@
+// v0.6.3 -- shared semantic content for the V2 text and HTML renderers, so both present exactly the same
+// persisted facts. Formatting only: no classification, arithmetic, or recomputation. Unavailable evidence
+// is written as words ("unavailable", "not applicable"), never as zero.
+import { STALE_RISK_CLASSIFICATION_EXPLANATIONS } from "./buildIncrementalChangeStalenessReport.js";
+import { COMPARISON_PRESENTATION, PARTIAL_REFERENCE_CLASSIFICATION_EXPLANATIONS, TREATMENT_PRESENTATION, findReportComparison, findReportTreatment } from "./buildIncrementalChangeStalenessReportV2.js";
+import { REINDEX_RECOMMENDATION_EXPLANATIONS } from "./buildWarmIndexReuseReport.js";
+export function display(value, missing = "unavailable") {
+    return value === null || value === undefined ? missing : String(value);
+}
+export function treatmentBlock(scenario, treatmentId, label) {
+    const treatment = findReportTreatment(scenario, treatmentId);
+    if (!treatment) {
+        return { label, available: false, rows: [], fallbackStatement: null, refreshRows: [], forcedNeighborSample: null, filesRead: [], requiredFiles: [], observedFiles: [], missingFiles: [] };
+    }
+    const retrieval = treatment.retrieval;
+    const correctness = treatment.fakeAgent?.correctness;
+    const refresh = treatment.refreshExecution;
+    const rows = [
+        ["Treatment status", treatment.status],
+        ["Treatment intent", treatment.treatmentIntent],
+        ["Failure reason", display(treatment.failureReason, "not applicable")],
+        ["Active index phase", treatment.activeIndexPhase],
+        ["Baseline freshness", treatment.baselineFreshness.status],
+        ["Refreshed freshness", display(treatment.refreshedFreshness?.status, "not applicable")],
+        ["Retrieval status", retrieval.status],
+        ["Context characters", retrieval.status === "not-run" ? "unavailable" : String(retrieval.totalChars)],
+        ["Estimated context tokens", retrieval.status === "not-run" ? "unavailable" : String(retrieval.totalEstimatedTokens)],
+        ["Retrieval duration (ms)", retrieval.status === "not-run" ? "unavailable" : String(retrieval.durationMs)],
+        ["Fake-agent status", display(treatment.fakeAgent?.status, "not run")],
+        ["Correctness score", correctness && correctness.available && correctness.score !== null ? String(correctness.score) : "unavailable"],
+        ["Required-file evidence", treatment.requiredFileEvidence.status],
+        ["Required-file reason", display(treatment.requiredFileEvidence.reason, "not applicable")],
+        ["Affected-neighborhood relationship", treatment.affectedNeighborhood.relationship],
+        ["Reindex recommendation (observational)", treatment.affectedNeighborhood.reindexRecommendation]
+    ];
+    const refreshRows = [
+        ["Refresh kind", refresh.kind],
+        ["Refresh realization", refresh.realization]
+    ];
+    let fallbackStatement = null;
+    let forcedNeighborSample = null;
+    if (refresh.kind === "incremental") {
+        const upstream = refresh.incrementalRefresh;
+        refreshRows.push(["Requested scope", upstream.requestedScope], ["Applied scope", upstream.appliedScope], ["Selection status", upstream.selectionStatus], ["Fallback reason", display(upstream.fallbackReason, "not applicable")], ["Fresh extraction files", String(upstream.freshExtractionFileCount)], ["Reused files", String(upstream.reusedFileCount)], ["Forced-neighbor reanalysis files", String(upstream.forcedNeighborReanalysisFileCount)], ["Upstream seed files", display(upstream.seedFileCount, "not recorded")], ["Upstream seed symbols", display(upstream.seedSymbolCount, "not recorded")], ["Upstream affected nodes", display(upstream.affectedNodeCount, "not recorded")], ["Upstream affected edges", display(upstream.affectedEdgeCount, "not recorded")]);
+        forcedNeighborSample = [...upstream.forcedNeighborSample];
+        if (refresh.realization === "FALLBACK_FULL") {
+            fallbackStatement = `FALLBACK_FULL: requested ${upstream.requestedScope}, applied ${upstream.appliedScope}, selection status ${upstream.selectionStatus}, reason ${display(upstream.fallbackReason, "not recorded")}. The requested partial refresh was not applied; a full rebuild produced this index.`;
+        }
+    }
+    else {
+        refreshRows.push(["Upstream incremental refresh evidence", "not applicable"]);
+    }
+    return {
+        label,
+        available: true,
+        rows,
+        fallbackStatement,
+        refreshRows,
+        forcedNeighborSample,
+        filesRead: [...retrieval.filesRead],
+        requiredFiles: [...treatment.requiredFileEvidence.requiredFiles],
+        observedFiles: [...treatment.requiredFileEvidence.observedFiles],
+        missingFiles: [...treatment.requiredFileEvidence.missingFiles]
+    };
+}
+export function comparisonBlock(scenario, presentation) {
+    const comparison = findReportComparison(scenario, presentation.candidate);
+    if (!comparison)
+        return { label: presentation.label, available: false, rows: [], reasonCodes: [], explanation: "" };
+    if (comparison.kind === "stale-risk") {
+        const value = comparison.comparison;
+        return {
+            label: presentation.label,
+            available: true,
+            rows: [
+                ["Correctness relation", value.correctnessRelation],
+                ["Required-file evidence relation", value.requiredFileEvidenceRelation],
+                ["Stale-risk classification", value.staleRiskClassification]
+            ],
+            reasonCodes: [...value.reasonCodes],
+            explanation: STALE_RISK_CLASSIFICATION_EXPLANATIONS[value.staleRiskClassification]
+        };
+    }
+    return {
+        label: presentation.label,
+        available: true,
+        rows: [
+            ["Refresh realization", display(comparison.refreshRealization, "not recorded")],
+            ["Candidate correctness relation", comparison.correctnessRelation],
+            ["Candidate required-file relation", comparison.requiredFileEvidenceRelation],
+            ["Reference classification", comparison.classification]
+        ],
+        reasonCodes: [...comparison.reasonCodes],
+        explanation: PARTIAL_REFERENCE_CLASSIFICATION_EXPLANATIONS[comparison.classification]
+    };
+}
+export const TREATMENT_PRESENTATION_ORDER = TREATMENT_PRESENTATION;
+export const COMPARISON_PRESENTATION_ORDER = COMPARISON_PRESENTATION;
+/**
+ * Baseline affected-neighborhood evidence is symmetric by construction of the execution; the report
+ * presents it once only when the persisted relationship and recommendation agree, and otherwise says so.
+ */
+export function affectedNeighborhoodSummary(scenario) {
+    const assessments = TREATMENT_PRESENTATION.map((entry) => findReportTreatment(scenario, entry.id)?.affectedNeighborhood ?? null).filter((assessment) => assessment !== null);
+    if (assessments.length === 0)
+        return { state: "none" };
+    const first = assessments[0];
+    if (assessments.some((a) => a.relationship !== first.relationship || a.reindexRecommendation !== first.reindexRecommendation))
+        return { state: "inconsistent" };
+    const number = (value) => display(value);
+    return {
+        state: "ok",
+        rows: [
+            ["Relationship", first.relationship],
+            ["Reindex recommendation (observational)", first.reindexRecommendation],
+            ["Changed indexed files", number(first.changedFileCount)],
+            ["Changed baseline symbols", number(first.changedSymbolCount)],
+            ["Affected graph nodes", number(first.affectedNodeCount)],
+            ["Affected graph edges", number(first.affectedEdgeCount)],
+            ["Task-overlap nodes", number(first.taskOverlapCount)],
+            ["Task-overlap percent", number(first.taskOverlapPercent)]
+        ],
+        explanation: REINDEX_RECOMMENDATION_EXPLANATIONS[first.reindexRecommendation]
+    };
+}
+export const EVIDENCE_FAMILY_NOTE = "Lab affected-neighborhood evidence describes the baseline graph neighborhood implicated by the controlled change. Upstream refresh evidence describes what my-dev-kit actually refreshed. They are different evidence families.";
+export const SCENARIO_SUMMARY_ROWS = (summary) => [
+    ["Scenarios", String(summary.scenarioCount)],
+    ["Ready", String(summary.readyScenarioCount)],
+    ["Failed", String(summary.failedScenarioCount)],
+    ["No refresh: observed stale regression", String(summary.staleObservedRegressionCount)],
+    ["No refresh: no observed stale regression", String(summary.staleNoObservedRegressionCount)],
+    ["No refresh: inconclusive", String(summary.staleInconclusiveCount)],
+    ["Changed-files: applied partial", String(summary.changedFilesAppliedPartialCount)],
+    ["Changed-files: fallback to full", String(summary.changedFilesFallbackFullCount)],
+    ["Affected-neighborhood: applied partial", String(summary.affectedNeighborhoodAppliedPartialCount)],
+    ["Affected-neighborhood: fallback to full", String(summary.affectedNeighborhoodFallbackFullCount)],
+    ["Changed-files: observed regression relative to full", String(summary.changedFilesObservedRegressionRelativeToFullCount)],
+    ["Changed-files: no observed regression relative to full", String(summary.changedFilesNoObservedRegressionRelativeToFullCount)],
+    ["Changed-files: inconclusive", String(summary.changedFilesInconclusiveCount)],
+    ["Changed-files: not comparable as partial refresh", String(summary.changedFilesNotComparableCount)],
+    ["Affected-neighborhood: observed regression relative to full", String(summary.affectedNeighborhoodObservedRegressionRelativeToFullCount)],
+    ["Affected-neighborhood: no observed regression relative to full", String(summary.affectedNeighborhoodNoObservedRegressionRelativeToFullCount)],
+    ["Affected-neighborhood: inconclusive", String(summary.affectedNeighborhoodInconclusiveCount)],
+    ["Affected-neighborhood: not comparable as partial refresh", String(summary.affectedNeighborhoodNotComparableCount)]
+];

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

@@ -15,5 +15,12 @@ export { renderContextIntegrityJsonReport } from "./renderContextIntegrityJsonRe
 export { renderContextIntegrityText } from "./renderContextIntegrityText.js";
 export { renderContextIntegrityHtml } from "./renderContextIntegrityHtml.js";
 export * from "./incrementalChangeStalenessReportModel.js";
+export * from "./incrementalChangeStalenessReportModelV2.js";
+export { buildIncrementalChangeStalenessPluginReport } from "./buildIncrementalChangeStalenessPluginReport.js";
+export { buildIncrementalChangeStalenessReportV2FromArtifact, findReportTreatment, findReportComparison, LIMITATIONS_V2 } from "./buildIncrementalChangeStalenessReportV2.js";
 export { buildIncrementalChangeStalenessReport, STALE_RISK_CLASSIFICATION_EXPLANATIONS } from "./buildIncrementalChangeStalenessReport.js";
 export { renderIncrementalChangeStalenessHtml } from "./renderIncrementalChangeStalenessHtml.js";
+export * from "./contextWindowScalingReportModel.js";
+export { buildContextWindowScalingReport, CONTEXT_WINDOW_SCALING_INTERPRETATION } from "./buildContextWindowScalingReport.js";
+export { renderContextWindowScalingHtml } from "./renderContextWindowScalingHtml.js";
+export { renderContextWindowScalingTextLines } from "./renderContextWindowScalingText.js";

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

@@ -0,0 +1,99 @@
+import { formatContextWindowScalingCount, formatContextWindowScalingPercent, formatContextWindowScalingScore, } from "./renderContextWindowScalingText.js";
+export function renderContextWindowScalingHtml(section) {
+    if (section === null) {
+        return `<section>
+    <h2>Context Window Scaling</h2>
+    <p>Not applicable to this plugin.</p>
+  </section>`;
+    }
+    const summary = section.runSummary;
+    return `<section>
+    <h2>Context Window Scaling</h2>
+    ${table(["Field", "Value"], [
+        ["Schema", section.schemaVersion],
+        ["Budgets (estimated context tokens)", section.budgets.join(", ")],
+        ["Treatments", section.treatments.join(", ")],
+        ["Token count method", section.tokenCountMethod ?? "unavailable"],
+        ...Object.entries(summary).map(([label, value]) => [label, String(value)]),
+    ])}
+    <h3>Budget Summary</h3>
+    ${table(["Budget", "Treatment", "Cells", "Fits", "Too large", "Context unavailable", "Success", "Not successful", "Success unavailable", "Success rate", "Correctness available", "Mean correctness", "Mean utilization", "Min utilization", "Max utilization"], section.budgetTreatmentSummaries.map((s) => [
+        String(s.contextBudgetTokens),
+        s.variantId,
+        String(s.totalCellCount),
+        String(s.fitCount),
+        String(s.contextTooLargeCount),
+        String(s.contextUnavailableCount),
+        String(s.successfulCellCount),
+        String(s.notSuccessfulCellCount),
+        String(s.successEvidenceUnavailableCount),
+        formatContextWindowScalingPercent(s.successRatePercent),
+        String(s.correctnessAvailableCount),
+        formatContextWindowScalingScore(s.meanCorrectnessScore),
+        formatContextWindowScalingPercent(s.meanContextBudgetUtilizationPercent),
+        formatContextWindowScalingPercent(s.minContextBudgetUtilizationPercent),
+        formatContextWindowScalingPercent(s.maxContextBudgetUtilizationPercent),
+    ]))}
+    <h3>Case Context Evidence</h3>
+    <p class="muted">Context does not vary by budget, so there is one row per case and treatment.</p>
+    ${table(["Case", "Treatment", "Context", "Characters", "Estimated tokens", "Token method", "Observed files", "Relevant-file evidence", "Expected relevant files", "Observed expected files", "Omitted relevant files"], section.caseTreatmentContexts.map((c) => [
+        c.caseId,
+        c.variantId,
+        c.contextStatus,
+        formatContextWindowScalingCount(c.characterCount),
+        formatContextWindowScalingCount(c.estimatedTokens),
+        c.tokenCountMethod ?? "unavailable",
+        formatContextWindowScalingCount(c.observedFileCount),
+        c.relevantFileStatus,
+        String(c.expectedRelevantFileCount),
+        formatContextWindowScalingCount(c.observedExpectedFileCount),
+        formatContextWindowScalingCount(c.omittedRelevantFileCount),
+    ]))}
+    <h3>Omitted Relevant Files</h3>
+    <p class="muted">Benchmark-expected files not observed in the treatment context. Not retrieval precision or recall.</p>
+    ${table(["Evidence available", "Unavailable", "Not applicable", "Total omitted"], [[
+            String(section.relevantFileSummary.relevantFileEvidenceAvailableCount),
+            String(section.relevantFileSummary.relevantFileEvidenceUnavailableCount),
+            String(section.relevantFileSummary.relevantFileEvidenceNotApplicableCount),
+            String(section.relevantFileSummary.totalOmittedRelevantFileCount),
+        ]])}
+    ${section.caseTreatmentContexts
+        .filter((c) => c.relevantFileStatus === "available" && (c.omittedRelevantFileCount ?? 0) > 0)
+        .map((c) => `<p><code>${escapeHtml(c.caseId)}</code> / ${escapeHtml(c.variantId)}: omitted ${c.omittedRelevantFiles.totalCount}; displayed ${c.omittedRelevantFiles.displayedCount} of ${c.omittedRelevantFiles.totalCount}; omitted from display ${c.omittedRelevantFiles.omittedCount}; truncated ${c.omittedRelevantFiles.truncated ? "yes" : "no"}</p>${list(c.omittedRelevantFiles.items)}`)
+        .join("\n    ")}
+    <h3>Per-Case Budget Matrix</h3>
+    ${table(["Case", "Treatment", "Budget", "Estimated context tokens", "Fit", "Utilization", "Evaluation", "Correctness", "Correctness score", "Correctness pass", "Success evidence", "Success", "Success reason"], section.caseBudgetCells.map((cell) => [
+        cell.caseId,
+        cell.variantId,
+        String(cell.contextBudgetTokens),
+        formatContextWindowScalingCount(cell.contextEstimatedTokens),
+        cell.contextFitStatus,
+        formatContextWindowScalingPercent(cell.contextBudgetUtilizationPercent),
+        cell.evaluationStatus,
+        cell.correctness.availability,
+        formatContextWindowScalingScore(cell.correctness.score),
+        cell.correctness.pass === null ? "unavailable" : String(cell.correctness.pass),
+        cell.successEvidence.status,
+        cell.successEvidence.success === null ? "unavailable" : String(cell.successEvidence.success),
+        cell.successEvidence.reason,
+    ]))}
+    <h3>Interpretation And Limitations</h3>
+    ${list(section.interpretation)}
+  </section>`;
+}
+function list(items) {
+    return `<ul>${items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul>`;
+}
+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 escapeHtml(value) {
+    return String(value ?? "")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}