tianshu-harness 3.23.0

package/dist/chunk-J6ESSM47.js

@@ -0,0 +1,1791 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  analyzeImpact,
+  inferTestedByTargets
+} from "./chunk-3C3R7JXY.js";
+import {
+  classifyPath
+} from "./chunk-7FW3I7WC.js";
+import {
+  toPosixPath
+} from "./chunk-GD4ZNZ7W.js";
+import {
+  resolveBetterSqlite3
+} from "./chunk-722LQO64.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/repo/meridian-indexer.ts
+init_esm_shims();
+import { readFileSync, existsSync as existsSync2, realpathSync } from "fs";
+import { resolve, dirname } from "path";
+import { createHash as createHash2 } from "crypto";
+
+// src/repo/meridian-db.ts
+init_esm_shims();
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS files (
+  path TEXT PRIMARY KEY,
+  content_hash TEXT NOT NULL,
+  indexed_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS symbols (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  line INTEGER NOT NULL,
+  exported INTEGER NOT NULL DEFAULT 0,
+  content_hash TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_path);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+
+CREATE TABLE IF NOT EXISTS edges (
+  source_id TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  weight REAL NOT NULL DEFAULT 1.0,
+  confidence TEXT NOT NULL DEFAULT 'extracted',
+  PRIMARY KEY(source_id, target_id, kind)
+);
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+
+CREATE TABLE IF NOT EXISTS access_log (
+  file_path TEXT NOT NULL,
+  accessed_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_access_file ON access_log(file_path);
+
+CREATE TABLE IF NOT EXISTS co_edits (
+  file_a TEXT NOT NULL,
+  file_b TEXT NOT NULL,
+  weight REAL NOT NULL DEFAULT 1.0,
+  last_turn INTEGER NOT NULL,
+  PRIMARY KEY(file_a, file_b)
+);
+CREATE INDEX IF NOT EXISTS idx_co_edits_a ON co_edits(file_a);
+CREATE INDEX IF NOT EXISTS idx_co_edits_b ON co_edits(file_b);
+
+CREATE TABLE IF NOT EXISTS physarum_edges (
+  file_a TEXT NOT NULL,
+  file_b TEXT NOT NULL,
+  weight REAL NOT NULL,
+  flow REAL NOT NULL DEFAULT 0,
+  consolidated INTEGER NOT NULL DEFAULT 0,
+  activation_count INTEGER NOT NULL DEFAULT 0,
+  last_activated_turn INTEGER NOT NULL DEFAULT 0,
+  direction REAL NOT NULL DEFAULT 0,
+  PRIMARY KEY(file_a, file_b)
+);
+
+CREATE TABLE IF NOT EXISTS physarum_prediction_observations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source_file TEXT NOT NULL,
+  predicted_at_turn INTEGER NOT NULL,
+  predictions_json TEXT NOT NULL,
+  observed_file TEXT NOT NULL,
+  observed_at_turn INTEGER NOT NULL,
+  hit_rank INTEGER,
+  lead_turns INTEGER NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_physarum_prediction_source ON physarum_prediction_observations(source_file);
+CREATE INDEX IF NOT EXISTS idx_physarum_prediction_observed ON physarum_prediction_observations(observed_file);
+
+CREATE TABLE IF NOT EXISTS immune_memory (
+  id TEXT PRIMARY KEY,
+  pattern TEXT NOT NULL,
+  response_json TEXT NOT NULL,
+  affinity_score REAL NOT NULL DEFAULT 0.5,
+  hit_count INTEGER NOT NULL DEFAULT 0,
+  last_hit INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_immune_pattern ON immune_memory(pattern);
+
+CREATE TABLE IF NOT EXISTS mistake_entries (
+  id TEXT PRIMARY KEY,
+  timestamp TEXT NOT NULL,
+  error TEXT NOT NULL,
+  context TEXT NOT NULL,
+  resolution TEXT NOT NULL,
+  tags_json TEXT NOT NULL DEFAULT '[]'
+);
+CREATE INDEX IF NOT EXISTS idx_mistake_error ON mistake_entries(error);
+
+CREATE TABLE IF NOT EXISTS p3_state (
+  kind TEXT NOT NULL,
+  version INTEGER NOT NULL,
+  json TEXT NOT NULL,
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY(kind, version)
+);
+
+CREATE TABLE IF NOT EXISTS sensorimotor_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  context_hash TEXT NOT NULL,
+  tool_name TEXT NOT NULL,
+  success INTEGER NOT NULL,
+  duration_ms INTEGER,
+  turn INTEGER NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_sm_context ON sensorimotor_log(context_hash, tool_name);
+CREATE INDEX IF NOT EXISTS idx_sm_tool ON sensorimotor_log(tool_name);
+
+CREATE TABLE IF NOT EXISTS module_summaries (
+  dir_path TEXT PRIMARY KEY,
+  summary TEXT NOT NULL,
+  key_exports_json TEXT NOT NULL DEFAULT '[]',
+  file_count INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'active',
+  content_hash TEXT NOT NULL DEFAULT '',
+  verified_at_commit TEXT,
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS cli_entries (
+  flag TEXT NOT NULL,
+  handler TEXT NOT NULL,
+  wired INTEGER NOT NULL DEFAULT 0,
+  verified_at_commit TEXT,
+  source_file TEXT NOT NULL,
+  PRIMARY KEY(flag, source_file)
+);
+
+CREATE TABLE IF NOT EXISTS meridian_meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_access_time ON access_log(accessed_at);
+CREATE INDEX IF NOT EXISTS idx_sm_created ON sensorimotor_log(created_at);
+CREATE INDEX IF NOT EXISTS idx_p3_updated ON p3_state(updated_at);
+`;
+var CLEANUP_MIN_INTERVAL_MS = 24 * 3600 * 1e3;
+var P3_EVENT_RETENTION_DAYS = 30;
+var LOG_RETENTION_DAYS = 90;
+function globEscape(filePath) {
+  return filePath.replace(/[*?[]/g, "[$&]");
+}
+var MeridianDb = class {
+  conn = null;
+  stateDir;
+  _available = true;
+  constructor(stateDir) {
+    this.stateDir = stateDir;
+  }
+  get db() {
+    if (!this.conn) {
+      if (!existsSync(this.stateDir)) mkdirSync(this.stateDir, { recursive: true });
+      try {
+        const Database = resolveBetterSqlite3(import.meta.url);
+        if (!Database) throw new Error("better-sqlite3 not installed");
+        const dbPath = join(this.stateDir, "meridian.db");
+        this.conn = new Database(dbPath);
+        this.conn.pragma("journal_mode = WAL");
+        this.conn.pragma("busy_timeout = 3000");
+        this.conn.exec(SCHEMA);
+        migrateToV1(this.conn);
+        this.conn.pragma("journal_size_limit = 67108864");
+        migrateToV2(this.conn);
+        this.cleanupExpiredRows();
+      } catch (err) {
+        if (err?.code === "ESQLITE_BUNDLE_BROKEN") throw err;
+        const reason = err instanceof Error ? err.message : String(err);
+        const hint = process.platform === "win32" ? 'Run: cd "$(npm root -g)\\tianshu-harness" && node scripts\\fetch-native-sqlite.js' : 'Run: cd "$(npm root -g)/tianshu-harness" && node scripts/fetch-native-sqlite.js';
+        console.warn(`\u26A0 better-sqlite3 not available. Code index (MeridianDb) disabled \u2014 repo symbol search & cross-file analysis will be unavailable. Reason: ${reason}
+  Fix: ${hint}`);
+        this._available = false;
+        this.conn = createNullDb();
+      }
+    }
+    return this.conn;
+  }
+  /**
+   * Whether the index is actually backed by sqlite.
+   *
+   * Callers must consult this BEFORE doing expensive work whose only consumer is
+   * the index (reading a file, hashing it, running tree-sitter). Feeding the
+   * no-op DB is not merely wasted storage: `needsParse` can never observe a
+   * previous write, so every caller re-does the same work forever.
+   *
+   * Touching `this.db` first is load-bearing — `_available` starts out `true`
+   * and only becomes accurate once the lazy connection has been attempted.
+   */
+  get available() {
+    void this.db;
+    return this._available;
+  }
+  needsParse(filePath, contentHash) {
+    if (!this.available) return false;
+    const row = this.db.prepare("SELECT content_hash FROM files WHERE path = ?").get(filePath);
+    return !row || row.content_hash !== contentHash;
+  }
+  upsertFile(result) {
+    if (!this.available) return;
+    const tx = this.db.transaction(() => {
+      this.db.prepare("INSERT OR REPLACE INTO files (path, content_hash) VALUES (?, ?)").run(result.filePath, result.contentHash);
+      this.db.prepare("DELETE FROM symbols WHERE file_path = ?").run(result.filePath);
+      const escapedPath = globEscape(result.filePath);
+      this.db.prepare("DELETE FROM edges WHERE source_id GLOB ?").run(`${escapedPath}:*`);
+      const insertSym = this.db.prepare("INSERT OR REPLACE INTO symbols (id, name, kind, file_path, line, exported, content_hash) VALUES (?, ?, ?, ?, ?, ?, ?)");
+      for (const s of result.symbols) {
+        insertSym.run(s.id, s.name, s.kind, s.filePath, s.line, s.exported ? 1 : 0, s.contentHash);
+      }
+      const insertEdge = this.db.prepare("INSERT OR REPLACE INTO edges (source_id, target_id, kind, weight, confidence) VALUES (?, ?, ?, ?, ?)");
+      for (const e of result.edges) {
+        insertEdge.run(e.sourceId, e.targetId, e.kind, e.weight, e.confidence ?? "extracted");
+      }
+      for (const imp of result.imports) {
+        const firstSymbol = result.symbols[0];
+        if (firstSymbol) {
+          insertEdge.run(firstSymbol.id, `${imp}:*:0`, "imports", 1, "extracted");
+        }
+      }
+    });
+    tx();
+  }
+  getSymbolsForFile(filePath) {
+    return this.db.prepare("SELECT * FROM symbols WHERE file_path = ?").all(filePath).map((row) => ({
+      id: row.id,
+      name: row.name,
+      kind: row.kind,
+      filePath: row.file_path,
+      line: row.line,
+      exported: row.exported === 1,
+      contentHash: row.content_hash
+    }));
+  }
+  /** Get every indexed symbol — cross-file callee-name matching reads this. */
+  getAllSymbols() {
+    return this.db.prepare("SELECT * FROM symbols").all().map((row) => ({
+      id: row.id,
+      name: row.name,
+      kind: row.kind,
+      filePath: row.file_path,
+      line: row.line,
+      exported: row.exported === 1,
+      contentHash: row.content_hash
+    }));
+  }
+  /**
+   * 按 name 集合一次拉取符号（buildCallEdges 批量路径，2026-09-08）。
+   * 参数化 `WHERE name IN (?,...)` 走 idx_symbols_name，替代 getAllSymbols
+   * 全表物化 + 内存过滤。名字去重后按 500 个分片（SQLite 变量上限留足余量），
+   * 分片结果按 symbol id 去重。空集合/无命中返回 []。
+   */
+  getSymbolsByNames(names) {
+    const unique = [...new Set(names)];
+    if (unique.length === 0) return [];
+    const CHUNK_SIZE = 500;
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (let i = 0; i < unique.length; i += CHUNK_SIZE) {
+      const chunk = unique.slice(i, i + CHUNK_SIZE);
+      const placeholders = chunk.map(() => "?").join(",");
+      const rows = this.db.prepare(`SELECT * FROM symbols WHERE name IN (${placeholders})`).all(...chunk);
+      for (const row of rows) {
+        const symbol = {
+          id: row.id,
+          name: row.name,
+          kind: row.kind,
+          filePath: row.file_path,
+          line: row.line,
+          exported: row.exported === 1,
+          contentHash: row.content_hash
+        };
+        if (seen.has(symbol.id)) continue;
+        seen.add(symbol.id);
+        out.push(symbol);
+      }
+    }
+    return out;
+  }
+  getEdgesFrom(symbolId) {
+    return this.db.prepare("SELECT * FROM edges WHERE source_id = ?").all(symbolId).map((row) => ({
+      sourceId: row.source_id,
+      targetId: row.target_id,
+      kind: row.kind,
+      weight: row.weight,
+      confidence: row.confidence ?? "extracted"
+    }));
+  }
+  getEdgesTo(symbolId) {
+    return this.db.prepare("SELECT * FROM edges WHERE target_id = ?").all(symbolId).map((row) => ({
+      sourceId: row.source_id,
+      targetId: row.target_id,
+      kind: row.kind,
+      weight: row.weight,
+      confidence: row.confidence ?? "extracted"
+    }));
+  }
+  recordAccess(filePath) {
+    if (!this.available) return;
+    this.db.prepare("INSERT INTO access_log (file_path) VALUES (?)").run(filePath);
+  }
+  getAccessCount(filePath) {
+    const row = this.db.prepare("SELECT COUNT(*) as cnt FROM access_log WHERE file_path = ?").get(filePath);
+    return row.cnt;
+  }
+  getNeighborIds(startId, maxHops) {
+    const visited = /* @__PURE__ */ new Set();
+    let frontier = /* @__PURE__ */ new Set([startId]);
+    for (let hop = 0; hop < maxHops; hop++) {
+      const next = /* @__PURE__ */ new Set();
+      for (const id of frontier) {
+        const rows = this.db.prepare(
+          "SELECT target_id as nid FROM edges WHERE source_id = ? UNION SELECT source_id as nid FROM edges WHERE target_id = ?"
+        ).all(id, id);
+        for (const r of rows) {
+          if (!visited.has(r.nid) && r.nid !== startId) {
+            visited.add(r.nid);
+            next.add(r.nid);
+          }
+        }
+      }
+      frontier = next;
+    }
+    return visited;
+  }
+  getStats() {
+    const files = this.db.prepare("SELECT COUNT(*) as cnt FROM files").get().cnt;
+    const symbols = this.db.prepare("SELECT COUNT(*) as cnt FROM symbols").get().cnt;
+    const edges = this.db.prepare("SELECT COUNT(*) as cnt FROM edges").get().cnt;
+    return { files, symbols, edges };
+  }
+  recordCoEdit(fileA, fileB, turn) {
+    const [a, b] = fileA < fileB ? [fileA, fileB] : [fileB, fileA];
+    this.db.prepare(`
+      INSERT INTO co_edits (file_a, file_b, weight, last_turn)
+      VALUES (?, ?, 1.0, ?)
+      ON CONFLICT(file_a, file_b) DO UPDATE SET
+        weight = MIN(weight + 0.5, 5.0),
+        last_turn = excluded.last_turn
+    `).run(a, b, turn);
+  }
+  getCoEditNeighbors(filePath) {
+    return this.db.prepare(`
+      SELECT file_b as file, weight FROM co_edits WHERE file_a = ?
+      UNION ALL
+      SELECT file_a as file, weight FROM co_edits WHERE file_b = ?
+    `).all(filePath, filePath);
+  }
+  getAccessHeat(filePath, decayHalfLifeN = 10) {
+    const rows = this.db.prepare(
+      "SELECT accessed_at FROM access_log WHERE file_path = ? ORDER BY rowid DESC LIMIT 20"
+    ).all(filePath);
+    let heat = 0;
+    for (let i = 0; i < rows.length; i++) {
+      heat += Math.pow(0.5, i / decayHalfLifeN);
+    }
+    return heat;
+  }
+  /** Get files that depend on the given file (reverse edges: who imports/calls into this file) */
+  getReverseDependents(filePath) {
+    return this.db.prepare(`
+      SELECT DISTINCT
+        substr(e.source_id, 1, instr(e.source_id, ':') - 1) as file,
+        e.kind,
+        e.weight
+      FROM edges e
+      WHERE e.target_id GLOB ?
+        AND substr(e.source_id, 1, instr(e.source_id, ':') - 1) != ?
+    `).all(`${globEscape(filePath)}:*`, filePath);
+  }
+  /** Get files this file depends on via imports edges (P2-2 出边 API，与入边对称）。
+   *  导入边写入格式 target_id = <path>:*:0（240 行），source_id = <path>:<symbol>；
+   *  source_id GLOB 前缀匹配该文件全部符号，排除 target 为自身的 self-import 边
+   *  （方向与入边相反：排除对象是 target_id 一侧），globEscape 沿
+   *  getReverseDependents 的既有约定（370 行）。悬边（target 未索引）保留。 */
+  getForwardDependencies(filePath) {
+    return this.db.prepare(`
+      SELECT DISTINCT
+        substr(e.target_id, 1, instr(e.target_id, ':') - 1) as file,
+        e.kind,
+        e.weight
+      FROM edges e
+      WHERE e.kind = 'imports'
+        AND e.source_id GLOB ?
+        AND substr(e.target_id, 1, instr(e.target_id, ':') - 1) != ?
+    `).all(`${globEscape(filePath)}:*`, filePath);
+  }
+  /** Get test files associated with a source file via tested_by edges */
+  getTestsFor(filePath) {
+    const rows = this.db.prepare(`
+      SELECT DISTINCT substr(e.source_id, 1, instr(e.source_id, ':') - 1) as file
+      FROM edges e
+      WHERE e.target_id GLOB ? AND e.kind = 'tested_by'
+    `).all(`${globEscape(filePath)}:*`);
+    return rows.map((r) => r.file);
+  }
+  /** Get all indexed file paths */
+  getAllFiles() {
+    return this.db.prepare("SELECT path FROM files").all().map((r) => r.path);
+  }
+  /**
+   * P1-2: cheap cold-start probe — whether the files table has any rows.
+   * LIMIT 1 探测，避免写工具热路径上每次全表扫（getAllFiles 5k 文件 ≈ 5k 行）。
+   */
+  hasFiles() {
+    const row = this.db.prepare("SELECT 1 AS one FROM files LIMIT 1").get();
+    return row !== void 0;
+  }
+  /** Insert or update a single edge */
+  upsertEdge(sourceId, targetId, kind, weight, confidence = "extracted") {
+    this.db.prepare(
+      "INSERT OR REPLACE INTO edges (source_id, target_id, kind, weight, confidence) VALUES (?, ?, ?, ?, ?)"
+    ).run(sourceId, targetId, kind, weight, confidence);
+  }
+  // ─── Codebase index (module summaries + CLI entries) ────────────────
+  upsertModuleSummary(entry) {
+    this.db.prepare(`INSERT OR REPLACE INTO module_summaries (dir_path, summary, key_exports_json, file_count, status, content_hash, verified_at_commit, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))`).run(
+      entry.dirPath,
+      entry.summary,
+      JSON.stringify(entry.keyExports),
+      entry.fileCount,
+      entry.status,
+      entry.contentHash,
+      entry.verifiedAtCommit ?? null
+    );
+  }
+  getModuleSummaries() {
+    const rows = this.db.prepare("SELECT * FROM module_summaries ORDER BY dir_path").all();
+    return rows.map((r) => ({
+      dirPath: r.dir_path,
+      summary: r.summary,
+      keyExports: JSON.parse(r.key_exports_json),
+      fileCount: r.file_count,
+      status: r.status,
+      contentHash: r.content_hash,
+      verifiedAtCommit: r.verified_at_commit ?? void 0
+    }));
+  }
+  upsertCliEntry(entry) {
+    this.db.prepare(`INSERT OR REPLACE INTO cli_entries (flag, handler, wired, verified_at_commit, source_file)
+      VALUES (?, ?, ?, ?, ?)`).run(
+      entry.flag,
+      entry.handler,
+      entry.wired ? 1 : 0,
+      entry.verifiedAtCommit ?? null,
+      entry.sourceFile
+    );
+  }
+  getCliEntries() {
+    const rows = this.db.prepare("SELECT * FROM cli_entries ORDER BY flag").all();
+    return rows.map((r) => ({
+      flag: r.flag,
+      handler: r.handler,
+      wired: r.wired === 1,
+      verifiedAtCommit: r.verified_at_commit ?? void 0,
+      sourceFile: r.source_file
+    }));
+  }
+  // ─── Physarum persistence ───────────────────────────────────────────
+  savePhysarumEdges(edges) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM physarum_edges").run();
+      const stmt = this.db.prepare(
+        "INSERT INTO physarum_edges (file_a, file_b, weight, flow, consolidated, activation_count, last_activated_turn, direction) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+      );
+      for (const e of edges) {
+        stmt.run(e.fileA, e.fileB, e.weight, e.flow, e.consolidated ? 1 : 0, e.activationCount, e.lastActivatedTurn, e.direction);
+      }
+    });
+    tx();
+  }
+  loadPhysarumEdges() {
+    const rows = this.db.prepare("SELECT * FROM physarum_edges").all();
+    return rows.map((r) => ({
+      fileA: r.file_a,
+      fileB: r.file_b,
+      weight: r.weight,
+      flow: r.flow,
+      consolidated: r.consolidated === 1,
+      activationCount: r.activation_count,
+      lastActivatedTurn: r.last_activated_turn,
+      direction: r.direction
+    }));
+  }
+  recordPhysarumPredictionObservation(observation) {
+    if (!this._available) return;
+    try {
+      this.db.prepare(`
+        INSERT INTO physarum_prediction_observations
+          (source_file, predicted_at_turn, predictions_json, observed_file, observed_at_turn, hit_rank, lead_turns)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        observation.sourceFile,
+        observation.predictedAtTurn,
+        JSON.stringify(observation.predictions),
+        observation.observedFile,
+        observation.observedAtTurn,
+        observation.hitRank,
+        observation.leadTurns
+      );
+    } catch {
+    }
+  }
+  getPhysarumPredictionObservations(limit = 100) {
+    if (!this._available) return [];
+    try {
+      const safeLimit = Math.max(1, Math.min(1e3, Math.floor(limit)));
+      const rows = this.db.prepare(`
+        SELECT * FROM physarum_prediction_observations
+        ORDER BY id DESC
+        LIMIT ${safeLimit}
+      `).all();
+      return rows.map((r) => ({
+        sourceFile: r.source_file,
+        predictedAtTurn: r.predicted_at_turn,
+        predictions: JSON.parse(r.predictions_json),
+        observedFile: r.observed_file,
+        observedAtTurn: r.observed_at_turn,
+        hitRank: r.hit_rank ?? null,
+        leadTurns: r.lead_turns
+      }));
+    } catch {
+      return [];
+    }
+  }
+  // ─── Immune memory persistence ───────────────────────────────────────
+  saveImmuneMemories(memories) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM immune_memory").run();
+      const stmt = this.db.prepare(
+        "INSERT INTO immune_memory (id, pattern, response_json, affinity_score, hit_count, last_hit, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+      );
+      for (const m of memories) {
+        stmt.run(
+          m.id,
+          m.pattern,
+          JSON.stringify(m.response),
+          m.affinityScore,
+          m.hitCount,
+          m.lastHit,
+          m.createdAt
+        );
+      }
+    });
+    tx();
+  }
+  loadImmuneMemories() {
+    const rows = this.db.prepare("SELECT * FROM immune_memory").all();
+    const result = [];
+    for (const r of rows) {
+      try {
+        const response = JSON.parse(r.response_json);
+        result.push({
+          id: r.id,
+          pattern: r.pattern,
+          response,
+          affinityScore: r.affinity_score,
+          hitCount: r.hit_count,
+          lastHit: r.last_hit,
+          createdAt: r.created_at
+        });
+      } catch {
+      }
+    }
+    return result;
+  }
+  // ─── Mistake notebook persistence ────────────────────────────────────
+  saveMistakeEntries(entries) {
+    const insert = this.db.prepare(
+      "INSERT INTO mistake_entries (id, timestamp, error, context, resolution, tags_json) VALUES (?, ?, ?, ?, ?, ?)"
+    );
+    const tx = this.db.transaction((items) => {
+      this.db.prepare("DELETE FROM mistake_entries").run();
+      for (const e of items) {
+        insert.run(e.id, e.timestamp, e.error, e.context, e.resolution, JSON.stringify(e.tags));
+      }
+    });
+    tx(entries);
+  }
+  /** Memory-epoch reset: drop all persisted mistake entries (see memory-epoch.ts). */
+  clearMistakeEntries() {
+    this.db.prepare("DELETE FROM mistake_entries").run();
+  }
+  loadMistakeEntries() {
+    const rows = this.db.prepare("SELECT * FROM mistake_entries").all();
+    const result = [];
+    for (const r of rows) {
+      try {
+        result.push({
+          id: r.id,
+          timestamp: r.timestamp,
+          error: r.error,
+          context: r.context,
+          resolution: r.resolution,
+          tags: JSON.parse(r.tags_json)
+        });
+      } catch {
+      }
+    }
+    return result;
+  }
+  // ─── P3 state persistence ───────────────────────────────────────────
+  saveToolPatternMinerSnapshot(snapshot) {
+    if (!this._available) return;
+    this.db.prepare(`
+      INSERT INTO p3_state (kind, version, json, updated_at)
+      VALUES ('tool_pattern_miner', ?, ?, datetime('now'))
+      ON CONFLICT(kind, version) DO UPDATE SET
+        json = excluded.json,
+        updated_at = excluded.updated_at
+    `).run(snapshot.version, JSON.stringify(snapshot));
+  }
+  loadToolPatternMinerSnapshot() {
+    if (!this._available) return null;
+    const row = this.db.prepare(`
+      SELECT json FROM p3_state
+      WHERE kind = 'tool_pattern_miner' AND version = 1
+    `).get();
+    if (!row) return null;
+    const parsed = JSON.parse(row.json);
+    return parsed.version === 1 ? parsed : null;
+  }
+  // ─── T2-02: Bandit state persistence ──────────────────────────────────
+  /**
+   * Periodic retention cleanup (anti-regression): runs at most once per 24h,
+   * tracked in meridian_meta. Idempotent; failures degrade silently — telemetry
+   * cleanup never blocks any path.
+   */
+  cleanupExpiredRows() {
+    if (!this._available) return;
+    try {
+      const row = this.db.prepare(`SELECT value FROM meridian_meta WHERE key = 'last_cleanup_at'`).get();
+      const last = row ? Number(row.value) : 0;
+      if (Number.isFinite(last) && Date.now() - last < CLEANUP_MIN_INTERVAL_MS) return;
+      purgeExpiredRows(this.db);
+      this.db.prepare(`INSERT OR REPLACE INTO meridian_meta (key, value) VALUES ('last_cleanup_at', ?)`).run(String(Date.now()));
+    } catch {
+    }
+  }
+  saveBanditState(kind, json) {
+    if (!this._available) return;
+    try {
+      this.db.prepare(`
+        INSERT INTO p3_state (kind, version, json, updated_at)
+        VALUES (?, 1, ?, datetime('now'))
+        ON CONFLICT(kind, version) DO UPDATE SET
+          json = excluded.json,
+          updated_at = excluded.updated_at
+      `).run(kind, json);
+    } catch {
+    }
+  }
+  loadBanditState(kind) {
+    if (!this._available) return null;
+    try {
+      const row = this.db.prepare(`
+        SELECT json FROM p3_state
+        WHERE kind = ? AND version = 1
+      `).get(kind);
+      return row?.json ?? null;
+    } catch {
+      return null;
+    }
+  }
+  loadBanditStatesByPrefix(prefix, limit = 100) {
+    if (!this._available) return [];
+    try {
+      const safeLimit = Math.max(1, Math.min(1e3, Math.floor(limit)));
+      return this.db.prepare(`
+        SELECT kind, json, updated_at as updatedAt FROM p3_state
+        WHERE kind LIKE ?
+        ORDER BY updated_at DESC
+        LIMIT ${safeLimit}
+      `).all(`${prefix}%`);
+    } catch {
+      return [];
+    }
+  }
+  // ─── Sensorimotor ─────────────────────────────────────────────────────
+  /**
+   * Record a sensorimotor experience: (context, tool, outcome).
+   * Gracefully degrades when DB is unavailable.
+   */
+  recordSensorimotorExperience(contextHash, toolName, success, durationMs, turn) {
+    if (!this._available) return;
+    try {
+      this.db.prepare(
+        `INSERT INTO sensorimotor_log (context_hash, tool_name, success, duration_ms, turn)
+         VALUES (?, ?, ?, ?, ?)`
+      ).run(contextHash, toolName, success ? 1 : 0, durationMs, turn);
+    } catch {
+    }
+  }
+  /**
+   * Get the success rate of a tool from recent sensorimotor history.
+   * Returns null if no data exists.
+   */
+  getToolSuccessRate(toolName, recentWindow) {
+    if (!this._available) return null;
+    try {
+      const limit = recentWindow && recentWindow > 0 ? `LIMIT ${recentWindow}` : "";
+      const rows = this.db.prepare(
+        `SELECT success FROM sensorimotor_log
+         WHERE tool_name = ?
+         ORDER BY id DESC
+         ${limit}`
+      ).all(toolName);
+      if (rows.length === 0) return null;
+      const successes = rows.filter((r) => r.success === 1).length;
+      return successes / rows.length;
+    } catch {
+      return null;
+    }
+  }
+  /** Current Meridian schema version (PRAGMA user_version), 0 when unavailable. */
+  schemaVersion() {
+    if (!this._available) return 0;
+    try {
+      return this.db.pragma("user_version", { simple: true }) ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  close() {
+    if (this.conn) {
+      try {
+        this.conn.pragma("wal_checkpoint(TRUNCATE)");
+      } catch {
+      }
+      this.conn.close();
+      this.conn = null;
+    }
+  }
+};
+function createNullDb() {
+  const noopStmt = { run: () => ({ changes: 0, lastInsertRowid: 0 }), all: () => [], get: () => void 0 };
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get: (_target, prop) => {
+      if (prop === "prepare") return () => noopStmt;
+      if (prop === "exec") return () => {
+      };
+      if (prop === "pragma") return () => {
+      };
+      if (prop === "close") return () => {
+      };
+      if (prop === "transaction") return (fn) => fn;
+      return () => {
+      };
+    }
+  });
+}
+function migrateToV1(db) {
+  try {
+    if ((db.pragma("user_version", { simple: true }) ?? 0) >= 1) return;
+    const tx = db.transaction(() => {
+      db.prepare("DELETE FROM files WHERE substr(path, 1, 1) = '/' OR (substr(path, 2, 1) = ':' AND path GLOB '[A-Za-z]:*')").run();
+      db.prepare("DELETE FROM symbols WHERE substr(file_path, 1, 1) = '/' OR (substr(file_path, 2, 1) = ':' AND file_path GLOB '[A-Za-z]:*')").run();
+      db.prepare("DELETE FROM edges WHERE kind = 'imports' AND NOT EXISTS (SELECT 1 FROM files f WHERE edges.target_id = f.path || ':*:0')").run();
+      db.pragma("user_version = 1");
+    });
+    tx();
+  } catch {
+  }
+}
+function migrateToV2(db) {
+  try {
+    if ((db.pragma("user_version", { simple: true }) ?? 0) >= 2) return;
+    const tx = db.transaction(() => {
+      purgeExpiredRows(db);
+      db.pragma("user_version = 2");
+    });
+    tx();
+    try {
+      db.pragma("wal_checkpoint(TRUNCATE)");
+      db.exec("VACUUM");
+    } catch {
+    }
+  } catch {
+  }
+}
+function purgeExpiredRows(db) {
+  db.prepare(`DELETE FROM p3_state
+    WHERE updated_at < datetime('now', ?)
+      AND kind NOT LIKE 'bandit:%' AND kind NOT LIKE 'p3:%'
+      AND kind NOT LIKE 'team\\_plan\\_cache:%' ESCAPE '\\'
+      AND kind <> 'tool_pattern_miner'`).run(`-${P3_EVENT_RETENTION_DAYS} days`);
+  db.prepare(`DELETE FROM access_log WHERE accessed_at < datetime('now', ?)`).run(`-${LOG_RETENTION_DAYS} days`);
+  db.prepare(`DELETE FROM sensorimotor_log WHERE created_at < datetime('now', ?)`).run(`-${LOG_RETENTION_DAYS} days`);
+}
+
+// src/repo/meridian-behavior.ts
+init_esm_shims();
+var CO_EDIT_BLACKLIST = [
+  "package.json",
+  "package-lock.json",
+  "tsconfig.json",
+  ".eslintrc",
+  ".prettierrc",
+  "yarn.lock",
+  "pnpm-lock.yaml"
+];
+function isBlacklisted(filePath) {
+  return CO_EDIT_BLACKLIST.some((p) => filePath.endsWith(p));
+}
+var DEFAULT_WEIGHTS = {
+  structural: 1,
+  coEdit: 0.6,
+  accessHeat: 0.3,
+  pheromone: 0.2
+};
+var MeridianBehavior = class {
+  constructor(db, stigmergy, weights = DEFAULT_WEIGHTS) {
+    this.db = db;
+    this.stigmergy = stigmergy;
+    this.weights = weights;
+  }
+  db;
+  stigmergy;
+  weights;
+  editBuffer = /* @__PURE__ */ new Set();
+  currentTurn = 0;
+  /** Pre-loaded pheromone cache for sync access during graph queries */
+  pheromoneCache = /* @__PURE__ */ new Map();
+  /** Load pheromone signals into cache (call before sync graph queries) */
+  async refreshPheromoneCache() {
+    if (!this.stigmergy) return;
+    const all = await this.stigmergy.query();
+    this.pheromoneCache.clear();
+    for (const p of all) {
+      const existing = this.pheromoneCache.get(p.path) ?? 0;
+      this.pheromoneCache.set(p.path, existing + p.currentStrength);
+    }
+  }
+  recordEdit(filePath, turn) {
+    if (isBlacklisted(filePath)) return;
+    if (turn !== this.currentTurn) {
+      this.flushCoEdits();
+      this.currentTurn = turn;
+      this.editBuffer.clear();
+    }
+    this.editBuffer.add(filePath);
+  }
+  flushCoEdits() {
+    const files = [...this.editBuffer];
+    for (let i = 0; i < files.length; i++) {
+      for (let j = i + 1; j < files.length; j++) {
+        this.db.recordCoEdit(files[i], files[j], this.currentTurn);
+      }
+    }
+    this.editBuffer.clear();
+  }
+  getFileBoost(filePath) {
+    let boost = 0;
+    const coNeighbors = this.db.getCoEditNeighbors(filePath);
+    const coEditScore = coNeighbors.reduce((sum, n) => sum + n.weight, 0);
+    boost += Math.min(coEditScore, 5) * this.weights.coEdit;
+    const heat = this.db.getAccessHeat(filePath);
+    boost += Math.min(heat, 3) * this.weights.accessHeat;
+    const pheromoneScore = this.pheromoneCache.get(filePath) ?? 0;
+    boost += Math.min(pheromoneScore, 2) * this.weights.pheromone;
+    return boost;
+  }
+  getCoEditEdges(seedFile) {
+    if (isBlacklisted(seedFile)) return [];
+    return this.db.getCoEditNeighbors(seedFile).filter((n) => !isBlacklisted(n.file)).map((n) => ({ targetFile: n.file, weight: n.weight * this.weights.coEdit }));
+  }
+};
+
+// src/repo/meridian-parser.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import { createRequire } from "module";
+var parserModule = null;
+var parsers = /* @__PURE__ */ new Map();
+var parseCount = 0;
+var MAX_PARSES_BEFORE_RESET = 250;
+var LANG_WASM = {
+  typescript: "tree-sitter-typescript.wasm",
+  python: "tree-sitter-python.wasm",
+  go: "tree-sitter-go.wasm"
+};
+var EXT_TO_LANG = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "typescript",
+  ".jsx": "typescript",
+  ".py": "python",
+  ".go": "go"
+};
+function detectLang(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXT_TO_LANG[ext] ?? null;
+}
+async function initParser() {
+  const TreeSitter = (await import("web-tree-sitter")).default;
+  await TreeSitter.init();
+  parserModule = TreeSitter;
+  parsers.clear();
+  parseCount = 0;
+}
+async function getParser(lang) {
+  if (!parserModule || parseCount >= MAX_PARSES_BEFORE_RESET) {
+    await initParser();
+  }
+  if (!parsers.has(lang)) {
+    const p = new parserModule();
+    const require2 = createRequire(import.meta.url);
+    const wasmPath = require2.resolve(`tree-sitter-wasms/out/${LANG_WASM[lang]}`);
+    const language = await parserModule.Language.load(wasmPath);
+    p.setLanguage(language);
+    parsers.set(lang, p);
+  }
+  return parsers.get(lang);
+}
+function makeId(filePath, name, line) {
+  return `${filePath}:${name}:${line}`;
+}
+async function parseFile(filePath, source) {
+  const lang = detectLang(filePath);
+  if (!lang) throw new Error(`Unsupported language for: ${filePath}`);
+  switch (lang) {
+    case "typescript":
+      return parseTypeScriptFile(filePath, source);
+    case "python":
+      return parsePythonFile(filePath, source);
+    case "go":
+      return parseGoFile(filePath, source);
+  }
+}
+async function parseTypeScriptFile(filePath, source) {
+  const p = await getParser("typescript");
+  const tree = p.parse(source);
+  parseCount++;
+  const symbols = [];
+  const edges = [];
+  const imports = [];
+  const calls = [];
+  const contentHash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  function walkSymbols(node, parentId) {
+    const row = node.startPosition.row + 1;
+    const isExported = node.parent?.type === "export_statement";
+    if (node.type === "import_statement") {
+      const sourceNode = node.childForFieldName("source");
+      if (sourceNode) {
+        const raw = sourceNode.text.replace(/['"]/g, "");
+        if (raw.startsWith(".")) imports.push(raw);
+      }
+      return;
+    }
+    const info = tsSymbolInfo(node);
+    if (info) {
+      const id = makeId(filePath, info.name, row);
+      symbols.push({ id, name: info.name, kind: info.kind, filePath, line: row, exported: isExported, contentHash });
+      if (parentId) {
+        edges.push({ sourceId: parentId, targetId: id, kind: "contains", weight: 1, confidence: "extracted" });
+      }
+      for (const child of node.namedChildren) {
+        walkSymbols(child, id);
+      }
+      return;
+    }
+    for (const child of node.namedChildren) {
+      walkSymbols(child, parentId);
+    }
+  }
+  walkSymbols(tree.rootNode);
+  const localByName = /* @__PURE__ */ new Map();
+  for (const s of symbols) {
+    const arr = localByName.get(s.name) ?? [];
+    arr.push(s);
+    localByName.set(s.name, arr);
+  }
+  function walkCalls(node, ownerId) {
+    const info = tsSymbolInfo(node);
+    if (info) ownerId = makeId(filePath, info.name, node.startPosition.row + 1);
+    if (node.type === "call_expression" && ownerId) {
+      const name = calleeName(node);
+      if (name) {
+        const locals = localByName.get(name);
+        if (locals && locals.length > 0) {
+          for (const l of locals) {
+            edges.push({ sourceId: ownerId, targetId: l.id, kind: "calls", weight: 1, confidence: "extracted" });
+          }
+        } else {
+          calls.push({ sourceId: ownerId, name, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+    for (const child of node.namedChildren) {
+      walkCalls(child, ownerId);
+    }
+  }
+  walkCalls(tree.rootNode);
+  tree.delete();
+  return { filePath, contentHash, symbols, edges, imports, calls };
+}
+function tsSymbolInfo(node) {
+  let kind = null;
+  let name = null;
+  switch (node.type) {
+    case "function_declaration":
+      kind = "function";
+      name = node.childForFieldName("name")?.text ?? null;
+      break;
+    case "class_declaration":
+      kind = "class";
+      name = node.childForFieldName("name")?.text ?? null;
+      break;
+    case "interface_declaration":
+      kind = "interface";
+      name = node.childForFieldName("name")?.text ?? null;
+      break;
+    case "type_alias_declaration":
+      kind = "type";
+      name = node.childForFieldName("name")?.text ?? null;
+      break;
+    case "enum_declaration":
+      kind = "enum";
+      name = node.childForFieldName("name")?.text ?? null;
+      break;
+    case "method_definition":
+      kind = "method";
+      name = node.childForFieldName("name")?.text ?? null;
+      break;
+    case "lexical_declaration":
+    case "variable_declaration": {
+      const declarator = node.namedChildren.find((c) => c.type === "variable_declarator");
+      if (declarator) {
+        const init = declarator.childForFieldName("value");
+        if (init && (init.type === "arrow_function" || init.type === "function")) {
+          kind = "function";
+        } else {
+          kind = "variable";
+        }
+        name = declarator.childForFieldName("name")?.text ?? null;
+      }
+      break;
+    }
+  }
+  if (kind && name) return { kind, name };
+  return null;
+}
+function calleeName(node) {
+  const fn = node.childForFieldName("function");
+  if (!fn) return null;
+  if (fn.type === "identifier") return fn.text;
+  if (fn.type === "member_expression") {
+    const prop = fn.childForFieldName("property");
+    if (prop && prop.type === "property_identifier") return prop.text;
+  }
+  return null;
+}
+async function parsePythonFile(filePath, source) {
+  const p = await getParser("python");
+  const tree = p.parse(source);
+  parseCount++;
+  const symbols = [];
+  const edges = [];
+  const imports = [];
+  const contentHash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  function walk(node, parentId) {
+    const row = node.startPosition.row + 1;
+    let kind = null;
+    let name = null;
+    switch (node.type) {
+      case "function_definition":
+        kind = "function";
+        name = node.childForFieldName("name")?.text ?? null;
+        break;
+      case "class_definition":
+        kind = "class";
+        name = node.childForFieldName("name")?.text ?? null;
+        break;
+      case "import_statement": {
+        const modNode = node.namedChildren.find((c) => c.type === "dotted_name");
+        if (modNode) imports.push(modNode.text);
+        return;
+      }
+      case "import_from_statement": {
+        const modName = node.childForFieldName("module_name");
+        if (modName) {
+          const raw = modName.text;
+          if (raw.startsWith(".")) imports.push(raw);
+          else imports.push(raw);
+        }
+        return;
+      }
+    }
+    if (kind && name) {
+      const id = makeId(filePath, name, row);
+      const isExported = node.parent?.type === "module";
+      symbols.push({ id, name, kind, filePath, line: row, exported: isExported ?? false, contentHash });
+      if (parentId) {
+        edges.push({ sourceId: parentId, targetId: id, kind: "contains", weight: 1, confidence: "extracted" });
+      }
+      for (const child of node.namedChildren) {
+        walk(child, id);
+      }
+      return;
+    }
+    for (const child of node.namedChildren) {
+      walk(child, parentId);
+    }
+  }
+  walk(tree.rootNode);
+  tree.delete();
+  return { filePath, contentHash, symbols, edges, imports, calls: [] };
+}
+async function parseGoFile(filePath, source) {
+  const p = await getParser("go");
+  const tree = p.parse(source);
+  parseCount++;
+  const symbols = [];
+  const edges = [];
+  const imports = [];
+  const contentHash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  function walk(node) {
+    const row = node.startPosition.row + 1;
+    let kind = null;
+    let name = null;
+    switch (node.type) {
+      case "function_declaration":
+        kind = "function";
+        name = node.childForFieldName("name")?.text ?? null;
+        break;
+      case "method_declaration":
+        kind = "method";
+        name = node.childForFieldName("name")?.text ?? null;
+        break;
+      case "type_declaration": {
+        const spec = node.namedChildren.find((c) => c.type === "type_spec");
+        if (spec) {
+          name = spec.childForFieldName("name")?.text ?? null;
+          const typeNode = spec.childForFieldName("type");
+          kind = typeNode?.type === "interface_type" ? "interface" : "type";
+        }
+        break;
+      }
+      case "import_declaration": {
+        for (const child of node.namedChildren) {
+          if (child.type === "import_spec" || child.type === "interpreted_string_literal") {
+            const raw = child.text.replace(/['"]/g, "");
+            if (raw && !raw.startsWith("//")) imports.push(raw);
+          }
+          if (child.type === "import_spec_list") {
+            for (const spec of child.namedChildren) {
+              const pathNode = spec.childForFieldName("path") ?? spec.namedChildren.find((c) => c.type === "interpreted_string_literal");
+              if (pathNode) imports.push(pathNode.text.replace(/['"]/g, ""));
+            }
+          }
+        }
+        return;
+      }
+    }
+    if (kind && name) {
+      const id = makeId(filePath, name, row);
+      const isExported = /^[A-Z]/.test(name);
+      symbols.push({ id, name, kind, filePath, line: row, exported: isExported, contentHash });
+    }
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(tree.rootNode);
+  tree.delete();
+  return { filePath, contentHash, symbols, edges, imports, calls: [] };
+}
+
+// src/repo/meridian-graph.ts
+init_esm_shims();
+
+// src/repo/meridian-types.ts
+init_esm_shims();
+var CONFIDENCE_MULTIPLIER = {
+  extracted: 1,
+  inferred: 0.7,
+  ambiguous: 0.4
+};
+
+// src/repo/meridian-graph.ts
+function spreadingActivation(db, seedFile, opts) {
+  const scores = /* @__PURE__ */ new Map();
+  scores.set(seedFile, 1);
+  const seedSymbols = db.getSymbolsForFile(seedFile);
+  let frontier = seedSymbols.map((s) => s.id);
+  for (let hop = 0; hop < opts.maxHops; hop++) {
+    const decayFactor = Math.pow(opts.decay, hop + 1);
+    const nextFrontier = [];
+    for (const symbolId of frontier) {
+      const edges = db.getEdgesFrom(symbolId);
+      for (const edge of edges) {
+        const targetFile = edge.targetId.split(":")[0];
+        if (targetFile && !targetFile.includes("*")) {
+          const confMult = CONFIDENCE_MULTIPLIER[edge.confidence ?? "extracted"];
+          const addition = decayFactor * edge.weight * confMult;
+          const existing = scores.get(targetFile) ?? 0;
+          scores.set(targetFile, Math.max(existing, addition));
+          nextFrontier.push(edge.targetId);
+        }
+      }
+      const reverseEdges = db.getEdgesTo(symbolId);
+      for (const edge of reverseEdges) {
+        const sourceFile = edge.sourceId.split(":")[0];
+        if (sourceFile && !sourceFile.includes("*")) {
+          const confMult = CONFIDENCE_MULTIPLIER[edge.confidence ?? "extracted"];
+          const addition = decayFactor * edge.weight * 0.7 * confMult;
+          const existing = scores.get(sourceFile) ?? 0;
+          scores.set(sourceFile, Math.max(existing, addition));
+          nextFrontier.push(edge.sourceId);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  if (opts.behavior) {
+    const coEdges = opts.behavior.getCoEditEdges(seedFile);
+    for (const { targetFile, weight } of coEdges) {
+      const existing = scores.get(targetFile) ?? 0;
+      scores.set(targetFile, Math.max(existing, weight));
+    }
+  }
+  return scores;
+}
+var TOKENS_PER_SYMBOL_LINE = 25;
+function buildRepoMap(db, seedFile, opts) {
+  const scores = spreadingActivation(db, seedFile, opts);
+  const stats = db.getStats();
+  const entries = [];
+  for (const [filePath, score] of scores) {
+    const symbols = db.getSymbolsForFile(filePath);
+    const boost = opts.behavior ? opts.behavior.getFileBoost(filePath) : 0;
+    entries.push({
+      filePath,
+      symbols: symbols.map((s) => ({ name: s.name, kind: s.kind, line: s.line })),
+      score: score + boost
+    });
+  }
+  entries.sort((a, b) => b.score - a.score);
+  let tokenCount = 0;
+  let cutoff = entries.length;
+  for (let i = 0; i < entries.length; i++) {
+    const entryTokens = entries[i].symbols.length * TOKENS_PER_SYMBOL_LINE + 10;
+    if (tokenCount + entryTokens > opts.maxTokens) {
+      cutoff = i;
+      break;
+    }
+    tokenCount += entryTokens;
+  }
+  return {
+    entries: entries.slice(0, Math.max(cutoff, 1)),
+    // always include at least seed
+    totalSymbols: stats.symbols,
+    graphSize: stats.files
+  };
+}
+
+// src/repo/meridian-framework.ts
+init_esm_shims();
+function stripComments(source) {
+  let out = "";
+  let i = 0;
+  let inStr = null;
+  while (i < source.length) {
+    const ch = source[i];
+    if (inStr) {
+      out += ch;
+      if (ch === "\\" && i + 1 < source.length) {
+        out += source[i + 1];
+        i += 2;
+        continue;
+      }
+      if (ch === inStr) inStr = null;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inStr = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      while (i < source.length && source[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      i += 2;
+      while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) {
+        if (source[i] === "\n") out += "\n";
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+var ROUTE_HEAD_RE = /\b(app|router)\.(get|post|put|patch|delete|all|use)\s*\(\s*['"]([^'"]+)['"]\s*,/g;
+function tailIdent(expr) {
+  const cleaned = expr.replace(/\s+/g, "").replace(/\(\)$/, "");
+  const m = cleaned.match(/(?:\.|^)([A-Za-z_][A-Za-z0-9_]*)$/);
+  return m ? m[1] : null;
+}
+function extractExpressRoutes(filePath, source, knownSymbols) {
+  const symbols = [];
+  const edges = [];
+  const safe = stripComments(source);
+  const knownByName = /* @__PURE__ */ new Map();
+  for (const s of knownSymbols) {
+    const arr = knownByName.get(s.name) ?? [];
+    arr.push(s);
+    knownByName.set(s.name, arr);
+  }
+  let m;
+  while ((m = ROUTE_HEAD_RE.exec(safe)) !== null) {
+    const method = m[2].toUpperCase();
+    const routePath = m[3];
+    if (method === "USE" && !routePath.startsWith("/")) continue;
+    const line = safe.slice(0, m.index).split("\n").length;
+    const name = `${method} ${routePath}`;
+    const routeId = `${filePath}:${name}:${line}`;
+    symbols.push({ id: routeId, name, kind: "route", filePath, line, exported: false, contentHash: "" });
+    const openParen = safe.indexOf("(", m.index);
+    const closeParen = openParen >= 0 ? matchDelim(safe, openParen, "(", ")") : -1;
+    const args = closeParen > openParen ? safe.slice(openParen + 1, closeParen) : "";
+    if (args.includes("=>")) continue;
+    const parts = args.split(",").map((s) => s.trim()).filter(Boolean);
+    const last = parts[parts.length - 1];
+    const handlerName = last ? tailIdent(last) : null;
+    if (!handlerName) continue;
+    const matches = knownByName.get(handlerName);
+    if (matches && matches.length === 1) {
+      edges.push({
+        sourceId: routeId,
+        targetId: matches[0].id,
+        kind: "route_handles",
+        weight: 1,
+        confidence: "inferred"
+      });
+    }
+  }
+  return { symbols, edges };
+}
+var JSX_TAG_RE = /<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
+function extractJsxChildren(filePath, source, fileSymbols, knownSymbols) {
+  const edges = [];
+  const safe = stripComments(source);
+  const knownByName = /* @__PURE__ */ new Map();
+  for (const s of knownSymbols) {
+    const arr = knownByName.get(s.name) ?? [];
+    arr.push(s);
+    knownByName.set(s.name, arr);
+  }
+  const enclosing = [...fileSymbols].sort((a, b) => a.line - b.line);
+  let m;
+  while ((m = JSX_TAG_RE.exec(safe)) !== null) {
+    const tag = m[1];
+    const line = safe.slice(0, m.index).split("\n").length;
+    const matches = knownByName.get(tag);
+    if (!matches || matches.length !== 1) continue;
+    const target = matches[0];
+    let parent = null;
+    for (const s of enclosing) {
+      if (s.line <= line) parent = s;
+      else break;
+    }
+    if (!parent) continue;
+    edges.push({
+      sourceId: parent.id,
+      targetId: target.id,
+      kind: "jsx_children",
+      weight: 1,
+      confidence: "inferred"
+    });
+  }
+  return { symbols: [], edges };
+}
+function matchDelim(s, open, oc, cc) {
+  let depth = 0;
+  for (let i = open; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      i++;
+      while (i < s.length && s[i] !== ch) {
+        if (s[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === oc) depth++;
+    else if (ch === cc) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+// src/repo/meridian-indexer.ts
+var TS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+var ALL_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go"];
+var IGNORE_PATTERNS = ["node_modules", "dist", ".git", ".rivet"];
+function isMeridianIndexablePath(rel) {
+  if (IGNORE_PATTERNS.some((p) => rel.includes(p))) return false;
+  if (classifyPath(rel).silent) return false;
+  return ALL_EXTENSIONS.some((ext) => rel.endsWith(ext));
+}
+function isUnnamedSymbolId(id) {
+  return id.endsWith(":*:0");
+}
+function queryFlow(db, seedId, opts) {
+  const maxHops = opts?.maxHops ?? 4;
+  const maxBridges = opts?.maxBridges ?? 1;
+  if (isUnnamedSymbolId(seedId)) return [];
+  const seedFile = seedId.split(":")[0];
+  const seed = db.getSymbolsForFile(seedFile).find((s) => s.id === seedId);
+  if (!seed) return [];
+  const hits = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  let frontier = [{ id: seedId, bridges: 0, hops: 0 }];
+  visited.add(`${seedId}:0`);
+  for (let hop = 0; hop < maxHops && frontier.length > 0; hop++) {
+    const next = [];
+    for (const cur of frontier) {
+      const neighbors = [
+        ...db.getEdgesFrom(cur.id).map((e) => e.targetId),
+        ...db.getEdgesTo(cur.id).map((e) => e.sourceId)
+      ];
+      for (const nid of neighbors) {
+        const unnamed = isUnnamedSymbolId(nid);
+        const bridges = cur.bridges + (unnamed ? 1 : 0);
+        if (bridges > maxBridges) continue;
+        const key = `${nid}:${bridges}`;
+        if (visited.has(key)) continue;
+        visited.add(key);
+        if (unnamed) {
+          next.push({ id: nid, bridges, hops: cur.hops + 1 });
+        } else {
+          const file = nid.split(":")[0];
+          const sym = db.getSymbolsForFile(file).find((s) => s.id === nid);
+          if (sym) {
+            const existing = hits.get(nid);
+            if (!existing || bridges < existing.bridges) {
+              hits.set(nid, { symbolId: nid, name: sym.name, kind: sym.kind, filePath: sym.filePath, line: sym.line, hops: cur.hops + 1, bridges });
+            }
+            next.push({ id: nid, bridges, hops: cur.hops + 1 });
+          }
+        }
+      }
+    }
+    frontier = next;
+  }
+  return [...hits.values()].sort((a, b) => a.hops - b.hops || a.symbolId.localeCompare(b.symbolId));
+}
+function reviveDeletedFile(db, rel) {
+  const symbols = db.getSymbolsForFile(rel);
+  let revived = 0;
+  for (const sym of symbols) {
+    for (const edge of db.getEdgesTo(sym.id)) {
+      const sourceFile = edge.sourceId.split(":")[0];
+      if (sourceFile && sourceFile !== rel) {
+        db.upsertEdge(edge.sourceId, `${rel}:*:0`, edge.kind, edge.weight, edge.confidence ?? "extracted");
+        revived++;
+      }
+    }
+  }
+  db.upsertFile({ filePath: rel, contentHash: "", symbols: [], edges: [], imports: [], calls: [] });
+  return revived;
+}
+var MeridianIndexer = class {
+  constructor(cwd, stateDir, stigmergy) {
+    this.cwd = cwd;
+    const dir = stateDir ?? resolve(cwd, ".rivet");
+    this.db = new MeridianDb(dir);
+    this.behavior = new MeridianBehavior(this.db, stigmergy);
+  }
+  cwd;
+  db;
+  behavior;
+  initialized = false;
+  indexing = /* @__PURE__ */ new Set();
+  /** invalidateFile 并发守卫（共享 indexer 场景）：同 rel 只跑一个解析，
+   *  并发到达标 pending，首个完成后重跑一轮，保证最终落到最新内容。 */
+  invalidating = /* @__PURE__ */ new Set();
+  pendingInvalidations = /* @__PURE__ */ new Set();
+  /** 后台全量索引（meridian-backfill）每实例只调度一次的 flag。 */
+  backfillScheduled = false;
+  getDb() {
+    return this.db;
+  }
+  /**
+   * 廉价探针（meridian-hook read_file 热路径，2026-09-08 阻塞修复）：
+   * 与 indexFile 前缀完全同序地完成 path 校验 → indexable → db available →
+   * 读文件 → sha256 → needsParse。hash 未变时写 recordAccess 并返回
+   * 'unchanged'；需要重解析时返回 'parse'，由 hook 将完整 indexFile 入队，
+   * 不在 postTool 链上执行 tree-sitter/事务。此方法只做同步 IO + 一次
+   * SELECT，不触碰 parser，不写库（unchanged 的 access_log 除外）。
+   */
+  probeFile(filePath) {
+    const rel = this.toRepoRelative(filePath);
+    if (rel === null) return "skip";
+    if (this.indexing.has(rel)) return "skip";
+    if (!this.isIndexable(rel)) return "skip";
+    if (!this.db.available) return "skip";
+    const absPath = resolve(this.cwd, rel);
+    if (!existsSync2(absPath)) return "skip";
+    const source = readFileSync(absPath, "utf-8");
+    const hash = createHash2("sha256").update(source).digest("hex").slice(0, 16);
+    if (!this.db.needsParse(rel, hash)) {
+      this.db.recordAccess(rel);
+      return "unchanged";
+    }
+    return "parse";
+  }
+  async ensureInit() {
+    if (!this.initialized) {
+      await initParser();
+      this.initialized = true;
+    }
+  }
+  async indexFile(filePath, options = {}) {
+    const rel = this.toRepoRelative(filePath);
+    if (rel === null) return;
+    if (this.indexing.has(rel)) return;
+    if (!this.isIndexable(rel)) return;
+    if (!this.db.available) return;
+    const absPath = resolve(this.cwd, rel);
+    if (!existsSync2(absPath)) return;
+    const source = readFileSync(absPath, "utf-8");
+    const hash = createHash2("sha256").update(source).digest("hex").slice(0, 16);
+    if (!this.db.needsParse(rel, hash)) {
+      this.db.recordAccess(rel);
+      return;
+    }
+    await this.ensureInit();
+    this.indexing.add(rel);
+    try {
+      const result = await parseFile(rel, source);
+      const resolvedImports = this.resolveImports(rel, result.imports);
+      for (const resolved of resolvedImports) {
+        if (!this.indexing.has(resolved)) {
+          if (options.yieldBetweenImports) {
+            await new Promise((resolve2) => setTimeout(resolve2, 0));
+          }
+          await this.indexFile(resolved, options);
+        }
+      }
+      const known = [...result.symbols, ...resolvedImports.flatMap((imp) => this.db.getSymbolsForFile(imp))];
+      const fw = this.extractFrameworkEdges(rel, source, result.symbols, known);
+      this.db.upsertFile({ ...result, imports: resolvedImports, symbols: [...result.symbols, ...fw.symbols] });
+      this.db.recordAccess(rel);
+      if (this.isTestFile(rel)) {
+        this.buildTestEdges(rel);
+      }
+      for (const e of fw.edges) {
+        this.db.upsertEdge(e.sourceId, e.targetId, e.kind, e.weight, e.confidence ?? "extracted");
+      }
+      this.buildCallEdges(rel, result.calls);
+    } finally {
+      this.indexing.delete(rel);
+    }
+  }
+  async invalidateFile(filePath) {
+    const rel = this.toRepoRelative(filePath);
+    if (rel === null) return;
+    if (!this.isIndexable(rel)) return;
+    if (this.invalidating.has(rel)) {
+      this.pendingInvalidations.add(rel);
+      return;
+    }
+    this.invalidating.add(rel);
+    try {
+      do {
+        this.pendingInvalidations.delete(rel);
+        await this.invalidateFileCore(rel);
+      } while (this.pendingInvalidations.has(rel));
+    } finally {
+      this.invalidating.delete(rel);
+    }
+  }
+  async invalidateFileCore(rel) {
+    const absPath = resolve(this.cwd, rel);
+    if (!existsSync2(absPath)) return;
+    await this.ensureInit();
+    const source = readFileSync(absPath, "utf-8");
+    const result = await parseFile(rel, source);
+    const resolvedImports = this.resolveImports(rel, result.imports);
+    const known = [...result.symbols, ...resolvedImports.flatMap((imp) => this.db.getSymbolsForFile(imp))];
+    const fw = this.extractFrameworkEdges(rel, source, result.symbols, known);
+    this.db.upsertFile({ ...result, imports: resolvedImports, symbols: [...result.symbols, ...fw.symbols] });
+    if (this.isTestFile(rel)) {
+      this.buildTestEdges(rel);
+    }
+    for (const e of fw.edges) {
+      this.db.upsertEdge(e.sourceId, e.targetId, e.kind, e.weight, e.confidence ?? "extracted");
+    }
+    this.buildCallEdges(rel, result.calls);
+  }
+  /** Shared framework-edge extraction (route_handles/jsx_children) for the
+   *  indexFile and invalidateFile paths — keeps the two production paths in
+   *  lockstep so hot updates never silently drop framework edges.
+   *  fileSymbols must stay this-file-only (JSX enclosing selection compares
+   *  line numbers); knownSymbols may include cross-file symbols (route handler /
+   *  component name matching). */
+  extractFrameworkEdges(rel, source, fileSymbols, knownSymbols) {
+    const out = { symbols: [], edges: [] };
+    const fw = extractExpressRoutes(rel, source, knownSymbols);
+    out.symbols.push(...fw.symbols);
+    out.edges.push(...fw.edges);
+    const jsx = extractJsxChildren(rel, source, fileSymbols, knownSymbols);
+    out.edges.push(...jsx.edges);
+    return out;
+  }
+  /** 删除文件处理（wave4 T9）：跨文件入边复活为 pending 而非静默断裂。
+   *  已删除/不可索引的文件直接忽略。返回复活（pending）的入边条数。 */
+  removeFile(filePath) {
+    const rel = this.toRepoRelative(filePath);
+    if (rel === null) return 0;
+    if (!this.isIndexable(rel)) return 0;
+    return reviveDeletedFile(this.db, rel);
+  }
+  async query(seedFile, opts) {
+    await this.behavior.refreshPheromoneCache();
+    return buildRepoMap(this.db, seedFile, {
+      maxHops: opts?.maxHops ?? 3,
+      decay: opts?.decay ?? 0.5,
+      maxTokens: opts?.maxTokens ?? 2e3,
+      behavior: this.behavior
+    });
+  }
+  recordEdit(filePath, turn) {
+    const rel = this.toRepoRelative(filePath);
+    if (rel === null) return;
+    this.behavior.recordEdit(rel, turn);
+  }
+  flushTurn() {
+    this.behavior.flushCoEdits();
+  }
+  /** Analyze impact radius for changed files */
+  impact(changedFiles, opts) {
+    return analyzeImpact(this.db, changedFiles, opts);
+  }
+  /** Build tested_by edges for a test file based on naming + imports */
+  buildTestEdges(testFilePath) {
+    const allFiles = this.db.getAllFiles();
+    const targets = inferTestedByTargets(testFilePath, allFiles);
+    for (const target of targets) {
+      const sourceId = `${testFilePath}:*:0`;
+      const targetId = `${target}:*:0`;
+      this.db.upsertEdge(sourceId, targetId, "tested_by", 0.7, "inferred");
+    }
+  }
+  /** Resolve same-file-unresolved call sites against cross-file symbols by name.
+   *  Unique match → inferred; multiple matches → ambiguous on every candidate.
+   *  Confidence drives the CONFIDENCE_MULTIPLIER discount in the graph layer.
+   *
+   *  2026-09-08：不再 getAllSymbols 全表物化 + 逐 call 内存 filter——收集本次
+   *  全部 callee name 后一次 getSymbolsByNames 批量拉取（走 idx_symbols_name），
+   *  内存只建 name → symbols Map；同名多命中 ambiguous 语义不变。 */
+  buildCallEdges(fromFile, calls) {
+    if (calls.length === 0) return;
+    const names = [...new Set(calls.map((c) => c.name))];
+    const symbolsByName = /* @__PURE__ */ new Map();
+    for (const symbol of this.db.getSymbolsByNames(names)) {
+      if (symbol.filePath === fromFile) continue;
+      const list = symbolsByName.get(symbol.name);
+      if (list) list.push(symbol);
+      else symbolsByName.set(symbol.name, [symbol]);
+    }
+    for (const call of calls) {
+      const matches = symbolsByName.get(call.name) ?? [];
+      if (matches.length === 0) continue;
+      if (matches.length === 1) {
+        const target = matches[0];
+        if (target) this.db.upsertEdge(call.sourceId, target.id, "calls", 1, "inferred");
+      } else {
+        for (const m of matches) {
+          this.db.upsertEdge(call.sourceId, m.id, "calls", 1, "ambiguous");
+        }
+      }
+    }
+  }
+  getStats() {
+    return this.db.getStats();
+  }
+  close() {
+    this.db.close();
+  }
+  /** Normalize to repo-relative path for classification & DB keys.
+   *  Returns null for any path that resolves outside the repo root —
+   *  covers both absolute paths and relative `../` traversal.
+   *  Fail-closed: the indexer must never read/parse/store files
+   *  outside the project boundary. */
+  toRepoRelative(filePath) {
+    const absCwd = resolve(this.cwd);
+    let realCwd;
+    try {
+      realCwd = realpathSync(this.cwd);
+    } catch {
+      realCwd = absCwd;
+    }
+    const absFile = resolve(absCwd, filePath);
+    const posixCwd = toPosixPath(absCwd);
+    const posixFile = toPosixPath(absFile);
+    if (!posixFile.startsWith(posixCwd + "/")) return null;
+    let realFile;
+    try {
+      realFile = realpathSync(absFile);
+    } catch {
+      realFile = resolve(realCwd, "." + absFile.slice(absCwd.length));
+    }
+    if (!toPosixPath(realFile).startsWith(toPosixPath(realCwd) + "/")) return null;
+    return posixFile.slice(posixCwd.length + 1);
+  }
+  isIndexable(filePath) {
+    const rel = this.toRepoRelative(filePath);
+    if (rel === null) return false;
+    return isMeridianIndexablePath(rel);
+  }
+  isTestFile(filePath) {
+    return filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("__tests__/") || filePath.includes("test/");
+  }
+  /** Resolve a list of raw import strings to deduped repo-relative paths.
+   *  External packages (zod, node:fs) and tsconfig path aliases (@/, ~) fail
+   *  resolution and are dropped — they carry no reverse-dependency value here. */
+  resolveImports(fromFile, imports) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const imp of imports) {
+      const resolved = this.resolveImport(fromFile, imp);
+      if (resolved) seen.add(resolved);
+    }
+    return [...seen];
+  }
+  resolveImport(fromFile, importPath) {
+    const posixRoot = toPosixPath(resolve(this.cwd));
+    const baseDir = dirname(resolve(this.cwd, fromFile));
+    for (const ext of TS_EXTENSIONS) {
+      const withExt = resolve(baseDir, importPath.replace(/\.[jt]sx?$/, "") + ext);
+      if (existsSync2(withExt)) {
+        return toPosixPath(withExt).slice(posixRoot.length + 1);
+      }
+      const indexFile = resolve(baseDir, importPath, "index" + ext);
+      if (existsSync2(indexFile)) {
+        return toPosixPath(indexFile).slice(posixRoot.length + 1);
+      }
+    }
+    return null;
+  }
+};
+
+export {
+  isMeridianIndexablePath,
+  isUnnamedSymbolId,
+  queryFlow,
+  reviveDeletedFile,
+  MeridianIndexer
+};