@praneeth_54/agentdoctor 2.1.0 → 3.0.1

package/dist/product/techdebt/roadmap.d.ts

@@ -0,0 +1,20 @@
+import type { ProductEvidence, TruthLabel } from "../truth.js";
+export interface TechnicalDebtItem {
+    id: string;
+    category: "todo" | "fixme" | "architecture" | "testing";
+    summary: string;
+    truth: TruthLabel;
+    evidence: ProductEvidence[];
+}
+export interface TechnicalDebtRoadmap {
+    root: string;
+    items: TechnicalDebtItem[];
+    metrics: {
+        todoCount: number;
+        fixmeCount: number;
+        testRatio: number | null;
+        architectureViolations: number;
+    };
+    limitations: string[];
+}
+export declare function buildTechnicalDebtRoadmap(rootInput: string): Promise<TechnicalDebtRoadmap>;

package/dist/product/techdebt/roadmap.js

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { checkArchitectureAtRoot } from "../../architecture/contract.js";
+import { detectProject } from "../../detectors/project.js";
+import { buildRepositoryGraph } from "../../platform/graph/build.js";
+import { readTextFile } from "../../utils/fs.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+function isTestPath(relativePath) {
+    const p = relativePath.toLowerCase();
+    return (p.includes(".test.") ||
+        p.includes(".spec.") ||
+        p.startsWith("tests/") ||
+        p.startsWith("test/") ||
+        p.includes("__tests__/"));
+}
+function isSourcePath(relativePath) {
+    const p = relativePath.toLowerCase();
+    if (isTestPath(p))
+        return false;
+    return /\.(ts|tsx|js|jsx|py|php|go|rs)$/i.test(p);
+}
+export async function buildTechnicalDebtRoadmap(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const limitations = [
+        "Roadmap aggregates TODO/FIXME markers, architecture contract violations, and test-ratio heuristics.",
+        "Not a substitute for issue trackers or formal debt scoring.",
+    ];
+    const detection = await detectProject(root);
+    const paths = detection.discovery.files.map((f) => f.relativePath.replace(/\\/g, "/"));
+    const sourceFiles = paths.filter(isSourcePath);
+    const testFiles = paths.filter(isTestPath);
+    let todoCount = 0;
+    let fixmeCount = 0;
+    const items = [];
+    const re = /\b(TODO|FIXME)\b(:[^\n]*)?/g;
+    for (const rel of paths) {
+        const text = await readTextFile(path.join(root, rel), 256 * 1024);
+        if (text === null)
+            continue;
+        re.lastIndex = 0;
+        let match;
+        while ((match = re.exec(text)) !== null) {
+            const kind = match[1] === "FIXME" ? "fixme" : "todo";
+            if (kind === "todo")
+                todoCount++;
+            else
+                fixmeCount++;
+            if (items.filter((i) => i.category === kind).length < 15) {
+                const line = text.slice(0, match.index).split("\n").length;
+                items.push({
+                    id: `${kind}-${rel}-${line}`,
+                    category: kind,
+                    summary: (match[0] ?? kind).trim().slice(0, 100),
+                    truth: "VERIFIED",
+                    evidence: [
+                        {
+                            path: rel,
+                            line,
+                            ...(() => {
+                                const excerpt = text.split(/\r?\n/)[line - 1]?.trim().slice(0, 120);
+                                return excerpt !== undefined && excerpt.length > 0 ? { excerpt } : {};
+                            })(),
+                        },
+                    ],
+                });
+            }
+        }
+    }
+    let architectureViolations = 0;
+    try {
+        const graph = await buildRepositoryGraph(root);
+        const arch = await checkArchitectureAtRoot(root, graph);
+        architectureViolations = arch.violations.length;
+        for (const v of arch.violations.slice(0, 10)) {
+            items.push({
+                id: `arch-${v.ruleId}-${v.fromPath ?? v.toPath ?? "root"}`,
+                category: "architecture",
+                summary: v.description.slice(0, 120),
+                truth: "VERIFIED",
+                evidence: [
+                    {
+                        path: v.fromPath || v.toPath || ".",
+                        excerpt: `${v.ruleId}: ${v.description}`.slice(0, 120),
+                    },
+                ],
+            });
+        }
+    }
+    catch {
+        limitations.push("Architecture contract check unavailable or failed.");
+    }
+    const denom = sourceFiles.length + testFiles.length;
+    const testRatio = denom === 0 ? null : testFiles.length / denom;
+    if (testRatio !== null && testRatio < 0.15) {
+        items.push({
+            id: "testing-low-ratio",
+            category: "testing",
+            summary: `Low test-file ratio (${testRatio.toFixed(3)}) — consider adding tests`,
+            truth: "INFERRED",
+            evidence: [
+                {
+                    path: ".",
+                    excerpt: `tests=${testFiles.length}, sources=${sourceFiles.length}`,
+                },
+            ],
+        });
+    }
+    return {
+        root,
+        items,
+        metrics: {
+            todoCount,
+            fixmeCount,
+            testRatio,
+            architectureViolations,
+        },
+        limitations,
+    };
+}

