@praneeth_54/agentdoctor 2.1.0 → 3.0.0

package/dist/product/index.d.ts

@@ -0,0 +1,69 @@
+export type { TruthLabel, ProductEvidence } from "./truth.js";
+export { minProductTruth, truthLabelDescription } from "./truth.js";
+export { traceRequirements } from "./requirements/trace.js";
+export type { RequirementTrace, RequirementsTraceReport } from "./requirements/trace.js";
+export { analyzeApiSurface } from "./api/doctor.js";
+export type { ApiDoctorReport, ApiEndpointFinding } from "./api/doctor.js";
+export { analyzeDatabaseSchema } from "./database/doctor.js";
+export type { DatabaseDoctorReport, SchemaObjectFinding, SchemaDriftFinding, SchemaRelationFinding, } from "./database/doctor.js";
+export { analyzeEvents } from "./events/doctor.js";
+export type { EventsDoctorReport, EventFlowNode, EventFlowEdge } from "./events/doctor.js";
+export { analyzeDependencies } from "./deps/analyze.js";
+export type { DependencyAnalysisReport, DirectDependency, DuplicatePackageName, UpgradeImpactHint, } from "./deps/analyze.js";
+export { analyzeCodeHealth } from "./health/code-health.js";
+export type { CodeHealthReport, CodeHealthIndicator } from "./health/code-health.js";
+export { buildSoftwareMap } from "./map/software-map.js";
+export type { SoftwareMap, SoftwareMapNode, SoftwareMapNodeKind } from "./map/software-map.js";
+export { appendChangeLedgerEntry, readChangeLedger, listChangeLedgerEntries, } from "./ledger/change-ledger.js";
+export type { ChangeLedgerEntry, ChangeLedgerListResult } from "./ledger/change-ledger.js";
+export { analyzeWhatIf } from "./whatif/engine.js";
+export type { WhatIfReport, WhatIfAffectedItem } from "./whatif/engine.js";
+export { loadDecisionLedger, appendDecisionLedgerEntry, parseAdrDecisions, resolveDecisionPath, } from "./decisions/ledger.js";
+export type { DecisionRecord, DecisionLedgerResult } from "./decisions/ledger.js";
+export { runForensicAnalysis, assertForensicReadOnly, ForensicWriteRefusedError, } from "./forensic/mode.js";
+export type { ForensicAnalysisReport } from "./forensic/mode.js";
+export { buildSoftwareDigitalTwinSnapshot } from "./twin/digital-twin.js";
+export type { SoftwareDigitalTwin } from "./twin/digital-twin.js";
+export { buildSoftwareDigitalTwin, updateTwin, loadTwinSnapshot, saveTwinSnapshot, invalidateTwinSnapshot, } from "./twin/store.js";
+export type { StoredTwinSnapshot, TwinSnapshotMeta } from "./twin/store.js";
+export { parsePackageLockJson, parseYarnLock, parsePnpmLockYaml, parseAllLockfiles, } from "./deps/lockfiles.js";
+export type { LockfilePackageVersion, ParsedLockfile } from "./deps/lockfiles.js";
+export { discoverOpenApiEndpoints } from "./api/openapi.js";
+export { buildIndex, searchIndex, searchHybrid, documentId } from "./search/index.js";
+export type { TfidfIndex, IndexDocument } from "./search/index.js";
+export { runEvalLab } from "./eval/lab.js";
+export type { EvalLabReport, EvalCheckResult } from "./eval/lab.js";
+export { diagnoseAgentDoctorSelf } from "./self/diagnose.js";
+export type { SelfDiagnoseReport, SelfDiagnoseFinding } from "./self/diagnose.js";
+export { analyzeInfra } from "./ops/infra.js";
+export type { InfraReport, InfraArtifact } from "./ops/infra.js";
+export { buildIncidentHypotheses } from "./ops/incident.js";
+export type { IncidentReport, IncidentTimelineItem } from "./ops/incident.js";
+export { discoverProjectRoots, resolveStartedProjectRoot } from "./discovery/roots.js";
+export type { ProjectDiscoveryReport, ProjectCandidate, DiscoverProjectOptions, } from "./discovery/roots.js";
+export { buildProjectDna, persistProjectDna } from "./dna/build.js";
+export type { ProjectDna } from "./dna/build.js";
+export { enrichGraphWithLanguageAdapters } from "./graph/enrich-languages.js";
+export type { LanguageGraphEnrichmentStats } from "./graph/enrich-languages.js";
+export { analyzeSecuritySurface } from "./security/doctor.js";
+export type { SecurityDoctorReport, SecurityPatternFinding } from "./security/doctor.js";
+export { analyzeTestBrain, persistTestBrainReport, mapTestsFromGraph, } from "./testbrain/analyze.js";
+export type { TestBrainReport, FileTestMapping, TestBrainGraphStats, FileTestMappingEvidence, } from "./testbrain/analyze.js";
+export { analyzePrivacySurface } from "./privacy/doctor.js";
+export type { PrivacyDoctorReport, PrivacyFinding } from "./privacy/doctor.js";
+export { searchSymbolsAndConcepts } from "./search/software-search.js";
+export type { SoftwareSearchReport, SoftwareSearchHit } from "./search/software-search.js";
+export { buildTechnicalDebtRoadmap } from "./techdebt/roadmap.js";
+export type { TechnicalDebtRoadmap, TechnicalDebtItem } from "./techdebt/roadmap.js";
+export { loadOrganizationModel, saveOrganizationModel, linkProjectToOrgModel, resolveLinkedProjectRoot, } from "./org/model.js";
+export type { OrganizationModel, OrgEntityRef, OrgProjectLink } from "./org/model.js";
+export { analyzeFeatureIntelligence } from "./features/intelligence.js";
+export type { FeatureIntelligenceReport, FeatureFlow, FeatureFlowLink, } from "./features/intelligence.js";
+export { buildSoftwareEvolutionTimeline } from "./evolution/timeline.js";
+export type { SoftwareEvolutionReport, EvolutionTimelineEvent, EvolutionTrend, } from "./evolution/timeline.js";
+export { queryMemory } from "./memory/institutional.js";
+export type { InstitutionalMemoryQueryResult, MemoryHit } from "./memory/institutional.js";
+export { evaluateApprovalRecord, formatApprovalRecordSummary } from "./approval/model.js";
+export type { ApprovalRecord, ApprovalState, ApprovalRisk, ApprovalEvaluationInput, ApprovalEvaluationResult, } from "./approval/model.js";
+export { issueApprovalGrant, consumeApprovalGrant, hashPlanPayload, hashFileWritePlan, } from "./approval/session.js";
+export type { ApprovalGrant, ConsumeApprovalResult } from "./approval/session.js";

