@monoes/monograph 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monograph",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "type": "module",
   "description": "Native TypeScript code intelligence engine for monomind",
   "main": "dist/src/index.js",

package/src/analysis/cluster-quality.ts

@@ -98,46 +98,45 @@ export function silhouetteScore(
 }
 
 /**
- * Compute Newman–Girvan modularity Q.
+ * Compute Newman–Girvan modularity Q using the community-level formula:
+ *   Q = Σ_c [e_c / m - (a_c / 2m)²]
+ * where e_c = intra-community edges, a_c = sum of degrees in community c, m = total edges.
  *
- * Q = (1/2m) * Σ_{ij} [A_ij - k_i*k_j/(2m)] * δ(c_i, c_j)
- *
- * where m = total edge count, k_i = degree of node i, A_ij = adjacency.
+ * O(E + N) instead of O(N²).
  * Returns a value in (-0.5, 1].
  */
 export function modularityScore(
   memberships: Map<string, number>,
   edges: Edge[],
 ): number {
+  if (edges.length === 0 || memberships.size === 0) return 0;
+
   const adj = buildAdjacency(edges);
+  const m = edges.length; // directed edges count (each undirected pair counted once in input)
 
-  // Degree map (undirected) — use adj to count undirected edges correctly
-  const degree = new Map<string, number>();
-  for (const [nodeId, neighbors] of adj) {
-    degree.set(nodeId, neighbors.size);
+  // Sum of degrees per community and intra-community edge count
+  const communityDegreeSum = new Map<number, number>();
+  const intraCommunityEdges = new Map<number, number>();
+
+  for (const [nodeId, cid] of memberships) {
+    const deg = adj.get(nodeId)?.size ?? 0;
+    communityDegreeSum.set(cid, (communityDegreeSum.get(cid) ?? 0) + deg);
   }
 
-  // m_undirected: each undirected edge is counted once in adj (both directions added)
-  // so sum of degrees = 2 * m_undirected
-  const totalDegree = [...degree.values()].reduce((s, d) => s + d, 0);
-  const m = totalDegree / 2;
-  if (m === 0) return 0;
+  for (const { sourceId, targetId } of edges) {
+    const cs = memberships.get(sourceId);
+    const ct = memberships.get(targetId);
+    if (cs !== undefined && ct !== undefined && cs === ct) {
+      intraCommunityEdges.set(cs, (intraCommunityEdges.get(cs) ?? 0) + 1);
+    }
+  }
 
   const twoM = 2 * m;
   let Q = 0;
-
-  const nodes = [...memberships.keys()];
-  for (let i = 0; i < nodes.length; i++) {
-    const u = nodes[i]!;
-    for (let j = i + 1; j < nodes.length; j++) {
-      const v = nodes[j]!;
-      if (memberships.get(u) !== memberships.get(v)) continue;
-      const aij = adj.get(u)?.has(v) ? 1 : 0;
-      const ki = degree.get(u) ?? 0;
-      const kj = degree.get(v) ?? 0;
-      Q += aij - (ki * kj) / twoM;
-    }
+  for (const [cid, degSum] of communityDegreeSum) {
+    const ec = intraCommunityEdges.get(cid) ?? 0;
+    Q += ec / m - (degSum / twoM) ** 2;
   }
 
-  return Q / m; // normalise by m (equivalent to 1/(2m) summed both directions)
+  return Q;
 }

package/src/analysis/combined.ts

@@ -29,6 +29,8 @@ export function resolveAnalyses(opts: CombinedOptions): Set<AnalysisKind> {
   return result;
 }
 
+// monolean: stub — resolves which analyses to run but doesn't execute them.
+// Wire up when dead-code/duplication detectors are called from a unified entry point.
 export async function runCombined(
   db: MonographDb,
   opts: CombinedOptions

package/src/analysis/targets.ts

@@ -44,13 +44,12 @@ export function computeRefactoringTargets(db: MonographDb): RefactoringTargetsRe
       n.id,
       n.file_path,
       n.properties,
-      COUNT(DISTINCT e_in.id) as in_degree,
-      COUNT(DISTINCT e_out.id) as out_degree
+      COALESCE(d_in.cnt, 0) as in_degree,
+      COALESCE(d_out.cnt, 0) as out_degree
     FROM nodes n
-    LEFT JOIN edges e_in ON e_in.target_id = n.id
-    LEFT JOIN edges e_out ON e_out.source_id = n.id
+    LEFT JOIN (SELECT target_id, COUNT(*) AS cnt FROM edges GROUP BY target_id) d_in ON d_in.target_id = n.id
+    LEFT JOIN (SELECT source_id, COUNT(*) AS cnt FROM edges GROUP BY source_id) d_out ON d_out.source_id = n.id
     WHERE n.label = 'File' AND n.file_path IS NOT NULL
-    GROUP BY n.id
   `).all() as FileNodeRow[];
 
   if (rows.length === 0) {

package/src/export/analysis-json.ts

@@ -82,6 +82,6 @@ export function buildDuplicationResultsEnvelope(
 
 export function stripRootPrefix(obj: unknown, rootPrefix: string): unknown {
   const json = JSON.stringify(obj);
-  const escaped = rootPrefix.replace(/[/\\]/g, s => `\\${s}`);
+  const escaped = rootPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   return JSON.parse(json.replace(new RegExp(escaped, 'g'), ''));
 }

package/src/export/sarif.ts

@@ -1,6 +1,15 @@
 import type Database from 'better-sqlite3';
 import { createHash } from 'crypto';
-import { relative } from 'path';
+import { readFileSync } from 'fs';
+import { relative, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_VERSION = (() => {
+  try {
+    return JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8')).version ?? '0.0.0';
+  } catch { return '0.0.0'; }
+})();
 
 export interface SarifRule {
   id: string;
@@ -231,6 +240,6 @@ export function exportHealthSarif(findings: SarifHealthFinding[], root?: string)
   return {
     $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
     version: '2.1.0',
-    runs: [{ tool: { driver: { name: 'monograph-health', version: '1.0.0', rules } }, results }],
+    runs: [{ tool: { driver: { name: 'monograph-health', version: PKG_VERSION, rules } }, results }],
   };
 }

package/src/graph/baseline.ts

@@ -126,15 +126,19 @@ export function extractFindingsFromDb(
 
   // God nodes (degree > 50)
   const gods = db.prepare(`
-    SELECT n.id, n.name, n.file_path, n.start_line,
-           COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) as degree
+    SELECT n.id, n.name, n.file_path, n.start_line, d.deg as degree
     FROM nodes n
-    LEFT JOIN edges e1 ON e1.source_id = n.id
-    LEFT JOIN edges e2 ON e2.target_id = n.id
-    GROUP BY n.id
-    HAVING degree > 50
-    ORDER BY degree DESC
-    LIMIT 100
+    JOIN (
+      SELECT node_id, SUM(cnt) AS deg FROM (
+        SELECT source_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY source_id
+        UNION ALL
+        SELECT target_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY target_id
+      ) GROUP BY node_id
+      HAVING deg > 50
+      ORDER BY deg DESC
+      LIMIT 100
+    ) d ON d.node_id = n.id
+    ORDER BY d.deg DESC
   `).all() as { id: string; name: string; file_path: string | null; start_line: number | null; degree: number }[];
 
   for (const n of gods) {
@@ -173,20 +177,25 @@ export function extractFindingsFromDb(
     });
   }
 
-  // Bridge nodes: nodes whose edges span more than one community_id
-  // Use JOIN+GROUP BY instead of correlated subqueries to avoid N*2 subquery executions
+  // Bridge nodes: nodes whose edges span 2+ distinct foreign communities.
+  // Pre-aggregate cross-community counts per direction to avoid 4-way cross product.
   const bridges = db.prepare(`
-    SELECT n.id, n.name, n.file_path, n.start_line,
-           COUNT(DISTINCT CASE WHEN e_out.source_id = n.id AND n_tgt.community_id != n.community_id THEN n_tgt.community_id END) +
-           COUNT(DISTINCT CASE WHEN e_in.target_id = n.id AND n_src.community_id != n.community_id THEN n_src.community_id END) AS cross_communities
+    SELECT n.id, n.name, n.file_path, n.start_line
     FROM nodes n
-    LEFT JOIN edges e_out ON e_out.source_id = n.id
-    LEFT JOIN nodes n_tgt ON n_tgt.id = e_out.target_id AND n_tgt.community_id IS NOT NULL
-    LEFT JOIN edges e_in ON e_in.target_id = n.id
-    LEFT JOIN nodes n_src ON n_src.id = e_in.source_id AND n_src.community_id IS NOT NULL
-    WHERE n.community_id IS NOT NULL
-    GROUP BY n.id
-    HAVING cross_communities >= 2
+    JOIN (
+      SELECT node_id, COUNT(DISTINCT foreign_community) AS cross_cnt FROM (
+        SELECT e.source_id AS node_id, n2.community_id AS foreign_community
+        FROM edges e
+        JOIN nodes n1 ON n1.id = e.source_id AND n1.community_id IS NOT NULL
+        JOIN nodes n2 ON n2.id = e.target_id AND n2.community_id IS NOT NULL AND n2.community_id != n1.community_id
+        UNION ALL
+        SELECT e.target_id AS node_id, n1.community_id AS foreign_community
+        FROM edges e
+        JOIN nodes n1 ON n1.id = e.source_id AND n1.community_id IS NOT NULL
+        JOIN nodes n2 ON n2.id = e.target_id AND n2.community_id IS NOT NULL AND n1.community_id != n2.community_id
+      ) GROUP BY node_id
+      HAVING cross_cnt >= 2
+    ) b ON b.node_id = n.id
     LIMIT 100
   `).all() as { id: string; name: string; file_path: string | null; start_line: number | null }[];
 

package/src/graph/health-score.ts

@@ -33,7 +33,7 @@ export function computeHealthScore(db: Database.Database): HealthScoreResult {
 
   // ── Unreachable file nodes ────────────────────────────────────────────────
   const unreachableRow = db.prepare(
-    "SELECT COUNT(*) as c FROM nodes WHERE label = 'File' AND properties LIKE '%\"unreachable\"%'"
+    "SELECT COUNT(*) as c FROM nodes WHERE label = 'File' AND json_extract(properties, '$.unreachable') = 1"
   ).get() as { c: number };
   const unreachableFiles = unreachableRow.c;
 
@@ -42,23 +42,20 @@ export function computeHealthScore(db: Database.Database): HealthScoreResult {
   const totalNodes = totalNodesRow.c;
 
   // ── p95 degree (god nodes) ────────────────────────────────────────────────
-  const degreesRows = db.prepare(`
-    SELECT source_id as node_id, COUNT(*) as deg FROM edges GROUP BY source_id
-    UNION ALL
-    SELECT target_id as node_id, COUNT(*) as deg FROM edges GROUP BY target_id
-  `).all() as { node_id: string; deg: number }[];
-
-  // Sum degrees per node
-  const degMap = new Map<string, number>();
-  for (const row of degreesRows) {
-    degMap.set(row.node_id, (degMap.get(row.node_id) ?? 0) + row.deg);
-  }
-  const degrees = [...degMap.values()].sort((a, b) => a - b);
-  const p95Index = Math.floor(degrees.length * 0.95);
-  const p95Degree = degrees[p95Index] ?? 0;
+  // Compute per-node total degree (in + out) entirely in SQL
+  const degreeRows = db.prepare(`
+    SELECT node_id, SUM(cnt) AS degree FROM (
+      SELECT source_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY source_id
+      UNION ALL
+      SELECT target_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY target_id
+    ) GROUP BY node_id ORDER BY degree ASC
+  `).all() as { node_id: string; degree: number }[];
+
+  const p95Index = Math.floor(degreeRows.length * 0.95);
+  const p95Degree = degreeRows[p95Index]?.degree ?? 0;
 
   const godNodeCount = p95Degree > 0
-    ? [...degMap.values()].filter(d => d > p95Degree).length
+    ? degreeRows.filter(r => r.degree > p95Degree).length
     : 0;
 
   // ── Circular edges (bidirectional import pairs) ───────────────────────────

package/src/graph/hotspots.ts

@@ -123,12 +123,16 @@ export function computeHotspots(
   // ── Step 3: Get file nodes + centrality from DB ───────────────────────────
   const fileNodes = db.prepare(`
     SELECT n.id, n.name, n.file_path, n.label, n.community_id,
-           COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) as degree
+           COALESCE(d.deg, 0) as degree
     FROM nodes n
-    LEFT JOIN edges e1 ON e1.source_id = n.id
-    LEFT JOIN edges e2 ON e2.target_id = n.id
+    LEFT JOIN (
+      SELECT node_id, SUM(cnt) AS deg FROM (
+        SELECT source_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY source_id
+        UNION ALL
+        SELECT target_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY target_id
+      ) GROUP BY node_id
+    ) d ON d.node_id = n.id
     WHERE n.label = 'File' AND n.file_path IS NOT NULL
-    GROUP BY n.id
   `).all() as { id: string; name: string; file_path: string; label: string; community_id: number | null; degree: number }[];
 
   // ── Step 4: Join churn + centrality ──────────────────────────────────────

package/src/graph/statistics.ts

@@ -77,21 +77,24 @@ export function clusteringCoefficient(db: MonographDb): number {
   let totalCoeff = 0;
   let countWithNeighbors = 0;
 
+  // Cap per-node neighbor scan to avoid O(k²) explosion on hub nodes
+  const MAX_K = 200;
   for (const [node, nbrs] of neighbors) {
     const k = nbrs.size;
     if (k < 2) continue;
 
     let triangles = 0;
-    const nbList = [...nbrs];
-    for (let i = 0; i < nbList.length; i++) {
-      for (let j = i + 1; j < nbList.length; j++) {
+    const nbList = k <= MAX_K ? [...nbrs] : [...nbrs].slice(0, MAX_K);
+    const effectiveK = nbList.length;
+    for (let i = 0; i < effectiveK; i++) {
+      for (let j = i + 1; j < effectiveK; j++) {
         if (neighbors.get(nbList[i])?.has(nbList[j])) {
           triangles++;
         }
       }
     }
 
-    const possible = (k * (k - 1)) / 2;
+    const possible = (effectiveK * (effectiveK - 1)) / 2;
     totalCoeff += triangles / possible;
     countWithNeighbors++;
   }
@@ -112,19 +115,28 @@ export interface PathStats {
 }
 
 /**
- * Compute both average path length and graph diameter in a single BFS pass.
- * Unreachable pairs are excluded from averagePathLength.
+ * Compute both average path length and graph diameter via BFS.
+ * For graphs > 500 nodes, uses deterministic sampling (every Nth node)
+ * to keep runtime practical — O(sample * E) instead of O(N * E).
  */
 export function pathStats(db: MonographDb): PathStats {
   const graph = getGraph(db);
   const nodes = graph.nodes();
   if (nodes.length < 2) return { averagePathLength: 0, diameter: 0 };
 
+  // Sample sources for large graphs — stride ensures even coverage
+  const MAX_SOURCES = 500;
+  const stride = nodes.length <= MAX_SOURCES ? 1 : Math.ceil(nodes.length / MAX_SOURCES);
+  const sources: string[] = [];
+  for (let i = 0; i < nodes.length && sources.length < MAX_SOURCES; i += stride) {
+    sources.push(nodes[i]);
+  }
+
   let totalLength = 0;
   let reachablePairs = 0;
   let maxDist = 0;
 
-  for (const source of nodes) {
+  for (const source of sources) {
     bfsFromNode(graph, source, (node, _attr, depth) => {
       if (node !== source && depth > 0) {
         totalLength += depth;

package/src/graph/stats.ts

@@ -143,10 +143,11 @@ export function computeGraphStats(db: Database.Database): GraphStatsSummary {
 /** Format a GraphStatsSummary as structured text for LLM consumption. */
 export function formatGraphStats(s: GraphStatsSummary): string {
   const cp = s.couplingProfile;
+  const totalEntities = cp.fanInProfile.low + cp.fanInProfile.medium + cp.fanInProfile.high + cp.fanInProfile.critical;
   const lines: string[] = [
     `Graph Stats`,
     `  Nodes: ${s.nodeCount}  Edges: ${s.edgeCount}  Communities: ${s.communityCount}  Files: ${s.fileCount}`,
-    `Coupling Profile (${cp.totalFiles} files)`,
+    `Coupling Profile (${totalEntities} entities, ${cp.totalFiles} files)`,
     `  Fan-in p50/p75/p90/p95: ${cp.p50FanIn}/${cp.p75FanIn}/${cp.p90FanIn}/${cp.p95FanIn}`,
     `  High-coupling (>p95): ${cp.couplingHighPct}%`,
     `Fan-in Risk: low=${cp.fanInProfile.low}(${cp.fanInProfile.lowPct}%) med=${cp.fanInProfile.medium}(${cp.fanInProfile.mediumPct}%) high=${cp.fanInProfile.high}(${cp.fanInProfile.highPct}%) crit=${cp.fanInProfile.critical}(${cp.fanInProfile.criticalPct}%)`,

package/src/index.ts

@@ -16,6 +16,9 @@ export * from './export/html.js';
 export * from './export/cypher.js';
 export * from './export/graphml.js';
 export * from './export/svg.js';
+export * from './export/obsidian.js';
+export * from './export/canvas.js';
+export * from './export/mermaid.js';
 export * from './mcp-tools/index.js';
 export * from './staleness/git-staleness.js';
 export * from './search/rrf.js';

package/src/pipeline/orchestrator.ts

@@ -26,6 +26,7 @@ import type { PipelineOptions, PipelineContext } from './types.js';
 import { DEFAULT_OPTIONS } from './types.js';
 import type { PipelineProgress, SuggestedQuestion } from '../types.js';
 import { generateGraphReport } from '../reporting/graph-report.js';
+import { analyzeChurn } from '../analysis/churn.js';
 
 function getCurrentCommitHash(repoPath: string): string | null {
   try {
@@ -164,10 +165,46 @@ async function buildAsyncLocked(
       await generateGraphReport(resolve(repoPath), undefined, dbPath, questions);
     }
 
+    // Populate churnScore on File nodes from git history (6-month window)
+    try {
+      const churnResult = await analyzeChurn(ctx.repoPath, '6m');
+      if (churnResult.files.length > 0) {
+        // Only consider files that exist as graph nodes for normalization —
+        // build artifacts and config files inflate the denominator otherwise
+        const graphFiles = new Set(
+          (db.prepare("SELECT file_path FROM nodes WHERE label = 'File' AND file_path IS NOT NULL").all() as { file_path: string }[])
+            .map(r => r.file_path),
+        );
+        const graphChurn = churnResult.files.filter(f => graphFiles.has(f.path));
+        const maxWeighted = graphChurn.reduce((m, f) => f.weightedCommits > m ? f.weightedCommits : m, 0);
+        if (maxWeighted > 0) {
+          const updateProps = db.prepare(`
+            UPDATE nodes SET properties = json_set(COALESCE(properties, '{}'), '$.churnScore', ?)
+            WHERE file_path = ? AND label = 'File'
+          `);
+          db.transaction(() => {
+            for (const f of graphChurn) {
+              updateProps.run(f.weightedCommits / maxWeighted, f.path);
+            }
+          })();
+        }
+      }
+    } catch {
+      // churn analysis is non-fatal (e.g. no git history)
+    }
+
     const hash = getCurrentCommitHash(resolve(repoPath));
     if (hash) {
       db.prepare("INSERT OR REPLACE INTO index_meta VALUES ('last_commit_hash', ?)").run(hash);
+    } else {
+      const msg = 'Could not determine git HEAD — staleness tracking will be unavailable';
+      if (options.onProgress) {
+        options.onProgress({ phase: 'warning', message: msg } as PipelineProgress);
+      } else {
+        process.stderr.write(`[monograph] ${msg}\n`);
+      }
     }
+    db.prepare("INSERT OR REPLACE INTO index_meta VALUES ('indexed_at', ?)").run(new Date().toISOString());
   } finally {
     closeDb(db);
   }

package/src/reporting/graph-report.ts

@@ -54,16 +54,15 @@ function queryEdgesByRelation(db: MonographDb): EdgeRelationStat[] {
 
 function queryTopNodesByDegree(db: MonographDb, limit = 10): TopDegreeNode[] {
   const rows = db.prepare(`
-    SELECT
-      n.id,
-      n.name,
-      n.label,
-      (
-        SELECT COUNT(*) FROM edges WHERE source_id = n.id
-      ) + (
-        SELECT COUNT(*) FROM edges WHERE target_id = n.id
-      ) AS degree
+    SELECT n.id, n.name, n.label, COALESCE(d.degree, 0) AS degree
     FROM nodes n
+    LEFT JOIN (
+      SELECT node_id, SUM(cnt) AS degree FROM (
+        SELECT source_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY source_id
+        UNION ALL
+        SELECT target_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY target_id
+      ) GROUP BY node_id
+    ) d ON d.node_id = n.id
     ORDER BY degree DESC
     LIMIT ?
   `).all(limit) as TopDegreeNode[];

package/src/staleness/git-staleness.ts

@@ -28,10 +28,13 @@ export function checkStaleness(db: MonographDb, repoPath: string): StalenessRepo
   const indexedCommitShort = indexedCommitFull ? indexedCommitFull.slice(0, 7) : null;
   const currentCommitShort = currentCommit ? currentCommit.slice(0, 7) : null;
 
-  // 3. If no stored commit or short SHAs match, not stale
-  if (!indexedCommitFull || indexedCommitShort === currentCommitShort) {
+  // 3. If SHAs match → fresh. If no stored commit → staleness unknown (not "fresh").
+  if (indexedCommitShort === currentCommitShort) {
     return { isStale: false, indexedAt: null, indexedCommit: indexedCommitShort, currentCommit: currentCommitShort, changedSince: [], staleSince: null };
   }
+  if (!indexedCommitFull) {
+    return { isStale: true, indexedAt: null, indexedCommit: null, currentCommit: currentCommitShort, changedSince: [], staleSince: null };
+  }
 
   // Guard: indexedCommitFull is read from SQLite — validate before shell interpolation
   if (!/^[0-9a-f]{7,40}$/i.test(indexedCommitFull)) {

package/src/storage/db.ts

@@ -5,6 +5,9 @@ import {
   CREATE_NODES, CREATE_EDGES, CREATE_COMMUNITIES,
   CREATE_INDEX_META, CREATE_NODES_FTS, CREATE_INDEXES, FTS_SYNC_TRIGGERS,
   CREATE_EMBEDDINGS, CREATE_WIKI_PAGES,
+  CREATE_AGENT_INTERACTIONS, CREATE_AGENT_INTERACTIONS_IDX,
+  CREATE_AGENT_INTERACTIONS_ORG_IDX, CREATE_AGENT_INTERACTIONS_TYPE_IDX,
+  CREATE_AGENT_INTERACTIONS_TS_IDX,
 } from './schema.js';
 import { MonographError } from '../types.js';
 
@@ -45,6 +48,11 @@ function applyMigrations(db: MonographDb): void {
   db.exec(FTS_SYNC_TRIGGERS);
   db.exec(CREATE_EMBEDDINGS);
   db.exec(CREATE_WIKI_PAGES);
+  db.exec(CREATE_AGENT_INTERACTIONS);
+  db.exec(CREATE_AGENT_INTERACTIONS_IDX);
+  db.exec(CREATE_AGENT_INTERACTIONS_ORG_IDX);
+  db.exec(CREATE_AGENT_INTERACTIONS_TYPE_IDX);
+  db.exec(CREATE_AGENT_INTERACTIONS_TS_IDX);
 
   // Schema version table — tracks incremental column additions.
   db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY)`);