package/dist/product/testbrain/analyze.d.ts

@@ -0,0 +1,29 @@
+import { type AnalyzeTestImpactOptions, type TestImpactReport } from "../../platform/test-impact/analyze.js";
+import type { RepositoryGraph } from "../../platform/types.js";
+export type FileTestMappingEvidence = "graph-import" | "naming-heuristic" | "impact-recommendation";
+export interface FileTestMapping {
+    sourceFile: string;
+    testFiles: string[];
+    evidence: FileTestMappingEvidence[];
+    confidence: number;
+}
+export interface TestBrainGraphStats {
+    testFileNodes: number;
+    sourceToTestLinks: number;
+    importEdgesFromTests: number;
+}
+export interface TestBrainReport {
+    root: string;
+    staticAnalysisLabel: "TECHNICAL_STATIC_ANALYSIS_SUPPORTED";
+    testImpact: TestImpactReport;
+    fileTestMappings: FileTestMapping[];
+    graphStats: TestBrainGraphStats;
+    limitations: string[];
+}
+export declare function mapTestsFromGraph(graph: RepositoryGraph): Map<string, Set<string>>;
+/**
+ * Test Brain — combines git test-impact with repository graph test↔source import links.
+ * Does not execute tests.
+ */
+export declare function analyzeTestBrain(rootInput: string | AnalyzeTestImpactOptions, maybeOptions?: AnalyzeTestImpactOptions): Promise<TestBrainReport>;
+export declare function persistTestBrainReport(rootInput: string, report: TestBrainReport): Promise<string>;

package/dist/product/testbrain/analyze.js

