trace-mcp 1.9.0 → 1.10.0

package/dist/cli.js

@@ -2140,7 +2140,7 @@ var logger = pino({
 }, process.stderr);
 
 // src/db/schema.ts
-var SCHEMA_VERSION = 17;
+var SCHEMA_VERSION = 18;
 var DDL = `
 -- ============================================================
 -- UNIFIED ADDRESS SPACE
@@ -6585,57 +6585,41 @@ var FilePersister = class {
     if (ext.gitignored) {
       store.updateFileGitignored(fileId, true);
     }
-    if (ext.symbols.length > 0) {
-      const insertedIds = store.insertSymbols(fileId, ext.symbols);
-      const trigramBySymbolId = /* @__PURE__ */ new Map();
-      for (let i = 0; i < ext.symbols.length; i++) {
-        trigramBySymbolId.set(ext.symbols[i].symbolId, {
-          id: insertedIds[i],
-          name: ext.symbols[i].name,
-          fqn: ext.symbols[i].fqn ?? null
-        });
-      }
-      indexTrigramsBatch(store.db, [...trigramBySymbolId.values()]);
-    }
-    if (ext.otherEdges.length > 0) this.storeRawEdges(ext.otherEdges);
+    this.persistSymbolsAndEntities(fileId, ext.symbols, ext.otherEdges, ext);
     if (ext.importEdges.length > 0) {
       this.state.pendingImports.set(fileId, ext.importEdges);
     }
-    for (const r of ext.routes) store.insertRoute(r, fileId);
-    for (const c of ext.components) store.insertComponent(c, fileId);
-    for (const m of ext.migrations) store.insertMigration(m, fileId);
-    if (ext.ormModels.length > 0) {
-      this.storeOrmResults(ext.ormModels, ext.ormAssociations, fileId);
-    }
-    for (const s of ext.rnScreens) store.insertRnScreen(s, fileId);
     for (const fwResult of ext.frameworkExtracts) {
-      if (fwResult.symbols.length > 0) {
-        const fwIds = store.insertSymbols(fileId, fwResult.symbols);
-        const fwTrigramBySymbolId = /* @__PURE__ */ new Map();
-        for (let i = 0; i < fwResult.symbols.length; i++) {
-          fwTrigramBySymbolId.set(fwResult.symbols[i].symbolId, {
-            id: fwIds[i],
-            name: fwResult.symbols[i].name,
-            fqn: fwResult.symbols[i].fqn ?? null
-          });
-        }
-        indexTrigramsBatch(store.db, [...fwTrigramBySymbolId.values()]);
-      }
-      if (fwResult.edges?.length) {
-        this.storeRawEdges(fwResult.edges);
-      }
-      for (const r of fwResult.routes ?? []) store.insertRoute(r, fileId);
-      for (const c of fwResult.components ?? []) store.insertComponent(c, fileId);
-      for (const m of fwResult.migrations ?? []) store.insertMigration(m, fileId);
-      if (fwResult.ormModels?.length) {
-        this.storeOrmResults(fwResult.ormModels, fwResult.ormAssociations ?? [], fileId);
-      }
-      for (const s of fwResult.rnScreens ?? []) store.insertRnScreen(s, fileId);
+      this.persistSymbolsAndEntities(fileId, fwResult.symbols, fwResult.edges ?? [], fwResult);
       if (fwResult.frameworkRole) {
         store.updateFileStatus(fileId, fwResult.status, fwResult.frameworkRole);
       }
     }
   }
+  /** Insert symbols+trigrams, edges, and entities (routes/components/migrations/ORM/screens). */
+  persistSymbolsAndEntities(fileId, symbols, edges, entities) {
+    const store = this.state.store;
+    if (symbols.length > 0) {
+      const insertedIds = store.insertSymbols(fileId, symbols);
+      const trigramBySymbolId = /* @__PURE__ */ new Map();
+      for (let i = 0; i < symbols.length; i++) {
+        trigramBySymbolId.set(symbols[i].symbolId, {
+          id: insertedIds[i],
+          name: symbols[i].name,
+          fqn: symbols[i].fqn ?? null
+        });
+      }
+      indexTrigramsBatch(store.db, [...trigramBySymbolId.values()]);
+    }
+    if (edges.length > 0) this.storeRawEdges(edges);
+    for (const r of entities.routes ?? []) store.insertRoute(r, fileId);
+    for (const c of entities.components ?? []) store.insertComponent(c, fileId);
+    for (const m of entities.migrations ?? []) store.insertMigration(m, fileId);
+    if (entities.ormModels?.length) {
+      this.storeOrmResults(entities.ormModels, entities.ormAssociations ?? [], fileId);
+    }
+    for (const s of entities.rnScreens ?? []) store.insertRnScreen(s, fileId);
+  }
   /**
    * Fast path for incremental re-indexing: if the set of symbols is structurally
    * identical (same symbolIds, names, kinds, fqns, signatures), only update byte
@@ -7795,58 +7779,10 @@ var IndexingPipeline = class _IndexingPipeline {
     this._gitignore = new GitignoreMatcher(this.rootPath);
     this._traceignore = new TraceignoreMatcher(this.rootPath, this.config.ignore);
     this.registerFrameworkEdgeTypes();
-    const extractor = new FileExtractor({
-      store: this.store,
-      registry: this.registry,
-      rootPath: this.rootPath,
-      workspaces: this.workspaces,
-      gitignore: this._gitignore,
-      fileContentCache: this._fileContentCache,
-      buildProjectContext: () => this.buildProjectContext()
-    });
     try {
-      disableFts5Triggers(this.store.db);
-      const BATCH_SIZE3 = Math.min(500, Math.max(100, Math.ceil(relPaths.length / 20)));
-      const CONCURRENCY = Math.min(8, cpus().length);
-      for (let i = 0; i < relPaths.length; i += BATCH_SIZE3) {
-        const batch = relPaths.slice(i, i + BATCH_SIZE3);
-        const extractions = [];
-        for (let c = 0; c < batch.length; c += CONCURRENCY) {
-          const chunk = batch.slice(c, c + CONCURRENCY);
-          const results = await Promise.all(
-            chunk.map((relPath) => extractor.extract(relPath, force))
-          );
-          for (const ext of results) {
-            if (ext === "skipped") {
-              result.skipped++;
-              continue;
-            }
-            if (ext === "error") {
-              result.errors++;
-              continue;
-            }
-            extractions.push(ext);
-          }
-        }
-        if (extractions.length > 0) {
-          const state = this.getPipelineState();
-          const persistEdgeResolver = new EdgeResolver(state);
-          const persister = new FilePersister(state, (edges) => persistEdgeResolver.storeRawEdges(edges));
-          persister.persistBatch(extractions);
-          result.indexed += extractions.length;
-        }
-        const processed = result.indexed + result.skipped + result.errors;
-        this.progress?.update("indexing", { processed });
-      }
-      enableFts5Triggers(this.store.db);
-      const edgeResolver = new EdgeResolver(this.getPipelineState());
-      await edgeResolver.resolveEdges(this.buildProjectContext(), this.buildResolveContext());
-      edgeResolver.resolveOrmAssociationEdges();
-      edgeResolver.resolveTypeScriptHeritageEdges();
-      edgeResolver.resolveEsmImportEdges();
-      edgeResolver.resolveTestCoversEdges();
-      const envIndexer = new EnvIndexer(this.store, this.config, this.rootPath, this._traceignore);
-      await envIndexer.indexEnvFiles(force);
+      await this.extractAndPersist(relPaths, force, result);
+      await this.resolveAllEdges();
+      await this.indexEnvFiles(force);
     } finally {
       this._fileContentCache.clear();
       this._pendingImports.clear();
@@ -7870,6 +7806,66 @@ var IndexingPipeline = class _IndexingPipeline {
     logger.info(result, "Indexing pipeline completed");
     return result;
   }
+  /** Pass 1: extract symbols from files and persist in batched transactions. */
+  async extractAndPersist(relPaths, force, result) {
+    const extractor = new FileExtractor({
+      store: this.store,
+      registry: this.registry,
+      rootPath: this.rootPath,
+      workspaces: this.workspaces,
+      gitignore: this._gitignore,
+      fileContentCache: this._fileContentCache,
+      buildProjectContext: () => this.buildProjectContext()
+    });
+    disableFts5Triggers(this.store.db);
+    const BATCH_SIZE3 = Math.min(500, Math.max(100, Math.ceil(relPaths.length / 20)));
+    const CONCURRENCY = Math.min(8, cpus().length);
+    for (let i = 0; i < relPaths.length; i += BATCH_SIZE3) {
+      const batch = relPaths.slice(i, i + BATCH_SIZE3);
+      const extractions = [];
+      for (let c = 0; c < batch.length; c += CONCURRENCY) {
+        const chunk = batch.slice(c, c + CONCURRENCY);
+        const results = await Promise.all(
+          chunk.map((relPath) => extractor.extract(relPath, force))
+        );
+        for (const ext of results) {
+          if (ext === "skipped") {
+            result.skipped++;
+            continue;
+          }
+          if (ext === "error") {
+            result.errors++;
+            continue;
+          }
+          extractions.push(ext);
+        }
+      }
+      if (extractions.length > 0) {
+        const state = this.getPipelineState();
+        const persistEdgeResolver = new EdgeResolver(state);
+        const persister = new FilePersister(state, (edges) => persistEdgeResolver.storeRawEdges(edges));
+        persister.persistBatch(extractions);
+        result.indexed += extractions.length;
+      }
+      const processed = result.indexed + result.skipped + result.errors;
+      this.progress?.update("indexing", { processed });
+    }
+    enableFts5Triggers(this.store.db);
+  }
+  /** Pass 2: resolve all edge types (imports, heritage, ORM, tests). */
+  async resolveAllEdges() {
+    const edgeResolver = new EdgeResolver(this.getPipelineState());
+    await edgeResolver.resolveEdges(this.buildProjectContext(), this.buildResolveContext());
+    edgeResolver.resolveOrmAssociationEdges();
+    edgeResolver.resolveTypeScriptHeritageEdges();
+    edgeResolver.resolveEsmImportEdges();
+    edgeResolver.resolveTestCoversEdges();
+  }
+  /** Pass 3: index .env files for environment variable tracking. */
+  async indexEnvFiles(force) {
+    const envIndexer = new EnvIndexer(this.store, this.config, this.rootPath, this._traceignore);
+    await envIndexer.indexEnvFiles(force);
+  }
   buildProjectContext() {
     if (!this._projectContext) {
       this._projectContext = buildProjectContext(this.rootPath);
@@ -10420,186 +10416,6 @@ function getProjectMap(store, registry, summaryOnly, projectContext) {
 }
 
 // src/tools/analysis/duplication.ts
-var CHECKABLE_KINDS = /* @__PURE__ */ new Set([
-  "function",
-  "class",
-  "method",
-  "interface",
-  "type_alias",
-  "enum"
-]);
-var TRIVIAL_NAMES = /* @__PURE__ */ new Set([
-  "constructor",
-  "toString",
-  "toJSON",
-  "valueOf",
-  "render",
-  "setup",
-  "main",
-  "index",
-  "default",
-  "init",
-  "create",
-  "get",
-  "set",
-  "delete",
-  "update",
-  "handle",
-  "process",
-  "run",
-  "start",
-  "stop",
-  "reset",
-  "configure",
-  "register",
-  "execute",
-  "validate",
-  "transform",
-  "apply",
-  "call",
-  "bind",
-  "map",
-  "filter",
-  "reduce",
-  "forEach",
-  "connect",
-  "disconnect",
-  "open",
-  "close",
-  "build",
-  "destroy",
-  "mount",
-  "unmount",
-  "dispose",
-  "serialize",
-  "deserialize"
-]);
-var TEST_PATH_RE2 = /(?:^|[/\\])(?:tests?|__tests__|spec)[/\\]|\.(?:test|spec)\.[jt]sx?$/i;
-var MIN_NAME_LENGTH = 4;
-var MAX_SYMBOLS_PER_FILE2 = 30;
-var W_NAME = 0.45;
-var W_KIND = 0.15;
-var W_SIGNATURE = 0.25;
-var W_TOKEN = 0.15;
-function tokenizeName(name) {
-  const parts = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().split(/[_\-./:]+/).filter((p5) => p5.length > 1);
-  return new Set(parts);
-}
-function jaccard(a, b) {
-  if (a.size === 0 && b.size === 0) return 0;
-  let intersection = 0;
-  for (const t of a) {
-    if (b.has(t)) intersection++;
-  }
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-function signatureSimilarity(srcParamCount, candParamCount) {
-  if (srcParamCount == null && candParamCount == null) return 0.5;
-  if (srcParamCount == null || candParamCount == null) return 0.3;
-  const max = Math.max(srcParamCount, candParamCount, 1);
-  return 1 - Math.abs(srcParamCount - candParamCount) / max;
-}
-function getHeritageNames(metadata) {
-  if (!metadata) return /* @__PURE__ */ new Set();
-  try {
-    const parsed = JSON.parse(metadata);
-    const names = /* @__PURE__ */ new Set();
-    if (typeof parsed.extends === "string") names.add(parsed.extends);
-    if (Array.isArray(parsed.extends)) {
-      for (const e of parsed.extends) if (typeof e === "string") names.add(e);
-    }
-    if (typeof parsed.implements === "string") names.add(parsed.implements);
-    if (Array.isArray(parsed.implements)) {
-      for (const i of parsed.implements) if (typeof i === "string") names.add(i);
-    }
-    return names;
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-function findDuplicateSymbols(store, db, sourceSymbols, sourceFileId, sourceFilePath, options) {
-  const threshold = options?.threshold ?? 0.7;
-  const maxResults = options?.maxResults ?? 10;
-  const sourceIsTest = TEST_PATH_RE2.test(sourceFilePath);
-  const heritageNames = /* @__PURE__ */ new Set();
-  for (const sym of sourceSymbols) {
-    const h = getHeritageNames(sym.metadata);
-    for (const n of h) heritageNames.add(n);
-  }
-  const checkable = sourceSymbols.filter(
-    (s) => CHECKABLE_KINDS.has(s.kind) && s.name.length >= MIN_NAME_LENGTH && !TRIVIAL_NAMES.has(s.name)
-  ).slice(0, MAX_SYMBOLS_PER_FILE2);
-  const allWarnings = [];
-  const paramCountStmt = db.prepare(
-    "SELECT param_count FROM symbols WHERE id = ?"
-  );
-  for (const src of checkable) {
-    const srcParamCount = src.param_count ?? paramCountStmt.get(src.id)?.param_count ?? null;
-    const srcTokens = tokenizeName(src.fqn ?? src.name);
-    const candidates = fuzzySearch(db, src.name, {
-      threshold: 0.25,
-      limit: 30,
-      kind: src.kind
-    });
-    for (const cand of candidates) {
-      if (cand.fileId === sourceFileId) continue;
-      if (cand.symbolIdStr === src.symbol_id) continue;
-      const candFile = store.getFileById(cand.fileId);
-      if (!candFile) continue;
-      const candIsTest = TEST_PATH_RE2.test(candFile.path);
-      if (sourceIsTest !== candIsTest) continue;
-      if (heritageNames.has(cand.name)) continue;
-      const candSymbol = getCandidateSymbol(db, cand.symbolId);
-      if (candSymbol) {
-        const candHeritage = getHeritageNames(candSymbol.metadata);
-        for (const h of candHeritage) {
-          if (heritageNames.has(h)) continue;
-        }
-      }
-      const nameSim = cand.similarity;
-      const kindMatch = cand.kind === src.kind ? 1 : 0;
-      const candParamCount = candSymbol?.param_count ?? paramCountStmt.get(cand.symbolId)?.param_count ?? null;
-      const sigSim = signatureSimilarity(srcParamCount, candParamCount);
-      const candTokens = tokenizeName(cand.fqn ?? cand.name);
-      const tokenOvl = jaccard(srcTokens, candTokens);
-      const score = W_NAME * nameSim + W_KIND * kindMatch + W_SIGNATURE * sigSim + W_TOKEN * tokenOvl;
-      if (score >= threshold) {
-        allWarnings.push({
-          source_symbol_id: src.symbol_id,
-          source_name: src.name,
-          source_file: sourceFilePath,
-          duplicate_symbol_id: cand.symbolIdStr,
-          duplicate_name: cand.name,
-          duplicate_file: candFile.path,
-          duplicate_line: candSymbol?.line_start ?? null,
-          score: Math.round(score * 1e3) / 1e3,
-          signals: {
-            name_similarity: Math.round(nameSim * 1e3) / 1e3,
-            kind_match: kindMatch,
-            signature_similarity: Math.round(sigSim * 1e3) / 1e3,
-            token_overlap: Math.round(tokenOvl * 1e3) / 1e3
-          }
-        });
-      }
-    }
-  }
-  allWarnings.sort((a, b) => b.score - a.score);
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const w of allWarnings) {
-    const key = `${w.source_symbol_id}::${w.duplicate_symbol_id}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push(w);
-    if (deduped.length >= maxResults) break;
-  }
-  return {
-    warnings: deduped,
-    symbols_checked: checkable.length,
-    threshold
-  };
-}
 function checkFileForDuplicates(store, db, filePath, options) {
   const file = store.getFile(filePath);
   if (!file) {
@@ -10642,11 +10458,6 @@ function checkSymbolForDuplicates(store, db, query, options) {
   }
   return { warnings: [], symbols_checked: 0, threshold };
 }
-function getCandidateSymbol(db, symbolId) {
-  return db.prepare(
-    "SELECT * FROM symbols WHERE id = ?"
-  ).get(symbolId);
-}
 
 // src/tools/register/core.ts
 function registerCoreTools(server, ctx) {
@@ -12488,11 +12299,11 @@ function suggestQueries(store) {
 
 // src/tools/navigation/related.ts
 import { ok as ok4, err as err5 } from "neverthrow";
-function tokenizeName2(name) {
+function tokenizeName(name) {
   const parts = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().split(/[_\-.]/).filter((p5) => p5.length > 1);
   return new Set(parts);
 }
-function jaccard2(a, b) {
+function jaccard(a, b) {
   if (a.size === 0 && b.size === 0) return 0;
   let intersection = 0;
   for (const t of a) {
@@ -12581,13 +12392,13 @@ function getRelatedSymbols(store, opts) {
       }
     }
   }
-  const targetTokens = tokenizeName2(target.name);
+  const targetTokens = tokenizeName(target.name);
   const candidateIds = [...scores.keys()];
   const candidateSymbols = store.getSymbolsByIds(candidateIds);
   const candidateFileIds = [...new Set([...candidateSymbols.values()].map((s) => s.file_id))];
   const fileMap = store.getFilesByIds(candidateFileIds);
   for (const [symId4, sym] of candidateSymbols) {
-    const nameScore = jaccard2(targetTokens, tokenizeName2(sym.name));
+    const nameScore = jaccard(targetTokens, tokenizeName(sym.name));
     if (nameScore > 0) {
       ensureEntry(symId4).name_overlap = nameScore;
     }
@@ -13684,63 +13495,9 @@ var FederationManager = class {
         detectionSource: svc.detectionSource,
         metadata: svc.metadata
       });
-      const contracts = parseContracts(svc.repoRoot);
-      if (opts?.contractPaths) {
-        for (const cp of opts.contractPaths) {
-          const absContract = path29.resolve(absRoot, cp);
-          if (fs25.existsSync(absContract)) {
-            const additionalContracts = parseContracts(path29.dirname(absContract));
-            contracts.push(...additionalContracts.filter(
-              (c) => path29.resolve(absRoot, c.specPath) === absContract
-            ));
-          }
-        }
-      }
-      for (const contract of contracts) {
-        const contractId = this.topoStore.insertContract(serviceId, {
-          contractType: contract.type,
-          specPath: contract.specPath,
-          version: contract.version,
-          parsedSpec: JSON.stringify({ endpoints: contract.endpoints, events: contract.events })
-        });
-        this.topoStore.insertEndpoints(
-          contractId,
-          serviceId,
-          contract.endpoints.map((e) => ({
-            method: e.method ?? void 0,
-            path: e.path,
-            operationId: e.operationId,
-            requestSchema: e.requestSchema ? JSON.stringify(e.requestSchema) : void 0,
-            responseSchema: e.responseSchema ? JSON.stringify(e.responseSchema) : void 0
-          }))
-        );
-        if (contract.events.length > 0) {
-          this.topoStore.insertEventChannels(
-            contractId,
-            serviceId,
-            contract.events.map((e) => ({
-              channelName: e.channelName,
-              direction: e.direction
-            }))
-          );
-        }
-      }
+      this.registerContracts(serviceId, svc.repoRoot, absRoot, opts?.contractPaths);
     }
-    this.topoStore.deleteClientCallsByRepo(repoId);
-    const clientCalls = scanClientCalls(absRoot);
-    if (clientCalls.length > 0) {
-      this.topoStore.insertClientCalls(clientCalls.map((c) => ({
-        sourceRepoId: repoId,
-        filePath: c.filePath,
-        line: c.line,
-        callType: c.callType,
-        method: c.method,
-        urlPattern: c.urlPattern,
-        confidence: c.confidence
-      })));
-    }
-    const linkedCount = this.topoStore.linkClientCallsToEndpoints();
-    this.buildCrossServiceEdges();
+    const clientCalls = this.scanAndLinkClientCalls(repoId, absRoot);
     this.topoStore.updateFederatedRepoSyncTime(repoId);
     const stats = this.topoStore.getTopologyStats();
     return {
@@ -13749,8 +13506,8 @@ var FederationManager = class {
       services: detected.length,
       contracts: stats.contracts,
       endpoints: stats.endpoints,
-      clientCalls: clientCalls.length,
-      linkedCalls: linkedCount
+      clientCalls: clientCalls.scanned,
+      linkedCalls: clientCalls.linked
     };
   }
   /**
@@ -13854,75 +13611,26 @@ var FederationManager = class {
           detectionSource: svc.detectionSource,
           metadata: svc.metadata
         });
-        const existingContracts = this.topoStore.getContractsByService(serviceId);
-        for (const ec of existingContracts) {
-          this.topoStore.insertContractSnapshot(ec.id, serviceId, {
-            version: ec.version,
-            specPath: ec.spec_path,
-            contentHash: ec.content_hash ?? "",
-            endpointsJson: ec.parsed_spec,
-            eventsJson: "[]"
-          });
-        }
+        this.snapshotContracts(serviceId);
         this.topoStore.deleteContractsByService(serviceId);
         const contracts = parseContracts(svc.repoRoot);
         contractsUpdated += contracts.length;
         for (const contract of contracts) {
-          const contractId = this.topoStore.insertContract(serviceId, {
-            contractType: contract.type,
-            specPath: contract.specPath,
-            version: contract.version,
-            parsedSpec: JSON.stringify({ endpoints: contract.endpoints, events: contract.events })
-          });
-          this.topoStore.insertEndpoints(
-            contractId,
-            serviceId,
-            contract.endpoints.map((e) => ({
-              method: e.method ?? void 0,
-              path: e.path,
-              operationId: e.operationId,
-              requestSchema: e.requestSchema ? JSON.stringify(e.requestSchema) : void 0,
-              responseSchema: e.responseSchema ? JSON.stringify(e.responseSchema) : void 0
-            }))
-          );
           endpointsUpdated += contract.endpoints.length;
-          if (contract.events.length > 0) {
-            this.topoStore.insertEventChannels(
-              contractId,
-              serviceId,
-              contract.events.map((e) => ({
-                channelName: e.channelName,
-                direction: e.direction
-              }))
-            );
-          }
         }
+        this.registerContracts(serviceId, svc.repoRoot);
       }
-      this.topoStore.deleteClientCallsByRepo(repo.id);
-      const calls = scanClientCalls(repo.repo_root);
-      clientCallsScanned += calls.length;
-      if (calls.length > 0) {
-        this.topoStore.insertClientCalls(calls.map((c) => ({
-          sourceRepoId: repo.id,
-          filePath: c.filePath,
-          line: c.line,
-          callType: c.callType,
-          method: c.method,
-          urlPattern: c.urlPattern,
-          confidence: c.confidence
-        })));
-      }
+      const calls = this.scanAndLinkClientCalls(repo.id, repo.repo_root);
+      clientCallsScanned += calls.scanned;
       this.topoStore.updateFederatedRepoSyncTime(repo.id);
     }
-    const newlyLinked = this.topoStore.linkClientCallsToEndpoints();
-    this.buildCrossServiceEdges();
     return {
       repos: repos.length,
       servicesUpdated,
       contractsUpdated,
       endpointsUpdated,
       clientCallsScanned,
-      newlyLinked,
+      newlyLinked: this.topoStore.linkClientCallsToEndpoints(),
       crossRepoEdges: this.topoStore.getTopologyStats().crossEdges
     };
   }
@@ -13932,82 +13640,18 @@ var FederationManager = class {
    * If per-repo DBs exist, resolves down to symbol level.
    */
   getImpact(opts) {
+    const matchingEndpoints = this.filterEndpoints(opts);
     const results = [];
-    const allEndpoints = this.topoStore.getAllEndpoints();
-    let matchingEndpoints = allEndpoints;
-    if (opts.endpoint) {
-      const normalized = opts.endpoint.toLowerCase();
-      matchingEndpoints = allEndpoints.filter(
-        (ep) => ep.path.toLowerCase().includes(normalized)
-      );
-    }
-    if (opts.method) {
-      matchingEndpoints = matchingEndpoints.filter(
-        (ep) => ep.method?.toUpperCase() === opts.method.toUpperCase()
-      );
-    }
-    if (opts.service) {
-      matchingEndpoints = matchingEndpoints.filter(
-        (ep) => ep.service_name.toLowerCase() === opts.service.toLowerCase()
-      );
-    }
     for (const ep of matchingEndpoints) {
       const clientCalls = this.topoStore.getClientCallsByEndpoint(ep.id);
       if (clientCalls.length === 0) continue;
-      const byRepo = /* @__PURE__ */ new Map();
-      for (const call of clientCalls) {
-        const repo2 = call.source_repo_name;
-        if (!byRepo.has(repo2)) byRepo.set(repo2, []);
-        byRepo.get(repo2).push(call);
-      }
-      const clients = [];
-      for (const [repoName, calls] of byRepo) {
-        const repo2 = this.topoStore.getFederatedRepo(repoName);
-        for (const call of calls) {
-          const symbols = repo2?.db_path && fs25.existsSync(repo2.db_path) ? resolveSymbolsAtLocation(repo2.db_path, call.file_path, call.line) : [];
-          clients.push({
-            repo: repoName,
-            filePath: call.file_path,
-            line: call.line,
-            callType: call.call_type,
-            confidence: call.confidence,
-            symbols
-          });
-        }
-      }
+      const clients = this.collectEndpointClients(clientCalls);
       const uniqueRepos = new Set(clients.map((c) => c.repo));
-      const riskLevel3 = uniqueRepos.size >= 3 ? "critical" : uniqueRepos.size >= 2 ? "high" : clients.length >= 3 ? "medium" : "low";
+      const baseRisk = computeRiskLevel(uniqueRepos.size, clients.length);
       const svc = this.topoStore.getAllServices().find((s) => s.id === ep.service_id);
       const repo = svc ? this.topoStore.getFederatedRepo(svc.repo_root) : void 0;
-      let breakingChanges;
-      const contracts = this.topoStore.getContractsByService(ep.service_id);
-      for (const contract of contracts) {
-        const snapshot = this.topoStore.getLatestSnapshot(contract.id);
-        if (!snapshot) continue;
-        let oldEndpoints = [];
-        try {
-          const parsed = JSON.parse(snapshot.endpoints_json);
-          oldEndpoints = (parsed.endpoints ?? []).map((e) => ({ method: e.method ?? null, path: e.path, requestSchema: e.requestSchema, responseSchema: e.responseSchema }));
-        } catch {
-          continue;
-        }
-        const currentEndpoints = this.topoStore.getEndpointsByService(ep.service_id).map((e) => ({
-          method: e.method,
-          path: e.path,
-          requestSchema: e.request_schema,
-          responseSchema: e.response_schema
-        }));
-        const epDiffs = diffEndpoints(oldEndpoints, currentEndpoints).filter((d) => d.endpoint.path === ep.path && (d.endpoint.method ?? "*") === (ep.method ?? "*"));
-        if (epDiffs.length > 0 && epDiffs.some((d) => d.breaking)) {
-          breakingChanges = epDiffs;
-        }
-      }
-      let finalRiskLevel = riskLevel3;
-      if (breakingChanges?.some((d) => d.breaking)) {
-        const riskLevels = ["low", "medium", "high", "critical"];
-        const idx = riskLevels.indexOf(riskLevel3);
-        if (idx < riskLevels.length - 1) finalRiskLevel = riskLevels[idx + 1];
-      }
+      const breakingChanges = this.detectBreakingChanges(ep);
+      const riskLevel3 = upgradeRiskIfBreaking(baseRisk, breakingChanges);
       results.push({
         endpoint: {
           method: ep.method,
@@ -14016,13 +13660,152 @@ var FederationManager = class {
           repo: repo?.name ?? svc?.repo_root ?? "unknown"
         },
         clients,
-        riskLevel: finalRiskLevel,
+        riskLevel: riskLevel3,
         summary: `${ep.method ?? "*"} ${ep.path} is called by ${clients.length} client(s) in ${uniqueRepos.size} repo(s)${breakingChanges ? " \u26A0 BREAKING SCHEMA CHANGES" : ""}`,
         breakingChanges
       });
     }
     return results;
   }
+  /** Register contracts for a service, including explicitly provided paths. */
+  registerContracts(serviceId, serviceRoot, repoRoot, explicitPaths) {
+    const contracts = parseContracts(serviceRoot);
+    if (explicitPaths && repoRoot) {
+      for (const cp of explicitPaths) {
+        const absContract = path29.resolve(repoRoot, cp);
+        if (fs25.existsSync(absContract)) {
+          const additional = parseContracts(path29.dirname(absContract));
+          contracts.push(...additional.filter(
+            (c) => path29.resolve(repoRoot, c.specPath) === absContract
+          ));
+        }
+      }
+    }
+    for (const contract of contracts) {
+      const contractId = this.topoStore.insertContract(serviceId, {
+        contractType: contract.type,
+        specPath: contract.specPath,
+        version: contract.version,
+        parsedSpec: JSON.stringify({ endpoints: contract.endpoints, events: contract.events })
+      });
+      this.topoStore.insertEndpoints(
+        contractId,
+        serviceId,
+        contract.endpoints.map((e) => ({
+          method: e.method ?? void 0,
+          path: e.path,
+          operationId: e.operationId,
+          requestSchema: e.requestSchema ? JSON.stringify(e.requestSchema) : void 0,
+          responseSchema: e.responseSchema ? JSON.stringify(e.responseSchema) : void 0
+        }))
+      );
+      if (contract.events.length > 0) {
+        this.topoStore.insertEventChannels(
+          contractId,
+          serviceId,
+          contract.events.map((e) => ({
+            channelName: e.channelName,
+            direction: e.direction
+          }))
+        );
+      }
+    }
+  }
+  /** Snapshot existing contracts before replacing them (for drift detection). */
+  snapshotContracts(serviceId) {
+    const existing = this.topoStore.getContractsByService(serviceId);
+    for (const ec of existing) {
+      this.topoStore.insertContractSnapshot(ec.id, serviceId, {
+        version: ec.version,
+        specPath: ec.spec_path,
+        contentHash: ec.content_hash ?? "",
+        endpointsJson: ec.parsed_spec,
+        eventsJson: "[]"
+      });
+    }
+  }
+  /** Scan repo for client calls, insert them, link to endpoints, and build edges. */
+  scanAndLinkClientCalls(repoId, repoRoot) {
+    this.topoStore.deleteClientCallsByRepo(repoId);
+    const clientCalls = scanClientCalls(repoRoot);
+    if (clientCalls.length > 0) {
+      this.topoStore.insertClientCalls(clientCalls.map((c) => ({
+        sourceRepoId: repoId,
+        filePath: c.filePath,
+        line: c.line,
+        callType: c.callType,
+        method: c.method,
+        urlPattern: c.urlPattern,
+        confidence: c.confidence
+      })));
+    }
+    const linked = this.topoStore.linkClientCallsToEndpoints();
+    this.buildCrossServiceEdges();
+    return { scanned: clientCalls.length, linked };
+  }
+  filterEndpoints(opts) {
+    let endpoints = this.topoStore.getAllEndpoints();
+    if (opts.endpoint) {
+      const normalized = opts.endpoint.toLowerCase();
+      endpoints = endpoints.filter((ep) => ep.path.toLowerCase().includes(normalized));
+    }
+    if (opts.method) {
+      endpoints = endpoints.filter((ep) => ep.method?.toUpperCase() === opts.method.toUpperCase());
+    }
+    if (opts.service) {
+      endpoints = endpoints.filter((ep) => ep.service_name.toLowerCase() === opts.service.toLowerCase());
+    }
+    return endpoints;
+  }
+  collectEndpointClients(clientCalls) {
+    const byRepo = /* @__PURE__ */ new Map();
+    for (const call of clientCalls) {
+      const repo = call.source_repo_name;
+      if (!byRepo.has(repo)) byRepo.set(repo, []);
+      byRepo.get(repo).push(call);
+    }
+    const clients = [];
+    for (const [repoName, calls] of byRepo) {
+      const repo = this.topoStore.getFederatedRepo(repoName);
+      for (const call of calls) {
+        const symbols = repo?.db_path && fs25.existsSync(repo.db_path) ? resolveSymbolsAtLocation(repo.db_path, call.file_path, call.line) : [];
+        clients.push({
+          repo: repoName,
+          filePath: call.file_path,
+          line: call.line,
+          callType: call.call_type,
+          confidence: call.confidence,
+          symbols
+        });
+      }
+    }
+    return clients;
+  }
+  detectBreakingChanges(ep) {
+    const contracts = this.topoStore.getContractsByService(ep.service_id);
+    for (const contract of contracts) {
+      const snapshot = this.topoStore.getLatestSnapshot(contract.id);
+      if (!snapshot) continue;
+      let oldEndpoints = [];
+      try {
+        const parsed = JSON.parse(snapshot.endpoints_json);
+        oldEndpoints = (parsed.endpoints ?? []).map((e) => ({ method: e.method ?? null, path: e.path, requestSchema: e.requestSchema, responseSchema: e.responseSchema }));
+      } catch {
+        continue;
+      }
+      const currentEndpoints = this.topoStore.getEndpointsByService(ep.service_id).map((e) => ({
+        method: e.method,
+        path: e.path,
+        requestSchema: e.request_schema,
+        responseSchema: e.response_schema
+      }));
+      const epDiffs = diffEndpoints(oldEndpoints, currentEndpoints).filter((d) => d.endpoint.path === ep.path && (d.endpoint.method ?? "*") === (ep.method ?? "*"));
+      if (epDiffs.length > 0 && epDiffs.some((d) => d.breaking)) {
+        return epDiffs;
+      }
+    }
+    return void 0;
+  }
   /**
    * Search across all federated repos. Opens each per-repo DB readonly,
    * runs FTS search, normalizes scores, merges results.
@@ -14108,6 +13891,18 @@ var FederationManager = class {
     }
   }
 };
+function computeRiskLevel(uniqueRepoCount, clientCount) {
+  if (uniqueRepoCount >= 3) return "critical";
+  if (uniqueRepoCount >= 2) return "high";
+  if (clientCount >= 3) return "medium";
+  return "low";
+}
+function upgradeRiskIfBreaking(risk, breakingChanges) {
+  if (!breakingChanges?.some((d) => d.breaking)) return risk;
+  const levels = ["low", "medium", "high", "critical"];
+  const idx = levels.indexOf(risk);
+  return idx < levels.length - 1 ? levels[idx + 1] : risk;
+}
 function resolveSymbolsAtLocation(dbPath, filePath, line) {
   if (!line) return [];
   try {
@@ -24534,13 +24329,13 @@ function detectDrift(store, cwd, options = {}) {
     const commitsB = fileCommitCount.get(fileB) ?? 0;
     const denominator = commitsA + commitsB - count;
     if (denominator <= 0) continue;
-    const jaccard3 = count / denominator;
-    if (jaccard3 < minConfidence) continue;
+    const jaccard2 = count / denominator;
+    if (jaccard2 < minConfidence) continue;
     anomalies.push({
       file_a: fileA,
       file_b: fileB,
       co_change_count: count,
-      confidence: round2(jaccard3),
+      confidence: round2(jaccard2),
       module_a: moduleA,
       module_b: moduleB
     });
@@ -31074,7 +30869,7 @@ var TopologyStore = class {
 };
 
 // src/server/server.ts
-var PKG_VERSION = true ? "1.9.0" : "0.0.0-dev";
+var PKG_VERSION = true ? "1.10.0" : "0.0.0-dev";
 function j2(value) {
   return JSON.stringify(value, (_key, val) => val === null || val === void 0 ? void 0 : val);
 }
@@ -63089,18 +62884,6 @@ function shortPath2(p5) {
 // src/project-root.ts
 import fs90 from "fs";
 import path102 from "path";
-var ROOT_MARKERS = [
-  ".git",
-  "package.json",
-  "go.mod",
-  "Cargo.toml",
-  "composer.json",
-  "pyproject.toml",
-  "Gemfile",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts"
-];
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", "node_modules", "vendor", ".svn", "__pycache__", ".tox"]);
 function discoverChildProjects(parentDir) {
   const absParent = path102.resolve(parentDir);
@@ -64451,13 +64234,35 @@ function generateReport(input) {
   const riskAnalysis = computeRiskScores(store, rootPath, changedFileInfos, blastRadius);
   const architectureViolations = computeArchViolations(store, changedFiles, layers);
   const deadCode = computeDeadCode(store, changedFiles);
+  let domainAnalysis;
+  let ownershipAnalysis;
+  let deploymentImpact;
+  if (input.enableProjectAware !== false) {
+    try {
+      domainAnalysis = computeDomainAnalysis(store, changedFiles, blastRadius.entries);
+    } catch (e) {
+      logger.debug({ error: e }, "CI report: domain analysis skipped");
+    }
+    try {
+      ownershipAnalysis = computeOwnershipAnalysis(rootPath, changedFiles);
+    } catch (e) {
+      logger.debug({ error: e }, "CI report: ownership analysis skipped");
+    }
+    try {
+      deploymentImpact = computeDeploymentImpact(changedFiles, rootPath);
+    } catch (e) {
+      logger.debug({ error: e }, "CI report: deployment impact skipped");
+    }
+  }
   const summary = {
     changedFileCount: changedFiles.length,
     affectedFileCount: blastRadius.totalAffected,
     riskLevel: riskAnalysis.overallLevel,
     untestedGaps: testCoverage.gaps.length,
     violations: architectureViolations.totalViolations,
-    deadExports: deadCode.totalDead
+    deadExports: deadCode.totalDead,
+    ...domainAnalysis ? { domainsCrossed: domainAnalysis.domainsAffected.length } : {},
+    ...deploymentImpact ? { servicesAffected: deploymentImpact.servicesAffected.length } : {}
   };
   return {
     changedFiles: changedFileInfos,
@@ -64466,6 +64271,9 @@ function generateReport(input) {
     riskAnalysis,
     architectureViolations,
     deadCode,
+    ...domainAnalysis ? { domainAnalysis } : {},
+    ...ownershipAnalysis ? { ownershipAnalysis } : {},
+    ...deploymentImpact ? { deploymentImpact } : {},
     summary
   };
 }
@@ -64634,6 +64442,98 @@ function scoreToLevel(score) {
   if (score >= 0.25) return "medium";
   return "low";
 }
+function computeDomainAnalysis(store, changedFiles, blastEntries) {
+  const domainStore = new DomainStore(store.db);
+  const allDomains = domainStore.getAllDomains();
+  if (allDomains.length === 0) return void 0;
+  const domainCounts = /* @__PURE__ */ new Map();
+  for (const filePath of changedFiles) {
+    const file = store.getFile(filePath);
+    if (!file) continue;
+    const domains = domainStore.getDomainsForFile(file.id);
+    for (const d of domains) {
+      const existing = domainCounts.get(d.name) ?? { filesChanged: 0, filesImpacted: 0 };
+      existing.filesChanged++;
+      domainCounts.set(d.name, existing);
+    }
+  }
+  for (const entry of blastEntries) {
+    const file = store.getFile(entry.path);
+    if (!file) continue;
+    const domains = domainStore.getDomainsForFile(file.id);
+    for (const d of domains) {
+      const existing = domainCounts.get(d.name) ?? { filesChanged: 0, filesImpacted: 0 };
+      existing.filesImpacted++;
+      domainCounts.set(d.name, existing);
+    }
+  }
+  if (domainCounts.size === 0) return void 0;
+  const domainsAffected = [...domainCounts.entries()].map(([name, counts]) => ({ name, ...counts })).sort((a, b) => b.filesChanged + b.filesImpacted - (a.filesChanged + a.filesImpacted));
+  const crossDomainDeps = domainStore.getCrossDomainDependencies();
+  const affectedDomainNames = new Set(domainsAffected.map((d) => d.name));
+  const crossDomainChanges = crossDomainDeps.filter((dep) => affectedDomainNames.has(dep.source_domain) || affectedDomainNames.has(dep.target_domain)).map((dep) => ({ from: dep.source_domain, to: dep.target_domain, edgeCount: dep.edge_count }));
+  const reviewTeams = domainsAffected.filter((d) => d.filesChanged > 0).map((d) => d.name);
+  return { domainsAffected, crossDomainChanges, reviewTeams };
+}
+function computeOwnershipAnalysis(rootPath, changedFiles) {
+  if (changedFiles.length === 0) return void 0;
+  const ownerships = getFileOwnership(rootPath, changedFiles);
+  if (ownerships.length === 0) return void 0;
+  const owners = [];
+  const allAuthors = /* @__PURE__ */ new Set();
+  for (const ownership of ownerships) {
+    if (ownership.owners.length === 0) continue;
+    const primary = ownership.owners[0];
+    owners.push({
+      file: ownership.file,
+      primaryOwner: primary.author,
+      percentage: primary.percentage
+    });
+    for (const o of ownership.owners) {
+      allAuthors.add(o.author);
+    }
+  }
+  if (owners.length === 0) return void 0;
+  return {
+    owners: owners.sort((a, b) => a.file.localeCompare(b.file)),
+    teamsCrossed: [...allAuthors].sort()
+  };
+}
+function computeDeploymentImpact(changedFiles, rootPath) {
+  if (changedFiles.length === 0) return void 0;
+  let topoStore;
+  try {
+    topoStore = new TopologyStore(TOPOLOGY_DB_PATH);
+  } catch {
+    return void 0;
+  }
+  try {
+    const services = topoStore.getAllServices();
+    if (services.length === 0) return void 0;
+    const serviceCounts = /* @__PURE__ */ new Map();
+    for (const filePath of changedFiles) {
+      for (const svc of services) {
+        if (svc.repo_root && (rootPath === svc.repo_root || rootPath.startsWith(svc.repo_root + "/"))) {
+          const key = svc.name;
+          const existing = serviceCounts.get(key) ?? { name: svc.name, type: svc.service_type ?? "unknown", count: 0 };
+          existing.count++;
+          serviceCounts.set(key, existing);
+          break;
+        }
+      }
+    }
+    if (serviceCounts.size === 0) return void 0;
+    const servicesAffected = [...serviceCounts.values()].map((s) => ({ name: s.name, type: s.type, filesChanged: s.count })).sort((a, b) => b.filesChanged - a.filesChanged);
+    const affectedServiceNames = new Set(servicesAffected.map((s) => s.name));
+    const allEdges = topoStore.getAllCrossServiceEdges();
+    const crossServiceChanges = allEdges.filter(
+      (e) => affectedServiceNames.has(e.source_name) || affectedServiceNames.has(e.target_name)
+    ).length;
+    return { servicesAffected, crossServiceChanges };
+  } finally {
+    topoStore.close();
+  }
+}
 
 // src/ci/markdown-formatter.ts
 function formatMarkdown(report) {
@@ -64649,6 +64549,12 @@ function formatMarkdown(report) {
   lines.push(`| Untested affected paths | ${report.summary.untestedGaps} |`);
   lines.push(`| Architecture violations | ${report.summary.violations} |`);
   lines.push(`| Dead exports introduced | ${report.summary.deadExports} |`);
+  if (report.summary.domainsCrossed != null) {
+    lines.push(`| Domains crossed | ${report.summary.domainsCrossed} |`);
+  }
+  if (report.summary.servicesAffected != null) {
+    lines.push(`| Services affected | ${report.summary.servicesAffected} |`);
+  }
   lines.push("");
   if (report.changedFiles.length > 0) {
     const codeFiles = report.changedFiles.filter((f) => f.symbolCount > 0);
@@ -64746,6 +64652,84 @@ function formatMarkdown(report) {
     lines.push("</details>");
     lines.push("");
   }
+  if (report.domainAnalysis) {
+    const da = report.domainAnalysis;
+    lines.push(`<details><summary>Domain Boundaries (${da.domainsAffected.length} domains)</summary>`);
+    lines.push("");
+    if (da.reviewTeams.length > 0) {
+      lines.push(`**Review needed from:** ${da.reviewTeams.join(", ")}`);
+      lines.push("");
+    }
+    lines.push("| Domain | Changed Files | Impacted Files |");
+    lines.push("|--------|--------------|----------------|");
+    for (const d of da.domainsAffected) {
+      lines.push(`| ${d.name} | ${d.filesChanged} | ${d.filesImpacted} |`);
+    }
+    if (da.crossDomainChanges.length > 0) {
+      lines.push("");
+      lines.push("**Cross-domain dependencies:**");
+      lines.push("");
+      lines.push("| From | To | Edges |");
+      lines.push("|------|----|-------|");
+      for (const cd of da.crossDomainChanges) {
+        lines.push(`| ${cd.from} | ${cd.to} | ${cd.edgeCount} |`);
+      }
+    }
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
+  }
+  if (report.ownershipAnalysis) {
+    const oa = report.ownershipAnalysis;
+    lines.push(`<details><summary>Code Ownership (${oa.teamsCrossed.length} contributors)</summary>`);
+    lines.push("");
+    lines.push(`**Teams involved:** ${oa.teamsCrossed.join(", ")}`);
+    lines.push("");
+    lines.push("| File | Primary Owner | Ownership % |");
+    lines.push("|------|--------------|-------------|");
+    for (const o of oa.owners) {
+      lines.push(`| \`${o.file}\` | ${o.primaryOwner} | ${o.percentage}% |`);
+    }
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
+  }
+  if (report.deploymentImpact) {
+    const di = report.deploymentImpact;
+    lines.push(`<details><summary>Deployment Impact (${di.servicesAffected.length} services)</summary>`);
+    lines.push("");
+    lines.push("| Service | Type | Changed Files |");
+    lines.push("|---------|------|--------------|");
+    for (const s of di.servicesAffected) {
+      lines.push(`| ${s.name} | ${s.type} | ${s.filesChanged} |`);
+    }
+    if (di.crossServiceChanges > 0) {
+      lines.push("");
+      lines.push(`**Cross-service edges affected:** ${di.crossServiceChanges}`);
+    }
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
+  }
+  if (report.baseline) {
+    const b = report.baseline;
+    const commitRef = b.baselineCommit ? ` (vs ${b.baselineCommit})` : "";
+    lines.push(`<details open><summary>Trend vs Baseline${commitRef}</summary>`);
+    lines.push("");
+    lines.push("| Metric | Delta | |");
+    lines.push("|--------|-------|-|");
+    lines.push(`| Risk score | ${formatDelta(b.riskDelta)} | ${arrow(b.riskDelta, true)} |`);
+    lines.push(`| Untested gaps | ${formatDeltaInt(b.untestedDelta)} | ${arrow(b.untestedDelta, true)} |`);
+    lines.push(`| Violations | ${formatDeltaInt(b.violationsDelta)} | ${arrow(b.violationsDelta, true)} |`);
+    lines.push(`| Dead exports | ${formatDeltaInt(b.deadExportsDelta)} | ${arrow(b.deadExportsDelta, true)} |`);
+    if (b.regressionDetected) {
+      lines.push("");
+      lines.push("**Warning: quality regression detected**");
+    }
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
+  }
   lines.push("---");
   lines.push("_Generated by [trace-mcp](https://github.com/nikolai-vysotskyi/trace-mcp) CI Report_");
   return lines.join("\n");
@@ -64753,6 +64737,117 @@ function formatMarkdown(report) {
 function formatJson(report) {
   return JSON.stringify(report, null, 2);
 }
+function formatDelta(n) {
+  return n >= 0 ? `+${Math.round(n * 100) / 100}` : `${Math.round(n * 100) / 100}`;
+}
+function formatDeltaInt(n) {
+  return n >= 0 ? `+${n}` : `${n}`;
+}
+function arrow(n, higherIsWorse) {
+  if (n === 0) return "-";
+  const up = n > 0;
+  if (higherIsWorse) return up ? "\u25B2 worse" : "\u25BC better";
+  return up ? "\u25B2 better" : "\u25BC worse";
+}
+
+// src/ci/baseline.ts
+var SNAPSHOT_TYPE = "ci_quality_baseline";
+var REGRESSION_THRESHOLD = 0.15;
+function captureBaseline(store, report, commitHash) {
+  store.insertGraphSnapshot(SNAPSHOT_TYPE, {
+    riskScore: report.riskAnalysis.overallScore,
+    riskLevel: report.riskAnalysis.overallLevel,
+    untestedGaps: report.testCoverage.totalUntested,
+    violations: report.architectureViolations.totalViolations,
+    deadExports: report.deadCode.totalDead,
+    changedFiles: report.summary.changedFileCount,
+    affectedFiles: report.summary.affectedFileCount
+  }, commitHash);
+}
+function compareWithBaseline(store, current) {
+  const snapshots = store.getGraphSnapshots(SNAPSHOT_TYPE, { limit: 1 });
+  if (snapshots.length === 0) return null;
+  const snapshot = snapshots[0];
+  const baseline = JSON.parse(snapshot.data);
+  const riskDelta = current.riskAnalysis.overallScore - baseline.riskScore;
+  return {
+    riskDelta: Math.round(riskDelta * 100) / 100,
+    untestedDelta: current.testCoverage.totalUntested - baseline.untestedGaps,
+    violationsDelta: current.architectureViolations.totalViolations - baseline.violations,
+    deadExportsDelta: current.deadCode.totalDead - baseline.deadExports,
+    regressionDetected: riskDelta > REGRESSION_THRESHOLD,
+    baselineCommit: snapshot.commit_hash,
+    baselineDate: snapshot.created_at
+  };
+}
+
+// src/ci/github-annotations.ts
+function generateAnnotations(report) {
+  const annotations = [];
+  for (const v of report.architectureViolations.violations) {
+    annotations.push({
+      path: v.source_file,
+      start_line: 1,
+      end_line: 1,
+      annotation_level: "failure",
+      title: "Architecture violation",
+      message: `${v.source_layer} \u2192 ${v.target_layer}: ${v.rule}`
+    });
+  }
+  for (const f of report.riskAnalysis.files.filter((f2) => f2.score >= 0.5)) {
+    annotations.push({
+      path: f.file,
+      start_line: 1,
+      end_line: 1,
+      annotation_level: "warning",
+      title: "High risk file",
+      message: `Risk score ${f.score} (complexity=${f.complexity}, churn=${f.churn}, coupling=${f.coupling})`
+    });
+  }
+  for (const gap of report.testCoverage.gaps.slice(0, 10)) {
+    annotations.push({
+      path: gap.file,
+      start_line: 1,
+      end_line: 1,
+      annotation_level: "notice",
+      title: "Untested export",
+      message: `${gap.kind} "${gap.name}" has no test coverage`
+    });
+  }
+  if (report.domainAnalysis) {
+    for (const cd of report.domainAnalysis.crossDomainChanges.slice(0, 5)) {
+      annotations.push({
+        path: "",
+        start_line: 0,
+        end_line: 0,
+        annotation_level: "notice",
+        title: "Cross-domain dependency",
+        message: `${cd.from} \u2192 ${cd.to} (${cd.edgeCount} edges)`
+      });
+    }
+  }
+  if (report.baseline?.regressionDetected) {
+    annotations.push({
+      path: "",
+      start_line: 0,
+      end_line: 0,
+      annotation_level: "warning",
+      title: "Quality regression",
+      message: `Risk score increased by ${report.baseline.riskDelta} vs baseline (commit ${report.baseline.baselineCommit ?? "unknown"})`
+    });
+  }
+  return annotations;
+}
+function formatGitHubActions(annotations) {
+  return annotations.map((a) => {
+    const file = a.path ? `file=${a.path},` : "";
+    const line = a.start_line > 0 ? `line=${a.start_line},` : "";
+    return `::${a.annotation_level} ${file}${line}title=${a.title}::${a.message}`;
+  }).join("\n");
+}
+function formatAnnotationsJson(annotations) {
+  return JSON.stringify(annotations, null, 2);
+}
 
 // src/cli/ci.ts
 function resolveDbPath(projectRoot) {
@@ -64760,7 +64855,7 @@ function resolveDbPath(projectRoot) {
   if (entry) return entry.dbPath;
   return getDbPath(projectRoot);
 }
-var ciReportCommand = new Command5("ci-report").description("Generate a change impact report for a PR/branch").option("--base <ref>", "Base git ref (default: main)", "main").option("--head <ref>", "Head git ref (default: HEAD)", "HEAD").option("--format <fmt>", "Output format: markdown | json (default: markdown)", "markdown").option("--output <path>", "Output file path (default: stdout, use - for stdout)", "-").option("--fail-on <level>", "Exit with code 1 if risk >= level: critical | high | medium", "").option("--index", "Index the project before generating the report", false).action(async (opts) => {
+var ciReportCommand = new Command5("ci-report").description("Generate a change impact report for a PR/branch").option("--base <ref>", "Base git ref (default: main)", "main").option("--head <ref>", "Head git ref (default: HEAD)", "HEAD").option("--format <fmt>", "Output format: markdown | json (default: markdown)", "markdown").option("--output <path>", "Output file path (default: stdout, use - for stdout)", "-").option("--fail-on <level>", "Exit with code 1 if risk >= level: critical | high | medium", "").option("--index", "Index the project before generating the report", false).option("--no-project-aware", "Disable domain/ownership/deployment analysis").option("--save-baseline", "Save current scores as quality baseline", false).option("--fail-regression", "Exit 1 if quality regressed vs baseline", false).option("--annotations <format>", "Output annotations: github-actions | json").action(async (opts) => {
   let projectRoot;
   try {
     projectRoot = findProjectRoot(process.cwd());
@@ -64787,7 +64882,9 @@ ${msg}
     include: ["**/*"],
     exclude: ["vendor/**", "node_modules/**", ".git/**"],
     db: { path: "" },
-    plugins: []
+    plugins: [],
+    ignore: { directories: [], patterns: [] },
+    watch: { enabled: false, debounceMs: 2e3 }
   };
   const dbPath = resolveDbPath(projectRoot);
   ensureGlobalDirs();
@@ -64805,10 +64902,35 @@ ${msg}
   const report = generateReport({
     changedFiles,
     store,
-    rootPath: projectRoot
+    rootPath: projectRoot,
+    enableProjectAware: opts.projectAware
   });
+  const baseline = compareWithBaseline(store, report);
+  if (baseline) {
+    report.baseline = baseline;
+  }
+  if (opts.saveBaseline) {
+    let commitHash = "unknown";
+    try {
+      commitHash = execFileSync7("git", ["rev-parse", "--short", "HEAD"], {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+    } catch {
+    }
+    captureBaseline(store, report, commitHash);
+    logger.info({ commit: commitHash }, "CI report: baseline saved");
+  }
   const output = opts.format === "json" ? formatJson(report) : formatMarkdown(report);
   writeOutput(opts.output, output);
+  if (opts.annotations) {
+    const annotations = generateAnnotations(report);
+    if (annotations.length > 0) {
+      const annotationOutput = opts.annotations === "json" ? formatAnnotationsJson(annotations) : formatGitHubActions(annotations);
+      writeOutput("-", annotationOutput);
+    }
+  }
   db.close();
   if (opts.failOn) {
     const levels = ["low", "medium", "high", "critical"];
@@ -64819,6 +64941,10 @@ ${msg}
       process.exit(1);
     }
   }
+  if (opts.failRegression && baseline?.regressionDetected) {
+    logger.warn({ riskDelta: baseline.riskDelta }, "CI report: quality regression detected");
+    process.exit(1);
+  }
 });
 function getChangedFiles(cwd, base, head) {
   try {
@@ -65666,7 +65792,7 @@ trace-mcp status \u2014 ${projectRoot}
 });
 
 // src/cli.ts
-var PKG_VERSION2 = true ? "1.9.0" : "0.0.0-dev";
+var PKG_VERSION2 = true ? "1.10.0" : "0.0.0-dev";
 function registerDefaultPlugins(registry) {
   for (const p5 of createAllLanguagePlugins()) registry.registerLanguagePlugin(p5);
   for (const p5 of createAllIntegrationPlugins()) registry.registerFrameworkPlugin(p5);