package/dist/product/index.js

@@ -0,0 +1,35 @@
+export { minProductTruth, truthLabelDescription } from "./truth.js";
+export { traceRequirements } from "./requirements/trace.js";
+export { analyzeApiSurface } from "./api/doctor.js";
+export { analyzeDatabaseSchema } from "./database/doctor.js";
+export { analyzeEvents } from "./events/doctor.js";
+export { analyzeDependencies } from "./deps/analyze.js";
+export { analyzeCodeHealth } from "./health/code-health.js";
+export { buildSoftwareMap } from "./map/software-map.js";
+export { appendChangeLedgerEntry, readChangeLedger, listChangeLedgerEntries, } from "./ledger/change-ledger.js";
+export { analyzeWhatIf } from "./whatif/engine.js";
+export { loadDecisionLedger, appendDecisionLedgerEntry, parseAdrDecisions, resolveDecisionPath, } from "./decisions/ledger.js";
+export { runForensicAnalysis, assertForensicReadOnly, ForensicWriteRefusedError, } from "./forensic/mode.js";
+export { buildSoftwareDigitalTwinSnapshot } from "./twin/digital-twin.js";
+export { buildSoftwareDigitalTwin, updateTwin, loadTwinSnapshot, saveTwinSnapshot, invalidateTwinSnapshot, } from "./twin/store.js";
+export { parsePackageLockJson, parseYarnLock, parsePnpmLockYaml, parseAllLockfiles, } from "./deps/lockfiles.js";
+export { discoverOpenApiEndpoints } from "./api/openapi.js";
+export { buildIndex, searchIndex, searchHybrid, documentId } from "./search/index.js";
+export { runEvalLab } from "./eval/lab.js";
+export { diagnoseAgentDoctorSelf } from "./self/diagnose.js";
+export { analyzeInfra } from "./ops/infra.js";
+export { buildIncidentHypotheses } from "./ops/incident.js";
+export { discoverProjectRoots, resolveStartedProjectRoot } from "./discovery/roots.js";
+export { buildProjectDna, persistProjectDna } from "./dna/build.js";
+export { enrichGraphWithLanguageAdapters } from "./graph/enrich-languages.js";
+export { analyzeSecuritySurface } from "./security/doctor.js";
+export { analyzeTestBrain, persistTestBrainReport, mapTestsFromGraph, } from "./testbrain/analyze.js";
+export { analyzePrivacySurface } from "./privacy/doctor.js";
+export { searchSymbolsAndConcepts } from "./search/software-search.js";
+export { buildTechnicalDebtRoadmap } from "./techdebt/roadmap.js";
+export { loadOrganizationModel, saveOrganizationModel, linkProjectToOrgModel, resolveLinkedProjectRoot, } from "./org/model.js";
+export { analyzeFeatureIntelligence } from "./features/intelligence.js";
+export { buildSoftwareEvolutionTimeline } from "./evolution/timeline.js";
+export { queryMemory } from "./memory/institutional.js";
+export { evaluateApprovalRecord, formatApprovalRecordSummary } from "./approval/model.js";
+export { issueApprovalGrant, consumeApprovalGrant, hashPlanPayload, hashFileWritePlan, } from "./approval/session.js";