@@ -0,0 +1,129 @@
+import path from "node:path";
+import { buildRepositoryGraph } from "../../platform/graph/build.js";
+import { analyzeTestImpact, } from "../../platform/test-impact/analyze.js";
+import { writeJsonArtifact } from "../../platform/store.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+function isTestPath(file) {
+    return /\.(test|spec)\./i.test(file) || file.includes("__tests__");
+}
+function resolveRelativeImport(fromFile, specifier) {
+    if (!specifier.startsWith("."))
+        return null;
+    const dir = path.posix.dirname(fromFile.replace(/\\/g, "/"));
+    let resolved = path.posix.normalize(path.posix.join(dir, specifier));
+    if (!resolved.startsWith("."))
+        resolved = resolved.replace(/^\.\//, "");
+    return resolved;
+}
+function sourceCandidatesFromSpecifier(specifier, fromTest) {
+    const base = resolveRelativeImport(fromTest, specifier);
+    if (!base)
+        return [];
+    const exts = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".java", ".kt", ".rs", ".dart"];
+    const out = [base];
+    if (!path.posix.extname(base)) {
+        for (const ext of exts)
+            out.push(`${base}${ext}`);
+        out.push(`${base}/index.ts`, `${base}/index.js`);
+    }
+    return [...new Set(out)];
+}
+export function mapTestsFromGraph(graph) {
+    const sourceToTests = new Map();
+    const nodesById = new Map(graph.nodes.map((n) => [n.id, n]));
+    for (const edge of graph.edges) {
+        if (edge.kind !== "imports")
+            continue;
+        const fromNode = nodesById.get(edge.from);
+        const toNode = nodesById.get(edge.to);
+        if (!fromNode?.path || !isTestPath(fromNode.path))
+            continue;
+        const spec = toNode?.meta?.specifier ?? toNode?.label ?? "";
+        if (!spec || !spec.startsWith("."))
+            continue;
+        for (const candidate of sourceCandidatesFromSpecifier(spec, fromNode.path)) {
+            if (!sourceToTests.has(candidate))
+                sourceToTests.set(candidate, new Set());
+            sourceToTests.get(candidate).add(fromNode.path);
+        }
+    }
+    return sourceToTests;
+}
+function mergeMapping(map, sourceFile, testFile, evidence, confidence) {
+    const key = sourceFile.replace(/\\/g, "/");
+    const existing = map.get(key);
+    if (!existing) {
+        map.set(key, {
+            sourceFile: key,
+            testFiles: [testFile],
+            evidence: [evidence],
+            confidence,
+        });
+        return;
+    }
+    if (!existing.testFiles.includes(testFile))
+        existing.testFiles.push(testFile);
+    if (!existing.evidence.includes(evidence))
+        existing.evidence.push(evidence);
+    existing.confidence = Math.max(existing.confidence, confidence);
+    existing.testFiles.sort();
+}
+/**
+ * Test Brain — combines git test-impact with repository graph test↔source import links.
+ * Does not execute tests.
+ */
+export async function analyzeTestBrain(rootInput, maybeOptions) {
+    const options = typeof rootInput === "string" ? { ...(maybeOptions ?? {}), root: rootInput } : rootInput;
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const limitations = [
+        "Test Brain wraps test-impact plus graph import heuristics — not mutation testing or coverage oracle.",
+        "Graph file↔test links are import-based for test files only; missing imports are not proven absence of tests.",
+    ];
+    const testImpact = await analyzeTestImpact(options);
+    const graph = await buildRepositoryGraph(root);
+    const graphMap = mapTestsFromGraph(graph);
+    const mappingBySource = new Map();
+    for (const [source, tests] of graphMap) {
+        for (const testFile of tests) {
+            mergeMapping(mappingBySource, source, testFile, "graph-import", 0.85);
+        }
+    }
+    for (const changed of testImpact.changedFiles) {
+        if (isTestPath(changed))
+            continue;
+        const normalized = changed.replace(/\\/g, "/");
+        for (const rec of testImpact.recommendedTests) {
+            if (!rec.reason.includes(normalized))
+                continue;
+            const evidence = rec.evidence === "verified" ? "impact-recommendation" : "naming-heuristic";
+            mergeMapping(mappingBySource, normalized, rec.testPath, evidence, rec.confidence);
+        }
+    }
+    const fileTestMappings = [...mappingBySource.values()].sort((a, b) => a.sourceFile.localeCompare(b.sourceFile));
+    const testFileNodes = graph.nodes.filter((n) => n.kind === "test").length;
+    let importEdgesFromTests = 0;
+    const nodesById = new Map(graph.nodes.map((n) => [n.id, n]));
+    for (const edge of graph.edges) {
+        if (edge.kind !== "imports")
+            continue;
+        const fromNode = nodesById.get(edge.from);
+        if (fromNode?.path && isTestPath(fromNode.path))
+            importEdgesFromTests += 1;
+    }
+    return {
+        root,
+        staticAnalysisLabel: "TECHNICAL_STATIC_ANALYSIS_SUPPORTED",
+        testImpact,
+        fileTestMappings,
+        graphStats: {
+            testFileNodes,
+            sourceToTestLinks: fileTestMappings.reduce((n, m) => n + m.testFiles.length, 0),
+            importEdgesFromTests,
+        },
+        limitations: [...limitations, ...testImpact.limitations, ...graph.limitations.slice(0, 2)],
+    };
+}
+export async function persistTestBrainReport(rootInput, report) {
+    const root = resolveRepoRoot(rootInput);
+    return writeJsonArtifact(root, "reports/test-brain.json", report);
+}

