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

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { buildContextStrategyComparisonV043Report } from "./buildContextStrategyComparisonV043Report.js";
 import { buildWarmIndexReuseReport } from "./buildWarmIndexReuseReport.js";
+import { buildIncrementalChangeStalenessReport } from "./buildIncrementalChangeStalenessReport.js";
 const V043_BULK_ARRAY_KEYS = [
     "v043StageContextExecutions",
     "v043StageContextEvaluations",
@@ -11,6 +12,7 @@ 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 rawRun = { ...args.run, artifacts: relativizeArtifacts(args.run.artifacts, outputRoot) };
     for (const key of V043_BULK_ARRAY_KEYS) {
         delete rawRun[key];
@@ -39,6 +41,7 @@ export function buildPluginExperimentReport(args) {
         skippedOutcomes: allOutcomes.filter((outcome) => outcome.status === "skipped"),
         findings: buildFindings(args.run),
         warmIndexReuse,
+        incrementalChangeStaleness,
         contextStrategyComparisonV043,
         interpretation: buildInterpretation(args.run, contextStrategyComparisonV043, warmIndexReuse),
         rawRun,
@@ -107,6 +110,18 @@ function freshnessSentence(report) {
         `fresh=${summary.freshTaskCount}, stale=${summary.staleTaskCount}, partially-stale=${summary.partiallyStaleTaskCount}, unknown=${summary.unknownTaskCount}. ` +
         "Freshness is observational evidence over files represented by the index snapshot and does not change retrieval or provider status.");
 }
+/** Neutral, count-only sentence derived from the report's persisted affected-neighborhood summary. */
+function affectedNeighborhoodSentence(report) {
+    const summary = report.affectedNeighborhoodSummary;
+    if (!summary || summary.assessedTaskCount === 0) {
+        return "No per-task affected-neighborhood assessment was available in this report.";
+    }
+    return (`Affected-neighborhood evidence was available for ${summary.assessedTaskCount} task boundar${summary.assessedTaskCount === 1 ? "y" : "ies"}: ` +
+        `complete=${summary.completeAssessmentCount}, partial=${summary.partialAssessmentCount}, unavailable=${summary.unavailableAssessmentCount}; ` +
+        `relationships were related=${summary.relatedTaskCount}, unrelated=${summary.unrelatedTaskCount}, unknown=${summary.unknownRelationshipTaskCount}; ` +
+        `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) {
     if (run.pluginId === "warm-index-reuse" && warmIndexReuse) {
         const summary = warmIndexReuse.summary;
@@ -118,7 +133,7 @@ function buildInterpretation(run, contextStrategyComparisonV043, warmIndexReuse)
                     `Deterministic fake-agent correctness/token evidence is available for ${summary.agentCorrectnessAvailableCount} of ${summary.agentSideCount} task sides (correctness) and ${summary.agentTotalTokensAvailableCount} (total tokens); ` +
                     "fake-agent totals are simulated harness evidence, not real-model or provider measurements. " +
                     "Estimated context-token values are context-size estimates, not provider token usage. " +
-                    freshnessSentence(warmIndexReuse),
+                    freshnessSentence(warmIndexReuse) + " " + affectedNeighborhoodSentence(warmIndexReuse),
                 recommendedNextStep: run.status === "completed"
                     ? "Review per-task measurements and cumulative component costs for each project; the variants are reported side by side and are not ranked."
                     : "Inspect unavailable metrics, warnings, and failures before drawing conclusions from this run.",
@@ -144,7 +159,7 @@ function buildInterpretation(run, contextStrategyComparisonV043, warmIndexReuse)
                 `${nonCompletedCounts ? `; outcome counts: ${nonCompletedCounts}` : ""}). ` +
                 `Token evidence status: ${campaign.tokenEvidenceStatus} (${summary.agentTotalTokensAvailableCount} of ${summary.agentSideCount} task sides have a total-token value). ` +
                 "Context estimated tokens remain a separate character-based context-size estimate and are never substituted for provider telemetry. " +
-                freshnessSentence(warmIndexReuse),
+                freshnessSentence(warmIndexReuse) + " " + affectedNeighborhoodSentence(warmIndexReuse),
             recommendedNextStep: isInfrastructureComplete && isAgentEvidenceComplete
                 ? "Review per-task correctness, token provenance, and cumulative component measurements."
                 : "Review infrastructure gaps (index build, raw/warm retrieval) separately from provider/agent limitations before drawing conclusions from this run.",

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

@@ -1,4 +1,4 @@
-import { MAX_REPORT_FRESHNESS_CHANGES, MAX_REPORT_FRESHNESS_UNRESOLVED, WARM_INDEX_REUSE_REPORT_SCHEMA_VERSION, } from "./warmIndexReuseReportModel.js";
+import { MAX_REPORT_AFFECTED_EDGES, MAX_REPORT_AFFECTED_NODES, MAX_REPORT_AFFECTED_TASK_AMBIGUOUS, MAX_REPORT_AFFECTED_TASK_UNRESOLVED, MAX_REPORT_AFFECTED_WARNINGS, MAX_REPORT_FRESHNESS_CHANGES, MAX_REPORT_FRESHNESS_UNRESOLVED, WARM_INDEX_REUSE_REPORT_SCHEMA_VERSION, } from "./warmIndexReuseReportModel.js";
 const WARM_INDEX_REUSE_PLUGIN_ID = "warm-index-reuse";
 const COMMON_LIMITATIONS = [
     "Context estimated-token counts use the character-based estimate and are not provider billing telemetry.",
@@ -30,6 +30,17 @@ const FRESHNESS_LIMITATIONS = [
     "Freshness is observational evidence. It does not trigger reindexing, suppress warm retrieval, alter execution status, or alter provider/agent outcome status.",
     "Freshness statuses: fresh means all represented indexed files were completely compared and their content identities still match; stale means a complete comparison confirmed at least one represented indexed file is modified or missing; partially-stale means at least one represented indexed file is confirmed changed but comparison evidence is incomplete; unknown means no confirmed change established staleness but evidence is insufficient to prove freshness. A task without an assessment is reported as not assessed, which is not the same as unknown.",
 ];
+const AFFECTED_NEIGHBORHOOD_LIMITATIONS = [
+    "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.",
+    "A changed baseline symbol means the symbol was present in a confirmed changed indexed file; it is not proof that the symbol's own source text changed.",
+    "Reindex recommendation categories describe this bounded analysis only. They do not claim that reindexing is mandatory, that it guarantees correctness, that skipping it is universally safe, or that the whole repository is fresh.",
+];
+/** Fixed neutral wording per recommendation category. */
+export const REINDEX_RECOMMENDATION_EXPLANATIONS = {
+    recommended: "Reindex recommended: the task has confirmed overlap with the affected one-hop baseline graph neighborhood.",
+    "not-indicated": "Reindex not indicated by this bounded analysis: complete evidence found no task-node overlap with the affected neighborhood.",
+    unknown: "Reindex recommendation unknown: evidence is incomplete or unavailable, so absence of observed overlap is not sufficient to conclude that the task is unaffected.",
+};
 const COST_MODEL = [
     "Index construction is a one-time cost per benchmark project; task retrieval is the repeated warm cost.",
     "Cold start: for the first task in a project, the cumulative warm component duration is the one-time index build plus the first retrieval.",
@@ -98,6 +109,7 @@ export function buildWarmIndexReuseReport(run) {
                     rawAgent: toReportAgent(rawEvidence),
                     warmAgent: toReportAgent(warmEvidence),
                     indexFreshness: toReportFreshness(execution.tasks[taskIndex].indexFreshness),
+                    affectedNeighborhood: toReportAffectedNeighborhood(execution.tasks[taskIndex].affectedNeighborhood, task.warm),
                 };
             }),
         };
@@ -130,6 +142,7 @@ export function buildWarmIndexReuseReport(run) {
         agent: agentIdentity,
         agentCampaign,
         indexFreshnessSummary: summarizeFreshness(projects.flatMap((project) => project.tasks)),
+        affectedNeighborhoodSummary: summarizeAffectedNeighborhood(projects.flatMap((project) => project.tasks)),
     };
 }
 function boundedList(source, limit, map) {
@@ -162,6 +175,70 @@ function toReportFreshness(freshness) {
         warnings: [...freshness.warnings],
     };
 }
+/** Bounded list whose totals come from persisted counts, which can exceed the persisted item list. */
+function boundedListWithTotal(source, totalCount, limit, map) {
+    const items = source.slice(0, limit).map(map);
+    const total = Math.max(totalCount, source.length);
+    return { totalCount: total, displayedCount: items.length, omittedCount: total - items.length, items };
+}
+/**
+ * Presents a persisted affected-neighborhood assessment only: it never traverses, remaps seeds,
+ * recomputes overlap, or reads the graph, index, or filesystem. Numeric fields are the warm-side
+ * metric objects already calculated by the metric owner. Absent evidence stays null.
+ */
+function toReportAffectedNeighborhood(assessment, warm) {
+    if (!assessment)
+        return null;
+    const mapping = assessment.taskMapping;
+    return {
+        status: assessment.status,
+        freshnessStatus: assessment.freshnessStatus,
+        seedMappingStatus: assessment.seedMappingStatus,
+        graphEvidenceStatus: assessment.graphEvidenceStatus,
+        neighborhoodStatus: assessment.neighborhoodStatus,
+        metrics: {
+            changedFileCount: warm.changedFileCount,
+            changedSymbolCount: warm.changedSymbolCount,
+            affectedNodeCount: warm.affectedNodeCount,
+            affectedEdgeCount: warm.affectedEdgeCount,
+            taskOverlapCount: warm.taskOverlapCount,
+            taskOverlapPercent: warm.taskOverlapPercent,
+        },
+        taskMappingStatus: mapping.status,
+        resolvableTaskNodeCount: mapping.resolvableTaskNodeCount,
+        relationship: assessment.relationship,
+        reindexRecommendation: assessment.reindexRecommendation,
+        recommendationExplanation: REINDEX_RECOMMENDATION_EXPLANATIONS[assessment.reindexRecommendation],
+        affectedNodeIds: boundedList(assessment.affectedNodeIds, MAX_REPORT_AFFECTED_NODES, (id) => id),
+        participatingEdgeIds: boundedList(assessment.participatingEdgeIds, MAX_REPORT_AFFECTED_EDGES, (id) => id),
+        unresolvedTaskMappings: boundedListWithTotal(mapping.unresolved, mapping.unresolvedCount, MAX_REPORT_AFFECTED_TASK_UNRESOLVED, (entry) => ({ ...entry })),
+        ambiguousTaskSymbols: boundedListWithTotal(mapping.ambiguousSymbols, mapping.ambiguousCount, MAX_REPORT_AFFECTED_TASK_AMBIGUOUS, (entry) => ({
+            name: entry.name,
+            candidateNodeIds: [...entry.candidateNodeIds],
+        })),
+        warnings: boundedListWithTotal(assessment.warnings, assessment.warningCount, MAX_REPORT_AFFECTED_WARNINGS, (warning) => ({
+            code: warning.code,
+            message: warning.message,
+        })),
+    };
+}
+function summarizeAffectedNeighborhood(tasks) {
+    const assessed = tasks.flatMap((task) => (task.affectedNeighborhood ? [task.affectedNeighborhood] : []));
+    const count = (key, value) => assessed.filter((entry) => entry[key] === value).length;
+    return {
+        assessedTaskCount: assessed.length,
+        unassessedTaskCount: tasks.length - assessed.length,
+        completeAssessmentCount: count("status", "complete"),
+        partialAssessmentCount: count("status", "partial"),
+        unavailableAssessmentCount: count("status", "unavailable"),
+        relatedTaskCount: count("relationship", "related"),
+        unrelatedTaskCount: count("relationship", "unrelated"),
+        unknownRelationshipTaskCount: count("relationship", "unknown"),
+        recommendedReindexCount: count("reindexRecommendation", "recommended"),
+        notIndicatedReindexCount: count("reindexRecommendation", "not-indicated"),
+        unknownReindexRecommendationCount: count("reindexRecommendation", "unknown"),
+    };
+}
 function summarizeFreshness(tasks) {
     const assessed = tasks.flatMap((task) => (task.indexFreshness ? [task.indexFreshness] : []));
     const count = (status) => assessed.filter((freshness) => freshness.status === status).length;
@@ -242,10 +319,10 @@ function buildCampaignSummary(args) {
 }
 function buildLimitations(agent) {
     if (agent.mode === "deterministic-fake") {
-        return [...COMMON_LIMITATIONS, ...FAKE_AGENT_LIMITATIONS, ...FRESHNESS_LIMITATIONS];
+        return [...COMMON_LIMITATIONS, ...FAKE_AGENT_LIMITATIONS, ...FRESHNESS_LIMITATIONS, ...AFFECTED_NEIGHBORHOOD_LIMITATIONS];
     }
     const providerLimitations = agent.id === "codex" ? CODEX_CAMPAIGN_LIMITATIONS : CLAUDE_CAMPAIGN_LIMITATIONS;
-    return [...COMMON_LIMITATIONS, ...providerLimitations, ...FRESHNESS_LIMITATIONS];
+    return [...COMMON_LIMITATIONS, ...providerLimitations, ...FRESHNESS_LIMITATIONS, ...AFFECTED_NEIGHBORHOOD_LIMITATIONS];
 }
 function toReportAgent(agent) {
     if (!agent)

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

@@ -0,0 +1,4 @@
+// v0.6.2 Batch 5 -- plugin-specific presentation model types only. No projection logic, no HTML,
+// no text rendering, and no recomputation live here; see buildIncrementalChangeStalenessReport.ts
+// and renderIncrementalChangeStalenessHtml.ts for those responsibilities.
+export const INCREMENTAL_CHANGE_STALENESS_REPORT_SCHEMA_VERSION = "my-dev-kit-lab-incremental-change-staleness-report-v1";

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

@@ -14,3 +14,6 @@ export { buildContextIntegrityReport } from "./buildContextIntegrityReport.js";
 export { renderContextIntegrityJsonReport } from "./renderContextIntegrityJsonReport.js";
 export { renderContextIntegrityText } from "./renderContextIntegrityText.js";
 export { renderContextIntegrityHtml } from "./renderContextIntegrityHtml.js";
+export * from "./incrementalChangeStalenessReportModel.js";
+export { buildIncrementalChangeStalenessReport, STALE_RISK_CLASSIFICATION_EXPLANATIONS } from "./buildIncrementalChangeStalenessReport.js";
+export { renderIncrementalChangeStalenessHtml } from "./renderIncrementalChangeStalenessHtml.js";

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

@@ -0,0 +1,239 @@
+// v0.6.2 Batch 5 -- plugin-specific HTML section rendering only. Renders exactly the persisted
+// report-model fields; performs no classification, no metric arithmetic, and no percent
+// calculation beyond formatting an already-persisted number.
+import { STALE_RISK_CLASSIFICATION_EXPLANATIONS } from "./buildIncrementalChangeStalenessReport.js";
+import { REINDEX_RECOMMENDATION_EXPLANATIONS } from "./buildWarmIndexReuseReport.js";
+const MAX_DISPLAY_ITEMS = 20;
+export function renderIncrementalChangeStalenessHtml(section) {
+    if (section === null) {
+        return `<section>
+    <h2>Incremental-Change And Staleness Evidence</h2>
+    <p>Not applicable to this plugin.</p>
+  </section>`;
+    }
+    return `<section>
+    <h2>Incremental-Change And Staleness Evidence</h2>
+    <p class="muted">Scoped experimental evidence: results are limited to the executed scenarios below, not a general safety verdict.</p>
+    ${table(["Field", "Value"], [
+        ["Scenarios", String(section.scenarioCount)],
+        ["Ready", String(section.readyScenarioCount)],
+        ["Failed", String(section.failedScenarioCount)],
+        ["Observed stale regression", String(section.observedStaleRegressionCount)],
+        ["No observed stale regression", String(section.noObservedStaleRegressionCount)],
+        ["Inconclusive", String(section.inconclusiveCount)]
+    ])}
+    <h3>Scenario Comparison</h3>
+    ${table([
+        "Scenario",
+        "Category",
+        "Status",
+        "Relationship",
+        "Reindex recommendation",
+        "Stale correctness",
+        "Full-refresh correctness",
+        "Correctness relation",
+        "Stale required files",
+        "Full-refresh required files",
+        "Required-file relation",
+        "Stale-risk classification"
+    ], section.scenarios.map(comparisonRow))}
+    ${section.scenarios.map(renderScenarioDetail).join("\n")}
+    <h3>Limitations</h3>
+    ${list(section.limitations)}
+  </section>`;
+}
+function symmetricAffectedNeighborhood(scenario) {
+    const stale = scenario.staleTreatment?.affectedNeighborhood ?? null;
+    const fullRefresh = scenario.fullRefreshTreatment?.affectedNeighborhood ?? null;
+    if (!stale || !fullRefresh)
+        return null;
+    if (stale.relationship !== fullRefresh.relationship || stale.reindexRecommendation !== fullRefresh.reindexRecommendation) {
+        return null;
+    }
+    return stale;
+}
+function comparisonRow(scenario) {
+    const stale = scenario.staleTreatment?.affectedNeighborhood ?? null;
+    const fullRefresh = scenario.fullRefreshTreatment?.affectedNeighborhood ?? null;
+    const symmetric = symmetricAffectedNeighborhood(scenario);
+    const inconsistent = stale !== null && fullRefresh !== null && symmetric === null;
+    return [
+        `${scenario.scenarioId}`,
+        scenario.category,
+        scenario.status,
+        inconsistent ? "inconsistent persisted evidence" : symmetric?.relationship ?? "not available",
+        inconsistent ? "inconsistent persisted evidence" : symmetric?.reindexRecommendation ?? "not available",
+        formatCorrectness(scenario.staleTreatment),
+        formatCorrectness(scenario.fullRefreshTreatment),
+        scenario.comparison.correctnessRelation,
+        scenario.staleTreatment?.requiredFileEvidence.status ?? "not available",
+        scenario.fullRefreshTreatment?.requiredFileEvidence.status ?? "not available",
+        scenario.comparison.requiredFileEvidenceRelation,
+        scenario.comparison.staleRiskClassification
+    ];
+}
+function formatCorrectness(treatment) {
+    if (!treatment || !treatment.fakeAgent)
+        return "unavailable";
+    const correctness = treatment.fakeAgent.correctness;
+    return correctness.available && correctness.score !== null ? String(correctness.score) : "unavailable";
+}
+function renderScenarioDetail(scenario) {
+    return `<h3>Scenario: ${escapeHtml(scenario.scenarioId)}</h3>
+    ${renderDefinition(scenario)}
+    ${renderLifecycle(scenario)}
+    ${renderAffectedNeighborhoodSection(scenario)}
+    ${renderTreatment("Stale-Index Treatment", scenario.staleTreatment)}
+    ${renderTreatment("Full-Refresh Treatment", scenario.fullRefreshTreatment)}
+    ${renderComparison(scenario)}`;
+}
+function renderDefinition(scenario) {
+    return `<h4>Scenario Definition</h4>
+    ${table(["Field", "Value"], [
+        ["Scenario ID", scenario.scenarioId],
+        ["Category", scenario.category],
+        ["Benchmark project", scenario.benchmarkProjectId],
+        ["Base case", scenario.baseCaseId],
+        ["Answer policy", scenario.answerPolicy],
+        ["Query", scenario.query ?? "unavailable"],
+        ["Status", scenario.status],
+        ["Failure reason", scenario.failureReason ?? "not applicable"]
+    ])}
+    <p>Expected files:</p>
+    ${boundedList(scenario.expectedFiles)}
+    <p>Expected symbols:</p>
+    ${boundedList(scenario.expectedSymbols)}`;
+}
+function renderLifecycle(scenario) {
+    const lifecycle = scenario.lifecycle;
+    if (!lifecycle) {
+        return `<h4>Lifecycle Integrity</h4><p>Not available for this scenario.</p>`;
+    }
+    return `<h4>Lifecycle Integrity</h4>
+    ${table(["Field", "Value"], [
+        ["Pre-mutation equivalence", lifecycle.preMutationEquivalence],
+        ["Post-mutation equivalence", lifecycle.postMutationEquivalence],
+        ["my-dev-kit version", lifecycle.myDevKitVersion ?? "unavailable"],
+        ["Stale baseline freshness", lifecycle.staleBaselineFreshnessStatus],
+        ["Full-refresh baseline freshness", lifecycle.fullRefreshBaselineFreshnessStatus],
+        ["Full-refresh refreshed freshness", lifecycle.fullRefreshRefreshedFreshnessStatus ?? "unavailable"]
+    ])}
+    <p>Controlled file paths:</p>
+    ${boundedList(lifecycle.controlledFilePaths)}
+    <p>Source roots:</p>
+    ${boundedList(lifecycle.sourceRoots)}`;
+}
+function renderAffectedNeighborhoodSection(scenario) {
+    const stale = scenario.staleTreatment?.affectedNeighborhood ?? null;
+    const fullRefresh = scenario.fullRefreshTreatment?.affectedNeighborhood ?? null;
+    if (!stale && !fullRefresh) {
+        return `<h4>Affected-Neighborhood Evidence (Changed Baseline Neighborhood Relative To The Task)</h4><p>Not available.</p>`;
+    }
+    const symmetric = symmetricAffectedNeighborhood(scenario);
+    if (!symmetric) {
+        return `<h4>Affected-Neighborhood Evidence (Changed Baseline Neighborhood Relative To The Task)</h4><p>inconsistent persisted evidence</p>`;
+    }
+    const explanation = REINDEX_RECOMMENDATION_EXPLANATIONS[symmetric.reindexRecommendation];
+    return `<h4>Affected-Neighborhood Evidence (Changed Baseline Neighborhood Relative To The Task)</h4>
+    ${table(["Field", "Value"], [
+        ["Relationship", symmetric.relationship],
+        ["Reindex recommendation", symmetric.reindexRecommendation],
+        ["Changed indexed files", formatAffectedNumber(symmetric.changedFileCount)],
+        ["Changed baseline symbols", formatAffectedNumber(symmetric.changedSymbolCount)],
+        ["Affected graph nodes", formatAffectedNumber(symmetric.affectedNodeCount)],
+        ["Affected graph edges", formatAffectedNumber(symmetric.affectedEdgeCount)],
+        ["Task-overlap nodes", formatAffectedNumber(symmetric.taskOverlapCount)],
+        ["Task-overlap percent", formatAffectedNumber(symmetric.taskOverlapPercent)]
+    ])}
+    <p>${escapeHtml(explanation)}</p>`;
+}
+function renderTreatment(title, treatment) {
+    if (!treatment) {
+        return `<h4>${escapeHtml(title)}</h4><p>Not available.</p>`;
+    }
+    const retrieval = treatment.retrieval;
+    const fakeAgent = treatment.fakeAgent;
+    const requiredFileEvidence = treatment.requiredFileEvidence;
+    return `<h4>${escapeHtml(title)}</h4>
+    ${table(["Field", "Value"], [
+        ["Treatment status", treatment.status],
+        ["Failure reason", treatment.failureReason ?? "not applicable"],
+        ["Active index phase", treatment.activeIndexPhase],
+        ["Baseline freshness status", treatment.baselineFreshness.status]
+    ])}
+    <p><strong>Retrieval</strong> (bounded evidence; full retrieved context body is never rendered here)</p>
+    ${table(["Field", "Value"], [
+        ["Status", retrieval.status],
+        ["Selected node ID", retrieval.selectedNodeId ?? "unavailable"],
+        ["Selected file", retrieval.selectedFile ?? "unavailable"],
+        ["Selected symbol", retrieval.selectedSymbol ?? "unavailable"],
+        ["Context characters", String(retrieval.totalChars)],
+        ["Estimated context tokens", String(retrieval.totalEstimatedTokens)],
+        ["Duration (ms)", String(retrieval.durationMs)]
+    ])}
+    <p>Files read:</p>
+    ${boundedList(retrieval.filesRead)}
+    <p>Retrieval warnings:</p>
+    ${boundedList(retrieval.warnings)}
+    <p><strong>Fake-Agent Evidence</strong> (deterministic fake-agent / simulated harness evidence, not a provider or real-model measurement)</p>
+    ${fakeAgent
+        ? table(["Field", "Value"], [
+            ["Status", fakeAgent.status],
+            ["Correctness score", fakeAgent.correctness.available && fakeAgent.correctness.score !== null ? String(fakeAgent.correctness.score) : "unavailable"],
+            ["Passed", fakeAgent.correctness.passed === null ? "unavailable" : String(fakeAgent.correctness.passed)],
+            ["Duration (ms)", fakeAgent.durationMs === null ? "unavailable" : String(fakeAgent.durationMs)]
+        ])
+        : "<p>Not run for this treatment.</p>"}
+    <p><strong>Required-File Evidence</strong> (bounded answer-key file-presence check, not retrieval precision/recall)</p>
+    ${table(["Field", "Value"], [
+        ["Status", requiredFileEvidence.status],
+        ["Reason", requiredFileEvidence.reason ?? "not applicable"]
+    ])}
+    <p>Required files:</p>
+    ${boundedList(requiredFileEvidence.requiredFiles)}
+    <p>Observed files:</p>
+    ${boundedList(requiredFileEvidence.observedFiles)}
+    <p>Missing files:</p>
+    ${boundedList(requiredFileEvidence.missingFiles)}`;
+}
+function renderComparison(scenario) {
+    const comparison = scenario.comparison;
+    const explanation = STALE_RISK_CLASSIFICATION_EXPLANATIONS[comparison.staleRiskClassification];
+    return `<h4>Matched Comparison</h4>
+    ${table(["Field", "Value"], [
+        ["Correctness relation", comparison.correctnessRelation],
+        ["Required-file evidence relation", comparison.requiredFileEvidenceRelation],
+        ["Stale-risk classification", comparison.staleRiskClassification]
+    ])}
+    <p>Reason codes:</p>
+    ${list(comparison.reasonCodes)}
+    <p>${escapeHtml(explanation)}</p>`;
+}
+function formatAffectedNumber(value) {
+    return value === null ? "unavailable" : String(value);
+}
+function boundedList(items) {
+    if (items.length === 0)
+        return "<p>none</p>";
+    const shown = items.slice(0, MAX_DISPLAY_ITEMS);
+    const omitted = items.length - shown.length;
+    return `${list(shown)}${omitted > 0 ? `<p class="muted">... ${omitted} more</p>` : ""}`;
+}
+function list(items) {
+    if (items.length === 0)
+        return "<ul><li>none</li></ul>";
+    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;");
+}

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

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