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

package/dist/src/evaluation/indexSnapshot.js

@@ -228,7 +228,7 @@ async function enumerateIndexArtifacts(indexDir) {
     artifacts.sort((left, right) => compareCodeUnits(left.path, right.path));
     return { artifacts, truncated };
 }
-async function readJson(filePath) {
+export async function readJson(filePath) {
     let text;
     try {
         text = await readFile(filePath, "utf8");

package/dist/src/experiments/plugins/warmIndexReuse/execution.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { resolveWithinRoot } from "../../../core/pathSafety.js";
+import { assessAffectedNeighborhood, mapAffectedNeighborhoodSeeds, } from "../../../evaluation/affectedNeighborhood.js";
 import { assessIndexFreshness } from "../../../evaluation/indexFreshness.js";
 import { runMyDevKitRetrievalFromIndex } from "../../../evaluation/runMyDevKitRetrieval.js";
 import { runRawFullFileBaseline } from "../../../evaluation/runRawFullFileBaseline.js";
@@ -92,6 +93,7 @@ async function executeTask(args) {
     let warmRetrieval;
     let warmStatus = "failed";
     let indexFreshness;
+    let affectedNeighborhood = null;
     if (!args.session) {
         errors.push(args.setupFailure ?? { side: "warm", code: "warm-index-setup-failed", message: "No warm index session." });
         // No snapshot exists, so freshness is conservatively unknown rather than assumed.
@@ -115,6 +117,24 @@ async function executeTask(args) {
                 targetRoot: args.session.targetRoot,
                 sourceRoots: args.session.sourceRoots,
             });
+            // Observational and in-memory: this task's freshness against the shared baseline graph. It
+            // reads no files, runs no my-dev-kit command, and cannot stop the retrieval below.
+            try {
+                const seedMapping = mapAffectedNeighborhoodSeeds({
+                    indexSnapshot: args.session.indexSnapshot,
+                    freshness: indexFreshness,
+                    graph: args.session.affectedNeighborhoodGraph,
+                });
+                affectedNeighborhood = assessAffectedNeighborhood({
+                    graph: args.session.affectedNeighborhoodGraph,
+                    seedMapping,
+                    task: evaluationCase,
+                });
+            }
+            catch (error) {
+                affectedNeighborhood = null;
+                warnings.push(`Affected-neighborhood assessment was not recorded: ${errorMessage(error)}`);
+            }
             try {
                 // requireKit: false retains subordinate command evidence; a skipped result caused by a
                 // failed command is classified as failed below rather than as an honest skip.
@@ -149,6 +169,7 @@ async function executeTask(args) {
         rawBaseline,
         warmRetrieval,
         indexFreshness,
+        affectedNeighborhood,
         warnings,
         errors,
     };

package/dist/src/experiments/plugins/warmIndexReuse/executionArtifact.js

@@ -47,6 +47,7 @@ function summarizeTask(task) {
             }
             : null,
         indexFreshness: task.indexFreshness ? structuredClone(task.indexFreshness) : null,
+        affectedNeighborhood: task.affectedNeighborhood ? structuredClone(task.affectedNeighborhood) : null,
         warnings: [...task.warnings],
         errors: task.errors.map((error) => ({ ...error })),
     };

package/dist/src/experiments/plugins/warmIndexReuse/metrics.js

@@ -147,6 +147,7 @@ export function calculateWarmIndexProjectMetrics(project, agentEvidence) {
                 cumulativeComponentDurationMs: warmDuration.add(warm.retrievalDurationMs, label("warm retrieval duration")),
                 cumulativeEstimatedContextTokens: warmTokens.add(warm.contextEstimatedTokens, label("warm estimated context tokens")),
                 ...warmAgent,
+                ...affectedNeighborhoodMetrics(task),
                 cumulativeAgentTotalTokens: warmAgentTokens.add(warmAgent.agentTotalTokens, label("warm agent total tokens")),
             },
         };
@@ -192,6 +193,35 @@ function warmDirect(task) {
         retrievalDurationMs: availableMetric(warm.durationMs, "ms", "measured"),
     };
 }
+const NO_AFFECTED_NEIGHBORHOOD_REASON = "No affected-neighborhood assessment was recorded for this task.";
+/**
+ * Converts the persisted affected-neighborhood assessment into the six warm-side metrics, once.
+ * A finite value (including zero) is available; an absent assessment or a null field is
+ * unavailable with a reason, never zero. The metric layer alone owns these value objects.
+ */
+function affectedNeighborhoodMetrics(task) {
+    const assessment = task.affectedNeighborhood;
+    const one = (field, label) => {
+        const unit = field === "taskOverlapPercent" ? "percent" : "count";
+        if (!assessment)
+            return unavailableMetric(unit, "derived", NO_AFFECTED_NEIGHBORHOOD_REASON);
+        const value = assessment[field];
+        if (typeof value === "number")
+            return availableMetric(value, unit, "derived");
+        const context = `assessment ${assessment.status}; seed mapping ${assessment.seedMappingStatus}; ` +
+            `graph ${assessment.graphEvidenceStatus}; neighborhood ${assessment.neighborhoodStatus}; task mapping ${assessment.taskMapping.status}` +
+            (field === "taskOverlapPercent" ? `; resolvable task nodes ${assessment.taskMapping.resolvableTaskNodeCount}` : "");
+        return unavailableMetric(unit, "derived", `Affected-neighborhood evidence did not establish ${label} (${context}).`);
+    };
+    return {
+        changedFileCount: one("changedFileCount", "the changed indexed file count"),
+        changedSymbolCount: one("changedSymbolCount", "the changed baseline symbol count"),
+        affectedNodeCount: one("affectedNodeCount", "the affected graph node count"),
+        affectedEdgeCount: one("affectedEdgeCount", "the affected graph edge count"),
+        taskOverlapCount: one("taskOverlapCount", "the task-overlap node count"),
+        taskOverlapPercent: one("taskOverlapPercent", "the task-overlap percent"),
+    };
+}
 /** Pure, order-preserving calculation; ordinals and cumulative state restart for every project. */
 export function calculateWarmIndexMetrics(projects, agentEvidence) {
     if (agentEvidence && agentEvidence.length !== projects.length) {
@@ -222,8 +252,49 @@ export function toWarmOutcomeMetrics(task, variantId) {
         { id: "cumulative-context-estimated-token-count", name: "Cumulative estimated context tokens", description: "Sum of retrieved estimated context tokens for tasks 1..N in this project; not provider token usage.", metric: task.warm.cumulativeEstimatedContextTokens },
         { id: "amortized-index-build-duration-ms", name: "Amortized index build duration", description: "Index build duration divided by this task's ordinal within its project.", metric: task.warm.amortizedIndexBuildDurationMs },
         ...agentSpecs(task.warm),
+        ...affectedNeighborhoodSpecs(task.warm),
     ]);
 }
+function affectedNeighborhoodSpecs(warm) {
+    return [
+        {
+            id: "affected-neighborhood-changed-file-count",
+            name: "Changed indexed files",
+            description: "Unique confirmed modified or missing files that the baseline index snapshot represents; new or non-indexed files are not counted.",
+            metric: warm.changedFileCount,
+        },
+        {
+            id: "affected-neighborhood-changed-symbol-count",
+            name: "Changed baseline symbols",
+            description: "Baseline indexed symbol identities (file path + name) belonging to confirmed changed indexed files; not proof that each symbol's own source text changed.",
+            metric: warm.changedSymbolCount,
+        },
+        {
+            id: "affected-neighborhood-node-count",
+            name: "Affected graph nodes",
+            description: "Unique resolved seed nodes plus their direct one-hop baseline graph neighbors, over edges of any kind and direction.",
+            metric: warm.affectedNodeCount,
+        },
+        {
+            id: "affected-neighborhood-edge-count",
+            name: "Affected graph edges",
+            description: "Unique baseline graph edges incident to at least one resolved seed node; not the induced subgraph of all affected nodes.",
+            metric: warm.affectedEdgeCount,
+        },
+        {
+            id: "affected-neighborhood-task-overlap-count",
+            name: "Task-overlap nodes",
+            description: "Unique baseline graph nodes that are both in the affected neighborhood and resolved from the task's expected files and symbols.",
+            metric: warm.taskOverlapCount,
+        },
+        {
+            id: "affected-neighborhood-task-overlap-percent",
+            name: "Task-overlap percent",
+            description: "Task-overlap nodes as a percentage of resolvable task graph nodes; unresolved or ambiguous expected metadata is not in the denominator.",
+            metric: warm.taskOverlapPercent,
+        },
+    ];
+}
 function agentSpecs(side) {
     return [
         {

package/dist/src/experiments/plugins/warmIndexReuse/warmIndexSession.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { buildMyDevKitIndex, probeMyDevKitVersion } from "../../../evaluation/runMyDevKitRetrieval.js";
+import { loadAffectedNeighborhoodGraphEvidence } from "../../../evaluation/affectedNeighborhood.js";
 import { captureIndexSnapshot } from "../../../evaluation/indexSnapshot.js";
 /**
  * Builds the index once through the shared `buildMyDevKitIndex` owner. A build that reports
@@ -31,13 +32,20 @@ export async function prepareWarmIndexSession(options) {
         command: build.command,
         tool
     });
+    // Loaded once per session from the manifest-referenced artifacts; never fails the session.
+    const affectedNeighborhoodGraph = await loadAffectedNeighborhoodGraphEvidence({
+        indexDir: build.indexDir,
+        sourceRoots,
+        indexSnapshot
+    });
     const session = Object.freeze({
         indexDir: build.indexDir,
         buildDurationMs: build.durationMs,
         targetRoot: options.target.absoluteTargetRoot,
         sourceRoots,
         buildCommand: build.command,
-        indexSnapshot
+        indexSnapshot,
+        affectedNeighborhoodGraph
     });
     return { ok: true, session, build };
 }

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

@@ -107,6 +107,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 +130,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 +156,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/renderPluginExperimentReportText.js

@@ -302,6 +302,7 @@ function renderWarmIndexReuseSection(lines, section) {
     lines.push(fieldLine("Agent Correctness Available (task sides)", `${section.summary.agentCorrectnessAvailableCount} of ${section.summary.agentSideCount}`));
     lines.push(fieldLine("Agent Token Totals Available (task sides)", `${section.summary.agentTotalTokensAvailableCount} of ${section.summary.agentSideCount}`));
     renderFreshnessSummary(lines, section);
+    renderAffectedNeighborhoodSummary(lines, section);
     if (section.agentCampaign) {
         renderCampaignSection(lines, section.agentCampaign);
     }
@@ -326,6 +327,7 @@ function renderWarmIndexReuseSection(lines, section) {
                 ["Raw Status", task.rawStatus],
                 ["Warm Status", task.warmStatus],
                 ["Index Freshness Status", task.indexFreshness ? task.indexFreshness.status : "not assessed"],
+                ["Affected Neighborhood Status", task.affectedNeighborhood ? task.affectedNeighborhood.status : "not assessed"],
                 ["Raw Context Characters", formatWarmMetric(task.raw.contextCharacters)],
                 ["Warm Context Characters", formatWarmMetric(task.warm.contextCharacters)],
                 ["Raw Estimated Context Tokens (estimate)", formatWarmMetric(task.raw.contextEstimatedTokens)],
@@ -350,6 +352,7 @@ function renderWarmIndexReuseSection(lines, section) {
                 lines.push(fieldLine(label, value));
             }
             renderTaskFreshnessDetail(lines, task.indexFreshness);
+            renderTaskAffectedNeighborhoodDetail(lines, task.affectedNeighborhood);
         }
     });
 }
@@ -371,6 +374,87 @@ function renderFreshnessSummary(lines, section) {
     lines.push(fieldLine("Partially-Stale Tasks", summary.partiallyStaleTaskCount));
     lines.push(fieldLine("Unknown Tasks", summary.unknownTaskCount));
 }
+function renderAffectedNeighborhoodSummary(lines, section) {
+    // Reports serialized before v0.6.1 lack the summary; render them as having no assessment.
+    const summary = section.affectedNeighborhoodSummary ?? {
+        assessedTaskCount: 0,
+        unassessedTaskCount: section.summary.taskCount,
+        completeAssessmentCount: 0,
+        partialAssessmentCount: 0,
+        unavailableAssessmentCount: 0,
+        relatedTaskCount: 0,
+        unrelatedTaskCount: 0,
+        unknownRelationshipTaskCount: 0,
+        recommendedReindexCount: 0,
+        notIndicatedReindexCount: 0,
+        unknownReindexRecommendationCount: 0,
+    };
+    pushSection(lines, "Affected Neighborhood Summary");
+    lines.push(fieldLine("Assessed Tasks", summary.assessedTaskCount));
+    lines.push(fieldLine("Unassessed Tasks", summary.unassessedTaskCount));
+    lines.push(fieldLine("Complete Assessments", summary.completeAssessmentCount));
+    lines.push(fieldLine("Partial Assessments", summary.partialAssessmentCount));
+    lines.push(fieldLine("Unavailable Assessments", summary.unavailableAssessmentCount));
+    lines.push(fieldLine("Related Tasks", summary.relatedTaskCount));
+    lines.push(fieldLine("Unrelated Tasks", summary.unrelatedTaskCount));
+    lines.push(fieldLine("Unknown-Relationship Tasks", summary.unknownRelationshipTaskCount));
+    lines.push(fieldLine("Reindex Recommended", summary.recommendedReindexCount));
+    lines.push(fieldLine("Reindex Not Indicated", summary.notIndicatedReindexCount));
+    lines.push(fieldLine("Reindex Recommendation Unknown", summary.unknownReindexRecommendationCount));
+}
+/** Renders the persisted affected-neighborhood evidence; numeric lines come from the metric owner. */
+function renderTaskAffectedNeighborhoodDetail(lines, evidence) {
+    if (!evidence)
+        return;
+    lines.push(fieldLine("Affected Neighborhood Relationship", evidence.relationship));
+    lines.push(fieldLine("Reindex Recommendation", evidence.reindexRecommendation));
+    lines.push(fieldLine("Reindex Recommendation Explanation", evidence.recommendationExplanation));
+    lines.push(fieldLine("Affected Neighborhood Freshness Status", evidence.freshnessStatus));
+    lines.push(fieldLine("Seed Mapping Status", evidence.seedMappingStatus));
+    lines.push(fieldLine("Graph Evidence Status", evidence.graphEvidenceStatus));
+    lines.push(fieldLine("Neighborhood Status", evidence.neighborhoodStatus));
+    lines.push(fieldLine("Task Mapping Status", evidence.taskMappingStatus));
+    lines.push(fieldLine("Resolvable Task Nodes", evidence.resolvableTaskNodeCount));
+    lines.push(fieldLine("Changed Indexed Files", formatWarmMetric(evidence.metrics.changedFileCount)));
+    lines.push(fieldLine("Changed Baseline Symbols", formatWarmMetric(evidence.metrics.changedSymbolCount)));
+    lines.push(fieldLine("Affected Graph Nodes", formatWarmMetric(evidence.metrics.affectedNodeCount)));
+    lines.push(fieldLine("Affected Graph Edges", formatWarmMetric(evidence.metrics.affectedEdgeCount)));
+    lines.push(fieldLine("Task-Overlap Nodes", formatWarmMetric(evidence.metrics.taskOverlapCount)));
+    lines.push(fieldLine("Task-Overlap Percent", formatWarmMetric(evidence.metrics.taskOverlapPercent)));
+    lines.push("Affected Node IDs:");
+    pushFreshnessBoundedNote(lines, evidence.affectedNodeIds);
+    if (evidence.affectedNodeIds.items.length === 0)
+        lines.push("- none");
+    for (const id of evidence.affectedNodeIds.items)
+        lines.push(`- ${sanitizeScalar(id)}`);
+    lines.push("Participating Edge IDs:");
+    pushFreshnessBoundedNote(lines, evidence.participatingEdgeIds);
+    if (evidence.participatingEdgeIds.items.length === 0)
+        lines.push("- none");
+    for (const id of evidence.participatingEdgeIds.items)
+        lines.push(`- ${sanitizeScalar(id)}`);
+    lines.push("Unresolved Task Mappings:");
+    pushFreshnessBoundedNote(lines, evidence.unresolvedTaskMappings);
+    if (evidence.unresolvedTaskMappings.items.length === 0)
+        lines.push("- none");
+    for (const entry of evidence.unresolvedTaskMappings.items) {
+        lines.push(`- ${sanitizeScalar(entry.subject)} ${sanitizeScalar(entry.name)} [${sanitizeScalar(entry.reason)}]`);
+    }
+    lines.push("Ambiguous Task Symbols:");
+    pushFreshnessBoundedNote(lines, evidence.ambiguousTaskSymbols);
+    if (evidence.ambiguousTaskSymbols.items.length === 0)
+        lines.push("- none");
+    for (const entry of evidence.ambiguousTaskSymbols.items) {
+        lines.push(`- ${sanitizeScalar(entry.name)}: ${entry.candidateNodeIds.map((id) => sanitizeScalar(id)).join(", ")}`);
+    }
+    lines.push("Affected Neighborhood Warnings:");
+    pushFreshnessBoundedNote(lines, evidence.warnings);
+    if (evidence.warnings.items.length === 0)
+        lines.push("- none");
+    for (const warning of evidence.warnings.items) {
+        lines.push(`- [${sanitizeScalar(warning.code)}] ${sanitizeScalar(warning.message)}`);
+    }
+}
 function pushFreshnessBoundedNote(lines, list) {
     if (list.omittedCount > 0) {
         lines.push(`Displayed: ${list.displayedCount} of ${list.totalCount}`);

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

@@ -5,6 +5,8 @@ const UNIT_LABELS = {
     "estimated-tokens": "est. tokens",
     tokens: "tokens",
     score: "score",
+    count: "",
+    percent: "%",
 };
 export function renderWarmIndexReuseHtml(section) {
     if (section === null) {
@@ -26,6 +28,7 @@ export function renderWarmIndexReuseHtml(section) {
         ["Agent token totals available", `${section.summary.agentTotalTokensAvailableCount} of ${section.summary.agentSideCount}`],
     ])}
     ${renderFreshnessSummary(section.indexFreshnessSummary ?? legacyFreshnessSummary(section.summary.taskCount))}
+    ${renderAffectedNeighborhoodSummary(section.affectedNeighborhoodSummary ?? legacyAffectedNeighborhoodSummary(section.summary.taskCount))}
     ${section.agentCampaign ? renderCampaignSection(section.agentCampaign) : ""}
     <h3>Cold Start And Warm Reuse</h3>
     ${list(section.costModel)}
@@ -45,6 +48,100 @@ function legacyFreshnessSummary(taskCount) {
         unknownTaskCount: 0,
     };
 }
+// Reports serialized before v0.6.1 lack the summary; they are rendered as having no assessment.
+function legacyAffectedNeighborhoodSummary(taskCount) {
+    return {
+        assessedTaskCount: 0,
+        unassessedTaskCount: taskCount,
+        completeAssessmentCount: 0,
+        partialAssessmentCount: 0,
+        unavailableAssessmentCount: 0,
+        relatedTaskCount: 0,
+        unrelatedTaskCount: 0,
+        unknownRelationshipTaskCount: 0,
+        recommendedReindexCount: 0,
+        notIndicatedReindexCount: 0,
+        unknownReindexRecommendationCount: 0,
+    };
+}
+function renderAffectedNeighborhoodSummary(summary) {
+    return `<h3>Affected Neighborhood</h3>
+    ${table(["Field", "Value"], [
+        ["Assessed tasks", String(summary.assessedTaskCount)],
+        ["Unassessed tasks", String(summary.unassessedTaskCount)],
+        ["Complete assessments", String(summary.completeAssessmentCount)],
+        ["Partial assessments", String(summary.partialAssessmentCount)],
+        ["Unavailable assessments", String(summary.unavailableAssessmentCount)],
+        ["Related tasks", String(summary.relatedTaskCount)],
+        ["Unrelated tasks", String(summary.unrelatedTaskCount)],
+        ["Unknown-relationship tasks", String(summary.unknownRelationshipTaskCount)],
+        ["Reindex recommended", String(summary.recommendedReindexCount)],
+        ["Reindex not indicated", String(summary.notIndicatedReindexCount)],
+        ["Reindex recommendation unknown", String(summary.unknownReindexRecommendationCount)],
+    ])}`;
+}
+function boundedNote(label, taskOrdinal, bounded) {
+    return bounded.omittedCount > 0 ? [`Task ${taskOrdinal}: ${bounded.omittedCount} of ${bounded.totalCount} ${label} omitted.`] : [];
+}
+/** Persisted affected-neighborhood evidence per task; numeric cells are the metric owner's objects. */
+function renderProjectAffectedNeighborhood(tasks) {
+    const overview = table(["Task", "Assessment", "Relationship", "Reindex recommendation", "Freshness", "Seeds", "Neighborhood", "Task mapping", "Resolvable task nodes"], tasks.map((task) => {
+        const label = `${task.taskOrdinal}. ${task.caseId}`;
+        const evidence = task.affectedNeighborhood;
+        return evidence
+            ? [
+                label,
+                evidence.status,
+                evidence.relationship,
+                evidence.reindexRecommendation,
+                evidence.freshnessStatus,
+                evidence.seedMappingStatus,
+                evidence.neighborhoodStatus,
+                evidence.taskMappingStatus,
+                String(evidence.resolvableTaskNodeCount),
+            ]
+            : [label, "not assessed", "", "", "", "", "", "", ""];
+    }));
+    const assessed = tasks.filter((task) => task.affectedNeighborhood !== null);
+    const metricRows = assessed.map((task) => {
+        const metrics = task.affectedNeighborhood.metrics;
+        return [
+            `${task.taskOrdinal}. ${task.caseId}`,
+            withReason(metrics.changedFileCount),
+            withReason(metrics.changedSymbolCount),
+            withReason(metrics.affectedNodeCount),
+            withReason(metrics.affectedEdgeCount),
+            withReason(metrics.taskOverlapCount),
+            withReason(metrics.taskOverlapPercent),
+        ];
+    });
+    const explanations = assessed.map((task) => `Task ${task.taskOrdinal}: ${task.affectedNeighborhood.recommendationExplanation}`);
+    const detailRows = assessed.flatMap((task) => {
+        const evidence = task.affectedNeighborhood;
+        const label = `${task.taskOrdinal}. ${task.caseId}`;
+        return [
+            ...evidence.unresolvedTaskMappings.items.map((entry) => [label, `unresolved ${entry.subject}`, entry.name, entry.reason]),
+            ...evidence.ambiguousTaskSymbols.items.map((entry) => [label, "ambiguous expected-symbol", entry.name, entry.candidateNodeIds.join(", ")]),
+            ...evidence.warnings.items.map((warning) => [label, "warning", warning.code, warning.message]),
+        ];
+    });
+    const omitted = assessed.flatMap((task) => {
+        const evidence = task.affectedNeighborhood;
+        return [
+            ...boundedNote("affected node IDs", task.taskOrdinal, evidence.affectedNodeIds),
+            ...boundedNote("participating edge IDs", task.taskOrdinal, evidence.participatingEdgeIds),
+            ...boundedNote("unresolved task mappings", task.taskOrdinal, evidence.unresolvedTaskMappings),
+            ...boundedNote("ambiguous task symbols", task.taskOrdinal, evidence.ambiguousTaskSymbols),
+            ...boundedNote("warnings", task.taskOrdinal, evidence.warnings),
+        ];
+    });
+    return `<h4>Affected Neighborhood</h4>
+    ${overview}
+    ${metricRows.length === 0 ? "" : table(["Task", "Changed files", "Changed symbols", "Affected nodes", "Affected edges", "Task-overlap nodes", "Task-overlap percent"], metricRows)}
+    ${explanations.length === 0 ? "" : list(explanations)}
+    ${detailRows.length === 0 ? "" : table(["Task", "Evidence type", "Name", "Detail"], detailRows)}
+    ${omitted.length === 0 ? "" : list(omitted)}`;
+}
 function renderFreshnessSummary(summary) {
     return `<h3>Index Freshness</h3>
     ${table(["Field", "Value"], [
@@ -184,6 +281,7 @@ function renderProject(project, index, agentId) {
         formatMetric(task.warm.cumulativeEstimatedContextTokens),
     ]))}
     ${renderProjectFreshness(project.tasks)}
+    ${renderProjectAffectedNeighborhood(project.tasks)}
     <p class="muted">Estimated tokens are character-based context-size estimates, not provider token usage.</p>
     <p class="muted">${agentColumnsNote(agentId)}</p>
     ${table([

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

@@ -2,3 +2,8 @@ export const WARM_INDEX_REUSE_REPORT_SCHEMA_VERSION = "my-dev-kit-lab-warm-index
 /** Report presentation limits; the full persisted lists stay in warm-index-execution.json. */
 export const MAX_REPORT_FRESHNESS_CHANGES = 20;
 export const MAX_REPORT_FRESHNESS_UNRESOLVED = 10;
+export const MAX_REPORT_AFFECTED_NODES = 20;
+export const MAX_REPORT_AFFECTED_EDGES = 20;
+export const MAX_REPORT_AFFECTED_TASK_UNRESOLVED = 10;
+export const MAX_REPORT_AFFECTED_TASK_AMBIGUOUS = 10;
+export const MAX_REPORT_AFFECTED_WARNINGS = 10;