package/src/storage/schema.ts

@@ -124,6 +124,36 @@ export const CREATE_FILE_CACHE = `
   )
 `;
 
+export const CREATE_AGENT_INTERACTIONS = `
+CREATE TABLE IF NOT EXISTS agent_interactions (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  org_name TEXT,
+  agent_type TEXT NOT NULL,
+  parent_agent TEXT,
+  prompt_summary TEXT,
+  result_summary TEXT,
+  tokens_in INTEGER NOT NULL DEFAULT 0,
+  tokens_out INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL NOT NULL DEFAULT 0,
+  success INTEGER NOT NULL DEFAULT 1,
+  duration_ms INTEGER NOT NULL DEFAULT 0,
+  timestamp INTEGER NOT NULL,
+  metadata TEXT
+)`;
+
+export const CREATE_AGENT_INTERACTIONS_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_session ON agent_interactions(session_id)`;
+
+export const CREATE_AGENT_INTERACTIONS_ORG_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_org ON agent_interactions(org_name)`;
+
+export const CREATE_AGENT_INTERACTIONS_TYPE_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_type ON agent_interactions(agent_type)`;
+
+export const CREATE_AGENT_INTERACTIONS_TS_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_ts ON agent_interactions(timestamp)`;
+
 export const FTS_SYNC_TRIGGERS = `
 CREATE TRIGGER IF NOT EXISTS nodes_fts_insert AFTER INSERT ON nodes BEGIN
   INSERT INTO nodes_fts(rowid, id, name, norm_label, file_path, label)

package/src/web/analyze-api.ts

@@ -52,11 +52,13 @@ async function handleAnalyze(req: IncomingMessage, res: ServerResponse): Promise
   }
 
   // Set SSE headers
+  const origin = req.headers['origin'] ?? '';
+  const allowedOrigin = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin) ? origin : '';
   res.writeHead(200, {
     'Content-Type': 'text/event-stream',
     'Cache-Control': 'no-cache',
     'Connection': 'keep-alive',
-    'Access-Control-Allow-Origin': 'http://localhost',
+    ...(allowedOrigin && { 'Access-Control-Allow-Origin': allowedOrigin }),
   });
 
   const dbPath = resolve(join(repoPath, '.monomind', 'monograph.db'));