package/dist/product/ledger/change-ledger.d.ts

@@ -0,0 +1,23 @@
+export interface ChangeLedgerEntry {
+    id: string;
+    recordedAt: string;
+    task?: string;
+    plan?: string;
+    approval?: string;
+    files?: string[];
+    tests?: string[];
+    proofIds?: string[];
+    note?: string;
+}
+export interface ChangeLedgerListResult {
+    root: string;
+    ledgerDir: string;
+    entries: ChangeLedgerEntry[];
+    limitations: string[];
+}
+export declare function appendChangeLedgerEntry(rootInput: string, entry: Omit<ChangeLedgerEntry, "id" | "recordedAt"> & {
+    id?: string;
+    recordedAt?: string;
+}): Promise<ChangeLedgerEntry>;
+export declare function readChangeLedger(rootInput: string): Promise<ChangeLedgerListResult>;
+export declare function listChangeLedgerEntries(rootInput: string): Promise<ChangeLedgerEntry[]>;

package/dist/product/ledger/change-ledger.js

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { safeRelPath } from "../../security/paths.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { pathExists } from "../../utils/fs.js";
+function ledgerDirFor(root) {
+    return path.join(resolveRepoRoot(root), ".agentdoctor", "change-ledger");
+}
+function ledgerFileFor(root) {
+    return path.join(ledgerDirFor(root), "entries.jsonl");
+}
+async function ensureLedgerDir(root) {
+    const dir = ledgerDirFor(root);
+    await fs.mkdir(dir, { recursive: true });
+    return dir;
+}
+function newEntryId() {
+    return `cle_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+export async function appendChangeLedgerEntry(rootInput, entry) {
+    const root = resolveRepoRoot(rootInput);
+    await ensureLedgerDir(root);
+    const record = {
+        id: entry.id ?? newEntryId(),
+        recordedAt: entry.recordedAt ?? new Date().toISOString(),
+        ...(entry.task !== undefined ? { task: entry.task } : {}),
+        ...(entry.plan !== undefined ? { plan: entry.plan } : {}),
+        ...(entry.approval !== undefined ? { approval: entry.approval } : {}),
+        ...(entry.files !== undefined ? { files: entry.files.map((f) => safeRelPath(root, f)) } : {}),
+        ...(entry.tests !== undefined ? { tests: entry.tests } : {}),
+        ...(entry.proofIds !== undefined ? { proofIds: entry.proofIds } : {}),
+        ...(entry.note !== undefined ? { note: entry.note } : {}),
+    };
+    const line = `${JSON.stringify(record)}\n`;
+    await fs.appendFile(ledgerFileFor(root), line, "utf8");
+    return record;
+}
+export async function readChangeLedger(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const ledgerDir = ledgerDirFor(root);
+    const limitations = ["Append-only JSONL; entries are not cryptographically signed."];
+    const file = ledgerFileFor(root);
+    if (!(await pathExists(file))) {
+        return { root, ledgerDir, entries: [], limitations };
+    }
+    const text = await fs.readFile(file, "utf8");
+    const entries = [];
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            entries.push(JSON.parse(trimmed));
+        }
+        catch {
+            limitations.push("Skipped malformed JSONL line in change ledger.");
+        }
+    }
+    return { root, ledgerDir, entries, limitations };
+}
+export async function listChangeLedgerEntries(rootInput) {
+    const result = await readChangeLedger(rootInput);
+    return result.entries;
+}

package/dist/product/map/software-map.d.ts

@@ -0,0 +1,17 @@
+import type { ProductEvidence, TruthLabel } from "../truth.js";
+export type SoftwareMapNodeKind = "root" | "package" | "directory" | "workspace" | "docs" | "tests" | "unknown";
+export interface SoftwareMapNode {
+    id: string;
+    kind: SoftwareMapNodeKind;
+    label: string;
+    path?: string;
+    truth: TruthLabel;
+    evidence: ProductEvidence[];
+    children?: SoftwareMapNode[];
+}
+export interface SoftwareMap {
+    root: string;
+    tree: SoftwareMapNode;
+    limitations: string[];
+}
+export declare function buildSoftwareMap(rootInput: string, maxFileSizeBytes?: number): Promise<SoftwareMap>;

package/dist/product/map/software-map.js

@@ -0,0 +1,95 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_MAX_FILE_SIZE_BYTES } from "../../constants.js";
+import { detectProject } from "../../detectors/project.js";
+import { detectMonorepo } from "../../detectors/monorepo.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+function nodeId(prefix, p) {
+    return `${prefix}:${p.replace(/[^\w./-]/g, "_")}`;
+}
+async function topLevelEntries(root) {
+    try {
+        const entries = await fs.readdir(root, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function buildSoftwareMap(rootInput, maxFileSizeBytes = DEFAULT_MAX_FILE_SIZE_BYTES) {
+    const root = resolveRepoRoot(rootInput);
+    const detection = await detectProject(root, maxFileSizeBytes);
+    const relativePaths = detection.discovery.files.map((f) => f.relativePath.replace(/\\/g, "/"));
+    let rootWorkspaces;
+    const rootPkgPath = path.join(root, "package.json");
+    try {
+        const raw = await fs.readFile(rootPkgPath, "utf8");
+        rootWorkspaces = JSON.parse(raw).workspaces;
+    }
+    catch {
+        rootWorkspaces = undefined;
+    }
+    const monorepo = detectMonorepo({
+        relativePaths,
+        packageJsonWorkspaces: rootWorkspaces,
+    }).monorepo;
+    const limitations = [
+        "Map is structural (directories/packages), not a full module dependency graph.",
+        `Monorepo signal: ${monorepo}`,
+    ];
+    const packageJsonPaths = relativePaths.filter((p) => p.endsWith("package.json"));
+    const packageNodes = packageJsonPaths.map((p) => ({
+        id: nodeId("pkg", p),
+        kind: p === "package.json" ? "root" : "package",
+        label: path.dirname(p) === "." ? "root package" : path.dirname(p),
+        path: p,
+        truth: "VERIFIED",
+        evidence: [{ path: p }],
+    }));
+    const dirs = await topLevelEntries(root);
+    const dirNodes = dirs.map((name) => {
+        let kind = "directory";
+        if (name === "docs")
+            kind = "docs";
+        if (name === "tests" || name === "test")
+            kind = "tests";
+        return {
+            id: nodeId("dir", name),
+            kind,
+            label: name,
+            path: name,
+            truth: "VERIFIED",
+            evidence: [{ path: name, excerpt: "top-level directory listing" }],
+        };
+    });
+    const tree = {
+        id: nodeId("root", root),
+        kind: "root",
+        label: path.basename(root) || root,
+        path: ".",
+        truth: "VERIFIED",
+        evidence: [{ path: ".", excerpt: "detectProject root" }],
+        children: [
+            {
+                id: "packages-section",
+                kind: "workspace",
+                label: "packages",
+                truth: packageNodes.length ? "VERIFIED" : "UNKNOWN",
+                evidence: packageNodes.slice(0, 3).map((n) => ({ path: n.path ?? "." })),
+                children: packageNodes,
+            },
+            {
+                id: "directories-section",
+                kind: "directory",
+                label: "top-level directories",
+                truth: dirNodes.length ? "VERIFIED" : "PARTIAL",
+                evidence: dirNodes.slice(0, 5).map((n) => ({ path: n.path ?? n.label })),
+                children: dirNodes,
+            },
+        ],
+    };
+    return { root, tree, limitations };
+}

package/dist/product/memory/institutional.d.ts

@@ -0,0 +1,16 @@
+import type { ProductEvidence, TruthLabel } from "../truth.js";
+export interface MemoryHit {
+    source: "brain" | "decisions" | "change-ledger" | "dna";
+    id: string;
+    title: string;
+    excerpt: string;
+    truth: TruthLabel;
+    evidence: ProductEvidence[];
+}
+export interface InstitutionalMemoryQueryResult {
+    root: string;
+    query: string;
+    hits: MemoryHit[];
+    limitations: string[];
+}
+export declare function queryMemory(rootInput: string, query: string): Promise<InstitutionalMemoryQueryResult>;

package/dist/product/memory/institutional.js

@@ -0,0 +1,87 @@
+import { loadLatestBrain, searchBrain } from "../../core/brain-cli/service.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { buildProjectDna } from "../dna/build.js";
+import { loadDecisionLedger } from "../decisions/ledger.js";
+import { readChangeLedger } from "../ledger/change-ledger.js";
+export async function queryMemory(rootInput, query) {
+    const root = resolveRepoRoot(rootInput);
+    const q = query.trim();
+    const limitations = [
+        "Institutional memory merges repo-local Brain, ADR/decision ledger, change ledger, and DNA — not a vector DB.",
+        "Ranking is substring match with simple scoring — not semantic search.",
+        "Cross-repo memory is not supported; query is scoped to the resolved catalog root.",
+    ];
+    if (!q) {
+        return { root, query: q, hits: [], limitations: [...limitations, "Empty query — no hits."] };
+    }
+    const hits = [];
+    const qLower = q.toLowerCase();
+    const brain = await loadLatestBrain(root);
+    if (brain) {
+        for (const bh of searchBrain(brain, q).slice(0, 15)) {
+            hits.push({
+                source: "brain",
+                id: bh.id,
+                title: bh.kind,
+                excerpt: bh.text.slice(0, 280),
+                truth: "VERIFIED",
+                evidence: [{ path: ".agentdoctor/project-brain", excerpt: bh.text.slice(0, 120) }],
+            });
+        }
+    }
+    else {
+        limitations.push("No Project Brain snapshot — brain hits skipped.");
+    }
+    const decisions = await loadDecisionLedger(root);
+    for (const d of decisions.decisions) {
+        const hay = `${d.title} ${d.bodyExcerpt ?? ""}`.toLowerCase();
+        if (!hay.includes(qLower))
+            continue;
+        hits.push({
+            source: "decisions",
+            id: d.id,
+            title: d.title,
+            excerpt: (d.bodyExcerpt ?? d.title).slice(0, 280),
+            truth: d.truth,
+            evidence: d.evidence,
+        });
+    }
+    const changeLedger = await readChangeLedger(root);
+    for (const entry of changeLedger.entries) {
+        const hay = `${entry.task ?? ""} ${entry.plan ?? ""} ${entry.note ?? ""} ${(entry.files ?? []).join(" ")}`.toLowerCase();
+        if (!hay.includes(qLower))
+            continue;
+        hits.push({
+            source: "change-ledger",
+            id: entry.id,
+            title: entry.task ?? entry.id,
+            excerpt: (entry.note ?? entry.plan ?? entry.task ?? "").slice(0, 280),
+            truth: "VERIFIED",
+            evidence: [{ path: ".agentdoctor/change-ledger/entries.jsonl", excerpt: entry.id }],
+        });
+    }
+    const dna = await buildProjectDna(root);
+    const dnaHay = JSON.stringify({
+        name: dna.name,
+        frameworks: dna.frameworks,
+        languages: dna.languages,
+        services: dna.services,
+    }).toLowerCase();
+    if (dnaHay.includes(qLower)) {
+        hits.push({
+            source: "dna",
+            id: dna.fingerprint,
+            title: `Project DNA: ${dna.name}`,
+            excerpt: `Languages: ${dna.languages.join(", ")}; frameworks: ${dna.frameworks.join(", ")}`,
+            truth: dna.truth,
+            evidence: [{ path: ".agentdoctor/dna/project-dna.json", excerpt: dna.fingerprint }],
+        });
+    }
+    hits.sort((a, b) => b.excerpt.length - a.excerpt.length);
+    return {
+        root,
+        query: q,
+        hits: hits.slice(0, 40),
+        limitations,
+    };
+}

package/dist/product/ops/incident.d.ts

@@ -0,0 +1,20 @@
+import type { TruthLabel } from "../truth.js";
+export interface IncidentTimelineItem {
+    id: string;
+    hypothesis: string;
+    truth: TruthLabel;
+    relatedPaths: string[];
+    method: string;
+}
+export interface IncidentReport {
+    root: string;
+    timeline: IncidentTimelineItem[];
+    limitations: string[];
+}
+export declare function buildIncidentHypotheses(rootInput: string, options?: {
+    changedFiles?: string[];
+    gitHotspots?: Array<{
+        path: string;
+        commits: number;
+    }>;
+}): Promise<IncidentReport>;

package/dist/product/ops/incident.js

@@ -0,0 +1,61 @@
+import { analyzeGitIntelligence } from "../../intelligence/git/analyze.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+function normalizePaths(paths) {
+    return [...new Set(paths.map((p) => p.replace(/\\/g, "/")))].sort();
+}
+export async function buildIncidentHypotheses(rootInput, options) {
+    const root = resolveRepoRoot(rootInput);
+    const limitations = [
+        "Timeline items are hypotheses for investigation, not verified incident root cause.",
+        "VERIFIED items require explicit changedFiles input or git hotspot file paths.",
+    ];
+    const changed = normalizePaths(options?.changedFiles ?? []);
+    const timeline = [];
+    if (changed.length) {
+        timeline.push({
+            id: "changed-files",
+            hypothesis: "Recent changes concentrated in supplied changedFiles list",
+            truth: "VERIFIED",
+            relatedPaths: changed,
+            method: "caller-supplied changedFiles",
+        });
+    }
+    let hotspots = options?.gitHotspots;
+    if (!hotspots) {
+        const git = await analyzeGitIntelligence(root);
+        if (git.gitAvailable) {
+            hotspots = git.hotspots.map((h) => ({ path: h.path, commits: h.commits }));
+        }
+        else {
+            limitations.push("Git unavailable; hotspot hypotheses skipped.");
+        }
+    }
+    if (hotspots?.length) {
+        const top = [...hotspots].sort((a, b) => b.commits - a.commits).slice(0, 5);
+        for (const h of top) {
+            const overlapsChange = changed.some((c) => c === h.path || h.path.endsWith(c) || c.endsWith(h.path));
+            timeline.push({
+                id: `hotspot-${h.path.replace(/[^\w]/g, "_")}`,
+                hypothesis: "Frequent historical churn (git hotspot) may relate to instability",
+                truth: overlapsChange ? "VERIFIED" : "INFERRED",
+                relatedPaths: [h.path.replace(/\\/g, "/")],
+                method: `git log file appearances (commits=${h.commits})`,
+            });
+        }
+    }
+    if (changed.length && hotspots?.length) {
+        const hotSet = new Set(hotspots.map((h) => h.path.replace(/\\/g, "/")));
+        const overlap = changed.filter((c) => hotSet.has(c));
+        if (overlap.length) {
+            timeline.push({
+                id: "change-hotspot-overlap",
+                hypothesis: "Changed files overlap historical hotspots",
+                truth: "VERIFIED",
+                relatedPaths: overlap,
+                method: "intersection(changedFiles, gitHotspots)",
+            });
+        }
+    }
+    timeline.sort((a, b) => a.id.localeCompare(b.id));
+    return { root, timeline, limitations };
+}

package/dist/product/ops/infra.d.ts

@@ -0,0 +1,15 @@
+import type { ProductEvidence, TruthLabel } from "../truth.js";
+export interface InfraArtifact {
+    kind: "docker" | "kubernetes" | "terraform" | "ci" | "compose-service" | "unknown";
+    path: string;
+    label: string;
+    truth: TruthLabel;
+    evidence: ProductEvidence[];
+}
+export interface InfraReport {
+    root: string;
+    artifacts: InfraArtifact[];
+    services: string[];
+    limitations: string[];
+}
+export declare function analyzeInfra(rootInput: string, maxFileSizeBytes?: number): Promise<InfraReport>;

package/dist/product/ops/infra.js

@@ -0,0 +1,112 @@
+import path from "node:path";
+import { DEFAULT_MAX_FILE_SIZE_BYTES } from "../../constants.js";
+import { detectProject } from "../../detectors/project.js";
+import { readTextFile } from "../../utils/fs.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+function classifyPath(relativePath) {
+    const norm = relativePath.replace(/\\/g, "/");
+    const base = norm.split("/").pop()?.toLowerCase() ?? "";
+    if (base === "dockerfile" || base.startsWith("dockerfile.")) {
+        return {
+            kind: "docker",
+            path: norm,
+            label: "Dockerfile",
+            truth: "VERIFIED",
+            evidence: [{ path: norm }],
+        };
+    }
+    if (base === "docker-compose.yml" || base === "docker-compose.yaml" || base === "compose.yml") {
+        return {
+            kind: "docker",
+            path: norm,
+            label: "Docker Compose",
+            truth: "VERIFIED",
+            evidence: [{ path: norm }],
+        };
+    }
+    if (norm.includes(".github/workflows/") && (base.endsWith(".yml") || base.endsWith(".yaml"))) {
+        return {
+            kind: "ci",
+            path: norm,
+            label: "GitHub Actions workflow",
+            truth: "VERIFIED",
+            evidence: [{ path: norm }],
+        };
+    }
+    if (base.endsWith(".tf")) {
+        return {
+            kind: "terraform",
+            path: norm,
+            label: "Terraform",
+            truth: "VERIFIED",
+            evidence: [{ path: norm }],
+        };
+    }
+    if (norm.includes("kubernetes/") || base.includes("deployment") || base.includes("service")) {
+        if (base.endsWith(".yaml") || base.endsWith(".yml")) {
+            return {
+                kind: "kubernetes",
+                path: norm,
+                label: "Kubernetes manifest (heuristic)",
+                truth: "INFERRED",
+                evidence: [{ path: norm }],
+            };
+        }
+    }
+    return null;
+}
+function parseComposeServices(content, relativePath) {
+    const services = [];
+    let inServices = false;
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (/^services:\s*$/i.test(trimmed)) {
+            inServices = true;
+            continue;
+        }
+        if (inServices) {
+            if (/^[a-zA-Z0-9_-]+:\s*$/.test(trimmed) && !trimmed.startsWith("version:")) {
+                const name = trimmed.replace(":", "");
+                if (name !== "services" && !name.includes(" "))
+                    services.push(name);
+            }
+            if (/^[a-zA-Z_]+:/.test(trimmed) &&
+                !line.startsWith(" ") &&
+                !line.startsWith("\t") &&
+                trimmed !== "services:") {
+                if (!trimmed.startsWith("services:"))
+                    inServices = false;
+            }
+        }
+    }
+    return services.map((s) => `${s}@${relativePath}`);
+}
+export async function analyzeInfra(rootInput, maxFileSizeBytes = DEFAULT_MAX_FILE_SIZE_BYTES) {
+    const root = resolveRepoRoot(rootInput);
+    const detection = await detectProject(root, maxFileSizeBytes);
+    const limitations = [
+        "Compose service names use simple line heuristics, not a full YAML parser.",
+        "Kubernetes detection is path/name heuristic.",
+    ];
+    const artifacts = [];
+    const services = [];
+    for (const entry of detection.discovery.files) {
+        const rel = entry.relativePath.replace(/\\/g, "/");
+        const artifact = classifyPath(rel);
+        if (artifact)
+            artifacts.push(artifact);
+        const base = rel.split("/").pop()?.toLowerCase() ?? "";
+        if (base === "docker-compose.yml" || base === "docker-compose.yaml" || base === "compose.yml") {
+            const text = await readTextFile(path.join(root, rel), maxFileSizeBytes);
+            if (text)
+                services.push(...parseComposeServices(text, rel));
+        }
+    }
+    artifacts.sort((a, b) => a.path.localeCompare(b.path));
+    return {
+        root,
+        artifacts,
+        services: [...new Set(services)].sort(),
+        limitations,
+    };
+}

package/dist/product/org/model.d.ts

@@ -0,0 +1,34 @@
+import type { TruthLabel } from "../truth.js";
+export interface OrgEntityRef {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface OrgProjectLink {
+    id: string;
+    name: string;
+    /** Absolute or repo-relative root path for this project within the workspace catalog */
+    rootPath: string;
+    teamIds: string[];
+    serviceIds: string[];
+    ownerIds: string[];
+}
+export interface OrganizationModel {
+    schemaVersion: 1;
+    updatedAt: string;
+    /** Catalog root this model was loaded from (not shared across repos automatically) */
+    catalogRoot: string;
+    teams: OrgEntityRef[];
+    projects: OrgProjectLink[];
+    services: OrgEntityRef[];
+    owners: OrgEntityRef[];
+    truth: TruthLabel;
+    limitations: string[];
+}
+export declare function loadOrganizationModel(rootInput: string): Promise<OrganizationModel>;
+export declare function saveOrganizationModel(rootInput: string, model: Omit<OrganizationModel, "schemaVersion" | "updatedAt" | "catalogRoot" | "truth" | "limitations">): Promise<OrganizationModel>;
+/** Register or update a project link under the catalog root (path must stay within catalogRoot). */
+export declare function linkProjectToOrgModel(rootInput: string, link: Omit<OrgProjectLink, "rootPath"> & {
+    rootPath?: string;
+}): Promise<OrganizationModel>;
+export declare function resolveLinkedProjectRoot(model: OrganizationModel, projectId: string): string | null;