package/dist/product/truth.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Product-layer truth labels (extends agent context labels with maturity markers).
+ */
+export type TruthLabel = "VERIFIED" | "INFERRED" | "UNKNOWN" | "EXTERNAL" | "EXPERIMENTAL" | "PARTIAL";
+export interface ProductEvidence {
+    path: string;
+    line?: number;
+    excerpt?: string;
+}
+/** Never promote weaker evidence to stronger by accident. */
+export declare function minProductTruth(a: TruthLabel, b: TruthLabel): TruthLabel;
+export declare function truthLabelDescription(label: TruthLabel): string;

package/dist/product/truth.js

@@ -0,0 +1,30 @@
+const TRUTH_ORDER = [
+    "VERIFIED",
+    "INFERRED",
+    "PARTIAL",
+    "EXPERIMENTAL",
+    "UNKNOWN",
+    "EXTERNAL",
+];
+/** Never promote weaker evidence to stronger by accident. */
+export function minProductTruth(a, b) {
+    const ia = TRUTH_ORDER.indexOf(a);
+    const ib = TRUTH_ORDER.indexOf(b);
+    return TRUTH_ORDER[Math.max(ia, ib)];
+}
+export function truthLabelDescription(label) {
+    switch (label) {
+        case "VERIFIED":
+            return "Directly supported by repository file evidence.";
+        case "INFERRED":
+            return "Heuristic or pattern match; not fully verified.";
+        case "PARTIAL":
+            return "Some evidence exists; coverage is incomplete.";
+        case "EXPERIMENTAL":
+            return "Early capability; behavior may change.";
+        case "UNKNOWN":
+            return "Cannot be determined from current evidence.";
+        case "EXTERNAL":
+            return "Requires information outside the repository.";
+    }
+}

package/dist/product/twin/digital-twin.d.ts

@@ -0,0 +1,23 @@
+import { getBrainStatus } from "../../core/brain-cli/service.js";
+import { analyzeCodeHealth } from "../health/code-health.js";
+import { type ProjectDna } from "../dna/build.js";
+import type { TruthLabel } from "../truth.js";
+export interface SoftwareDigitalTwin {
+    root: string;
+    generatedAt: string;
+    dna: ProjectDna;
+    brain: Awaited<ReturnType<typeof getBrainStatus>>;
+    graphSummary: {
+        nodeCount: number;
+        edgeCount: number;
+        truth: TruthLabel;
+    };
+    gitSummary: {
+        gitAvailable: boolean;
+        hotspotCount: number;
+        truth: TruthLabel;
+    };
+    health: Awaited<ReturnType<typeof analyzeCodeHealth>>;
+    limitations: string[];
+}
+export declare function buildSoftwareDigitalTwinSnapshot(rootInput: string): Promise<SoftwareDigitalTwin>;

package/dist/product/twin/digital-twin.js

@@ -0,0 +1,52 @@
+import { getBrainStatus } from "../../core/brain-cli/service.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { analyzeGitIntelligence } from "../../intelligence/git/analyze.js";
+import { analyzeCodeHealth } from "../health/code-health.js";
+import { buildProjectDna } from "../dna/build.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+export async function buildSoftwareDigitalTwinSnapshot(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const limitations = [
+        "Digital twin is a deterministic snapshot of local analyzers, not live runtime state.",
+        "Graph summary may be partial when graph build skips files.",
+    ];
+    const [dna, brain, git] = await Promise.all([
+        buildProjectDna(root),
+        getBrainStatus(root),
+        analyzeGitIntelligence(root),
+    ]);
+    let nodeCount = 0;
+    let edgeCount = 0;
+    let graphTruth = "UNKNOWN";
+    try {
+        const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+        nodeCount = graph.nodes.length;
+        edgeCount = graph.edges.length;
+        graphTruth = "INFERRED";
+        if (graph.limitations?.length) {
+            limitations.push(...graph.limitations.slice(0, 3));
+        }
+    }
+    catch {
+        limitations.push("Intelligence graph build failed for twin snapshot.");
+    }
+    const healthWithGit = await analyzeCodeHealth(root, { gitReport: git });
+    return {
+        root,
+        generatedAt: new Date().toISOString(),
+        dna,
+        brain,
+        graphSummary: {
+            nodeCount,
+            edgeCount,
+            truth: graphTruth,
+        },
+        gitSummary: {
+            gitAvailable: git.gitAvailable,
+            hotspotCount: git.hotspots.length,
+            truth: git.gitAvailable ? "INFERRED" : "UNKNOWN",
+        },
+        health: healthWithGit,
+        limitations,
+    };
+}

package/dist/product/twin/store.d.ts

@@ -0,0 +1,21 @@
+import type { SoftwareDigitalTwin } from "./digital-twin.js";
+export interface TwinSnapshotMeta {
+    root: string;
+    generatedAt: string;
+    invalidationHash: string;
+    changedFiles?: string[];
+}
+export interface StoredTwinSnapshot {
+    meta: TwinSnapshotMeta;
+    twin: SoftwareDigitalTwin;
+}
+export declare function loadTwinSnapshot(rootInput: string): Promise<StoredTwinSnapshot | null>;
+export declare function saveTwinSnapshot(rootInput: string, twin: SoftwareDigitalTwin, meta: Omit<TwinSnapshotMeta, "generatedAt"> & {
+    generatedAt?: string;
+}): Promise<string>;
+export declare function invalidateTwinSnapshot(rootInput: string): Promise<void>;
+export declare function updateTwin(rootInput: string, options?: {
+    changedFiles?: string[];
+    force?: boolean;
+}): Promise<SoftwareDigitalTwin>;
+export declare function buildSoftwareDigitalTwin(rootInput: string): Promise<SoftwareDigitalTwin>;

package/dist/product/twin/store.js

@@ -0,0 +1,78 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { DEFAULT_MAX_FILE_SIZE_BYTES } from "../../constants.js";
+import { atomicWriteTextFile, pathExists, readJsonFile } from "../../utils/fs.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { buildSoftwareDigitalTwinSnapshot } from "./digital-twin.js";
+import { OWNERSHIP_BOUNDARY_VERSION } from "../../project/ownership.js";
+function twinDir(root) {
+    return path.join(resolveRepoRoot(root), ".agentdoctor", "twin");
+}
+function snapshotPath(root) {
+    return path.join(twinDir(root), "snapshot.json");
+}
+function hashInputs(changedFiles) {
+    const payload = [
+        `ownership-boundary:${OWNERSHIP_BOUNDARY_VERSION}`,
+        ...(changedFiles ?? []).slice().sort(),
+    ].join("\n");
+    return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+export async function loadTwinSnapshot(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const parsed = await readJsonFile(snapshotPath(root), DEFAULT_MAX_FILE_SIZE_BYTES);
+    if (!parsed.ok)
+        return null;
+    if (parsed.data.meta.root !== root)
+        return null;
+    // Reject twins built under a prior ownership boundary (or any mismatched hash).
+    const expected = hashInputs(parsed.data.meta.changedFiles);
+    if (parsed.data.meta.invalidationHash !== expected)
+        return null;
+    return parsed.data;
+}
+export async function saveTwinSnapshot(rootInput, twin, meta) {
+    const root = resolveRepoRoot(rootInput);
+    const file = snapshotPath(root);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const stored = {
+        meta: {
+            root,
+            generatedAt: meta.generatedAt ?? new Date().toISOString(),
+            invalidationHash: meta.invalidationHash,
+            ...(meta.changedFiles?.length ? { changedFiles: meta.changedFiles } : {}),
+        },
+        twin,
+    };
+    await atomicWriteTextFile(file, `${JSON.stringify(stored, null, 2)}\n`);
+    return file;
+}
+export async function invalidateTwinSnapshot(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const file = snapshotPath(root);
+    if (await pathExists(file)) {
+        await fs.rm(file, { force: true });
+    }
+}
+export async function updateTwin(rootInput, options) {
+    const root = resolveRepoRoot(rootInput);
+    const invalidationHash = hashInputs(options?.changedFiles);
+    const existing = options?.force ? null : await loadTwinSnapshot(root);
+    if (existing &&
+        existing.meta.invalidationHash === invalidationHash &&
+        existing.twin.root === root) {
+        return existing.twin;
+    }
+    await invalidateTwinSnapshot(root);
+    const twin = await buildSoftwareDigitalTwinSnapshot(root);
+    await saveTwinSnapshot(root, twin, {
+        root,
+        invalidationHash,
+        ...(options?.changedFiles?.length ? { changedFiles: options.changedFiles } : {}),
+    });
+    return twin;
+}
+export async function buildSoftwareDigitalTwin(rootInput) {
+    return updateTwin(rootInput);
+}

package/dist/product/whatif/engine.d.ts

@@ -0,0 +1,28 @@
+import type { TruthLabel } from "../truth.js";
+export interface WhatIfAffectedItem {
+    pathOrSymbol: string;
+    role: "changed" | "caller" | "callee" | "reverse-dependency";
+    truth: TruthLabel;
+}
+export interface WhatIfReport {
+    root: string;
+    target: string;
+    affected: WhatIfAffectedItem[];
+    limitations: string[];
+}
+export declare function analyzeWhatIf(rootInput: string, target: string, options?: {
+    graph?: {
+        nodes: Array<{
+            id: string;
+            kind: string;
+            label: string;
+            path?: string;
+        }>;
+        edges: Array<{
+            from: string;
+            to: string;
+            kind: string;
+        }>;
+    };
+    buildGraph?: boolean;
+}): Promise<WhatIfReport>;

package/dist/product/whatif/engine.js

@@ -0,0 +1,91 @@
+import { deriveGraphChangeImpact } from "../../assurance/change.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { assertProjectOwnedRepoPath, classifyRelativePathOwnership, ProjectOwnershipError, } from "../../project/ownership.js";
+import { PathEscapeError, resolveSafeRepoPath } from "../../security/paths.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { minProductTruth } from "../truth.js";
+function normalizeTarget(target) {
+    return target.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+async function assertOwnedWhatIfTarget(root, target) {
+    const normalized = normalizeTarget(target);
+    const lexical = classifyRelativePathOwnership(normalized);
+    if (lexical !== "project_owned") {
+        throw new ProjectOwnershipError(lexical, `what-if target outside project ownership (${lexical})`);
+    }
+    try {
+        const abs = resolveSafeRepoPath(root, normalized);
+        await assertProjectOwnedRepoPath(root, abs, normalized);
+    }
+    catch (error) {
+        if (error instanceof PathEscapeError || error instanceof ProjectOwnershipError) {
+            throw error;
+        }
+        // Non-existent owned path remains a valid hypothetical change target.
+    }
+    return normalized;
+}
+export async function analyzeWhatIf(rootInput, target, options) {
+    const root = resolveRepoRoot(rootInput);
+    const normalized = await assertOwnedWhatIfTarget(root, target);
+    const limitations = [
+        "Impact analysis uses intelligence graph import/call edges when available.",
+        "Symbol-level precision depends on graph node coverage.",
+        "What-if targets must be project-owned paths (containment alone is not ownership).",
+    ];
+    let graph = options?.graph;
+    if (!graph && options?.buildGraph !== false) {
+        try {
+            graph = await buildIntelligenceGraph({ root, mode: "auto" });
+        }
+        catch {
+            limitations.push("Graph build failed; impact may be empty.");
+        }
+    }
+    if (!graph) {
+        limitations.push("No graph provided or built; only the target file is listed.");
+        return {
+            root,
+            target: normalized,
+            affected: [
+                {
+                    pathOrSymbol: normalized,
+                    role: "changed",
+                    truth: "VERIFIED",
+                },
+            ],
+            limitations,
+        };
+    }
+    const changedFiles = [{ path: normalized, kind: "modified" }];
+    const impact = deriveGraphChangeImpact(graph, changedFiles, []);
+    const affected = [
+        {
+            pathOrSymbol: normalized,
+            role: "changed",
+            truth: "VERIFIED",
+        },
+    ];
+    for (const c of impact.callers) {
+        affected.push({
+            pathOrSymbol: c,
+            role: "caller",
+            truth: minProductTruth("INFERRED", "PARTIAL"),
+        });
+    }
+    for (const c of impact.callees) {
+        affected.push({
+            pathOrSymbol: c,
+            role: "callee",
+            truth: minProductTruth("INFERRED", "PARTIAL"),
+        });
+    }
+    for (const c of impact.reverseDependencies) {
+        affected.push({
+            pathOrSymbol: c,
+            role: "reverse-dependency",
+            truth: minProductTruth("INFERRED", "PARTIAL"),
+        });
+    }
+    return { root, target: normalized, affected, limitations };
+}