suture-mcp 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,3033 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/cli.ts
+var path9 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs"), 1);
+var readline2 = __toESM(require("readline/promises"), 1);
+var import_node_stream2 = require("stream");
+var import_node_process = require("process");
+
+// src/substrate/sqlite.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+function rowToEpisode(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId ?? void 0,
+    content: JSON.parse(row.content),
+    entities: JSON.parse(row.entities),
+    edges: JSON.parse(row.edges),
+    validFrom: new Date(row.validFrom),
+    validTo: row.validTo !== null ? new Date(row.validTo) : null,
+    tier: row.tier,
+    rir: JSON.parse(row.rir),
+    source: row.source,
+    confidence: row.confidence ?? void 0,
+    status: row.status ?? "active",
+    visibility: row.visibility ?? "local",
+    tags: row.tags ? JSON.parse(row.tags) : void 0,
+    provenance: row.provenance ? JSON.parse(row.provenance) : void 0,
+    curationReason: row.curationReason ?? void 0,
+    pinned: row.pinned !== null && row.pinned !== void 0 ? row.pinned === 1 : void 0
+  };
+}
+var SqliteSubstrate = class {
+  db;
+  constructor(path10) {
+    this.db = new import_better_sqlite3.default(path10);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS episodes (
+        id TEXT PRIMARY KEY,
+        projectId TEXT,
+        content TEXT NOT NULL,
+        entities TEXT NOT NULL,
+        edges TEXT NOT NULL,
+        validFrom INTEGER NOT NULL,
+        validTo INTEGER,
+        tier TEXT NOT NULL,
+        rir TEXT NOT NULL,
+        source TEXT NOT NULL,
+        confidence REAL,
+        status TEXT NOT NULL DEFAULT 'active',
+        visibility TEXT NOT NULL DEFAULT 'local',
+        tags TEXT,
+        provenance TEXT,
+        curationReason TEXT,
+        pinned INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS discovery_sessions (
+        id TEXT PRIMARY KEY,
+        projectId TEXT NOT NULL,
+        rootPath TEXT NOT NULL,
+        startedBy TEXT NOT NULL,
+        startedAt INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        scanSummary TEXT NOT NULL,
+        coverage TEXT NOT NULL,
+        policyVersion TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS discovery_findings (
+        id TEXT PRIMARY KEY,
+        sessionId TEXT NOT NULL,
+        projectId TEXT NOT NULL,
+        type TEXT NOT NULL,
+        claim TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        evidence TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        source TEXT NOT NULL,
+        freshness TEXT NOT NULL,
+        risk TEXT NOT NULL,
+        status TEXT NOT NULL,
+        createdAt INTEGER NOT NULL,
+        reason TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS hook_injection_ledger (
+        projectId TEXT NOT NULL,
+        sessionId TEXT NOT NULL,
+        client TEXT NOT NULL,
+        event TEXT NOT NULL,
+        lastHash TEXT NOT NULL,
+        lastInjectedAt INTEGER NOT NULL,
+        source TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        PRIMARY KEY (projectId, sessionId, client, event)
+      );
+      CREATE TABLE IF NOT EXISTS hook_reinject_flags (
+        projectId TEXT NOT NULL,
+        sessionId TEXT NOT NULL,
+        client TEXT NOT NULL,
+        source TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        createdAt INTEGER NOT NULL,
+        consumedAt INTEGER,
+        PRIMARY KEY (projectId, sessionId, client)
+      );
+      CREATE TABLE IF NOT EXISTS project_index_files (
+        projectId TEXT NOT NULL,
+        filePath TEXT NOT NULL,
+        hash TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        indexedAt INTEGER NOT NULL,
+        estimatedTokens INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (projectId, filePath)
+      );
+      CREATE TABLE IF NOT EXISTS project_index_projects (
+        projectId TEXT PRIMARY KEY,
+        fingerprint TEXT NOT NULL,
+        rootPath TEXT NOT NULL,
+        packageName TEXT,
+        gitRemote TEXT,
+        firstIndexedAt INTEGER NOT NULL,
+        lastIndexedAt INTEGER NOT NULL,
+        indexedFiles INTEGER NOT NULL DEFAULT 0,
+        codeSymbols INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+    this.migrate();
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS episodes_active_project ON episodes(projectId, validTo, status);
+      CREATE INDEX IF NOT EXISTS discovery_findings_session ON discovery_findings(sessionId);
+      CREATE INDEX IF NOT EXISTS project_index_files_project ON project_index_files(projectId);
+      CREATE UNIQUE INDEX IF NOT EXISTS project_index_projects_fingerprint ON project_index_projects(fingerprint);
+      CREATE INDEX IF NOT EXISTS project_index_projects_root ON project_index_projects(rootPath);
+    `);
+  }
+  migrate() {
+    const columns = new Set(
+      this.db.prepare(`PRAGMA table_info(episodes)`).all().map((c) => c.name)
+    );
+    const add = (name, definition) => {
+      if (!columns.has(name)) this.db.exec(`ALTER TABLE episodes ADD COLUMN ${name} ${definition}`);
+    };
+    add("projectId", "TEXT");
+    add("confidence", "REAL");
+    add("status", "TEXT NOT NULL DEFAULT 'active'");
+    add("visibility", "TEXT NOT NULL DEFAULT 'local'");
+    add("tags", "TEXT");
+    add("provenance", "TEXT");
+    add("curationReason", "TEXT");
+    add("pinned", "INTEGER NOT NULL DEFAULT 0");
+    this.db.prepare(
+      `INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('schemaVersion', '2')`
+    ).run();
+  }
+  upsert(episode) {
+    this.db.prepare(
+      `
+      INSERT OR REPLACE INTO episodes (
+        id, projectId, content, entities, edges, validFrom, validTo, tier, rir, source,
+        confidence, status, visibility, tags, provenance, curationReason, pinned
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+    ).run(
+      episode.id,
+      episode.projectId ?? null,
+      JSON.stringify(episode.content),
+      JSON.stringify(episode.entities),
+      JSON.stringify(episode.edges),
+      episode.validFrom.getTime(),
+      episode.validTo !== null ? episode.validTo.getTime() : null,
+      episode.tier,
+      JSON.stringify(episode.rir),
+      episode.source,
+      episode.confidence ?? null,
+      episode.status ?? "active",
+      episode.visibility ?? "local",
+      episode.tags ? JSON.stringify(episode.tags) : null,
+      episode.provenance ? JSON.stringify(episode.provenance) : null,
+      episode.curationReason ?? null,
+      episode.pinned ? 1 : 0
+    );
+  }
+  invalidate(id, validTo) {
+    this.db.prepare(`UPDATE episodes SET validTo = ?, status = 'invalidated' WHERE id = ?`).run(validTo.getTime(), id);
+  }
+  listByTier(tier) {
+    const rows = this.db.prepare(`SELECT * FROM episodes WHERE tier = ? AND validTo IS NULL AND status = 'active'`).all(tier);
+    return rows.map(rowToEpisode);
+  }
+  listAll() {
+    const rows = this.db.prepare(`SELECT * FROM episodes WHERE validTo IS NULL AND status = 'active'`).all();
+    return rows.map(rowToEpisode);
+  }
+  listActiveByIds(ids) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(", ");
+    const rows = this.db.prepare(`SELECT * FROM episodes WHERE id IN (${placeholders}) AND validTo IS NULL AND status = 'active'`).all(...ids);
+    const byId = new Map(rows.map((row) => [row.id, rowToEpisode(row)]));
+    return ids.flatMap((id) => {
+      const ep = byId.get(id);
+      return ep ? [ep] : [];
+    });
+  }
+  listAllRaw() {
+    return this.db.prepare(`SELECT * FROM episodes WHERE validTo IS NULL AND status = 'active'`).all();
+  }
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  raw() {
+    return this.db;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/server/mcp.ts
+var path6 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var import_node_stream = require("stream");
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/core/gate.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var SessionGate = class {
+  seen = /* @__PURE__ */ new Set();
+  sentinel;
+  constructor(stateDir) {
+    fs.mkdirSync(stateDir, { recursive: true });
+    this.sentinel = path.join(stateDir, "reinject.flag");
+  }
+  shouldInject(contentHash) {
+    return !this.seen.has(contentHash) || fs.existsSync(this.sentinel);
+  }
+  markInjected(contentHash) {
+    this.seen.add(contentHash);
+    if (fs.existsSync(this.sentinel)) {
+      fs.unlinkSync(this.sentinel);
+    }
+  }
+  forceReinject() {
+    fs.writeFileSync(this.sentinel, "");
+  }
+};
+
+// src/search/memory-graph.ts
+function normalizeName(name) {
+  return name.trim().toLowerCase();
+}
+var MemoryGraph = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mg_entities (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        normalizedName TEXT,
+        kind TEXT NOT NULL,
+        attributes TEXT NOT NULL,
+        episodeId TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS mg_entities_name ON mg_entities(name);
+      CREATE INDEX IF NOT EXISTS mg_entities_normalized_name ON mg_entities(normalizedName);
+      CREATE TABLE IF NOT EXISTS mg_relations (
+        fromId TEXT NOT NULL,
+        toId TEXT NOT NULL,
+        label TEXT NOT NULL,
+        validFrom INTEGER NOT NULL,
+        validTo INTEGER,
+        episodeId TEXT NOT NULL
+      );
+    `);
+    const columns = new Set(
+      this.db.prepare(`PRAGMA table_info(mg_entities)`).all().map((c) => c.name)
+    );
+    if (!columns.has("normalizedName")) {
+      this.db.exec(`ALTER TABLE mg_entities ADD COLUMN normalizedName TEXT`);
+      this.db.exec(`UPDATE mg_entities SET normalizedName = lower(name) WHERE normalizedName IS NULL`);
+    }
+  }
+  index(episode) {
+    this.remove(episode.id);
+    const upsertEntity = this.db.prepare(
+      `INSERT OR REPLACE INTO mg_entities(id, name, normalizedName, kind, attributes, episodeId) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    const insertRelation = this.db.prepare(
+      `INSERT INTO mg_relations(fromId, toId, label, validFrom, validTo, episodeId) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    for (const entity of episode.entities) {
+      upsertEntity.run(
+        entity.id,
+        entity.name,
+        normalizeName(entity.name),
+        entity.kind,
+        JSON.stringify(entity.attributes),
+        episode.id
+      );
+    }
+    for (const edge of episode.edges) {
+      insertRelation.run(
+        edge.fromId,
+        edge.toId,
+        edge.label,
+        edge.validFrom.getTime(),
+        edge.validTo ? edge.validTo.getTime() : null,
+        episode.id
+      );
+    }
+  }
+  search(entityName, limit = 10) {
+    const rows = this.db.prepare(
+      `SELECT DISTINCT e.episodeId
+         FROM mg_entities e
+         JOIN episodes ep ON ep.id = e.episodeId
+         WHERE e.normalizedName = ?
+           AND ep.validTo IS NULL
+           AND ep.status = 'active'
+         LIMIT ?`
+    ).all(normalizeName(entityName), limit);
+    return rows.map((r) => r.episodeId);
+  }
+  getRelations(entityId) {
+    const rows = this.db.prepare(`SELECT * FROM mg_relations WHERE fromId = ?`).all(entityId);
+    return rows.map((r) => ({
+      fromId: r.fromId,
+      toId: r.toId,
+      label: r.label,
+      validFrom: new Date(r.validFrom),
+      validTo: r.validTo !== null ? new Date(r.validTo) : null
+    }));
+  }
+  remove(episodeId) {
+    this.db.prepare(`DELETE FROM mg_entities WHERE episodeId = ?`).run(episodeId);
+    this.db.prepare(`DELETE FROM mg_relations WHERE episodeId = ?`).run(episodeId);
+  }
+  clear() {
+    this.db.prepare(`DELETE FROM mg_entities`).run();
+    this.db.prepare(`DELETE FROM mg_relations`).run();
+  }
+};
+
+// src/search/code-graph.ts
+var import_node_module = require("module");
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var Parser = require2("tree-sitter");
+var { typescript: tsLang } = require2("tree-sitter-typescript");
+var KIND_MAP = {
+  function_declaration: "function",
+  method_definition: "function",
+  class_declaration: "class",
+  interface_declaration: "interface",
+  type_alias_declaration: "type",
+  lexical_declaration: "variable"
+};
+var CodeGraph = class {
+  db;
+  parser;
+  constructor(db) {
+    this.db = db;
+    this.ensureSchema();
+    this.parser = new Parser();
+    this.parser.setLanguage(tsLang);
+  }
+  ensureSchema() {
+    const existingColumns = this.db.prepare(`PRAGMA table_info(cg_symbols)`).all();
+    const primaryKey = existingColumns.filter((column) => column.pk > 0).sort((a, b) => a.pk - b.pk).map((column) => column.name).join(",");
+    if (existingColumns.length > 0 && primaryKey !== "name,filePath,line") {
+      this.db.exec(`
+        DROP TABLE IF EXISTS cg_symbols;
+        DROP TABLE IF EXISTS cg_symbols_fts;
+      `);
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS cg_symbols (
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        filePath TEXT NOT NULL,
+        line INTEGER NOT NULL,
+        PRIMARY KEY (name, filePath, line)
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS cg_symbols_fts USING fts5(
+        name,
+        filePath UNINDEXED,
+        line UNINDEXED,
+        tokenize='trigram'
+      );
+    `);
+  }
+  indexFile(filePath, source) {
+    this.removeFile(filePath);
+    const tree = this.parser.parse(source);
+    const upsertSym = this.db.prepare(
+      `INSERT OR REPLACE INTO cg_symbols(name, kind, filePath, line) VALUES (?, ?, ?, ?)`
+    );
+    const upsertFts = this.db.prepare(
+      `INSERT INTO cg_symbols_fts(name, filePath, line) VALUES (?, ?, ?)`
+    );
+    const walk = (node) => {
+      const kind = KIND_MAP[node.type];
+      if (kind) {
+        let name;
+        if (node.type === "lexical_declaration") {
+          const declarator = node.children.find(
+            (c) => c.type === "variable_declarator"
+          );
+          name = declarator?.childForFieldName("name")?.text;
+        } else {
+          name = node.childForFieldName("name")?.text;
+        }
+        if (name) {
+          const line2 = node.startPosition.row + 1;
+          upsertSym.run(name, kind, filePath, line2);
+          upsertFts.run(name, filePath, line2);
+        }
+      }
+      for (const child of node.children) {
+        walk(child);
+      }
+    };
+    walk(tree.rootNode);
+  }
+  search(query, limit = 10) {
+    const normalized = query.trim().slice(0, 200);
+    if (!normalized) return [];
+    const safeQuery = `"${normalized.replace(/"/g, '""')}"`;
+    let rows;
+    try {
+      rows = this.db.prepare(
+        `SELECT s.name, s.kind, s.filePath, s.line
+           FROM cg_symbols_fts f
+           JOIN cg_symbols s ON s.name = f.name AND s.filePath = f.filePath AND s.line = f.line
+           WHERE cg_symbols_fts MATCH ?
+           ORDER BY rank
+           LIMIT ?`
+      ).all(safeQuery, limit);
+    } catch {
+      return [];
+    }
+    return rows.map((r) => ({
+      name: r.name,
+      kind: r.kind,
+      filePath: r.filePath,
+      line: r.line
+    }));
+  }
+  countSymbolsForFile(filePath) {
+    const row = this.db.prepare(`SELECT COUNT(*) AS count FROM cg_symbols WHERE filePath = ?`).get(filePath);
+    return row?.count ?? 0;
+  }
+  removeFile(filePath) {
+    this.db.prepare(`DELETE FROM cg_symbols WHERE filePath = ?`).run(filePath);
+    this.db.prepare(`DELETE FROM cg_symbols_fts WHERE filePath = ?`).run(filePath);
+  }
+};
+
+// src/search/fts5.ts
+var Fts5Index = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS episodes_fts USING fts5(
+        id UNINDEXED,
+        text,
+        tokenize="trigram"
+      )
+    `);
+  }
+  index(episode) {
+    this.remove(episode.id);
+    this.db.prepare(`INSERT OR REPLACE INTO episodes_fts(id, text) VALUES (?, ?)`).run(episode.id, JSON.stringify(episode.content));
+  }
+  search(query, limit = 10) {
+    const normalized = query.trim().slice(0, 200);
+    if (!normalized) return [];
+    const safeQuery = `"${normalized.replace(/"/g, '""')}"`;
+    try {
+      const rows = this.db.prepare(
+        `SELECT id FROM episodes_fts WHERE episodes_fts MATCH ? ORDER BY rank LIMIT ?`
+      ).all(safeQuery, limit);
+      return rows.map((r) => r.id);
+    } catch {
+      return [];
+    }
+  }
+  remove(id) {
+    this.db.prepare(`DELETE FROM episodes_fts WHERE id = ?`).run(id);
+  }
+  clear() {
+    this.db.prepare(`DELETE FROM episodes_fts`).run();
+  }
+};
+
+// src/search/router.ts
+var SearchRouter = class {
+  memory;
+  code;
+  fts;
+  constructor(memory, code, fts) {
+    this.memory = memory;
+    this.code = code;
+    this.fts = fts;
+  }
+  search(query, limit = 10) {
+    const graphIds = this.memory.search(query, limit);
+    const ftsIds = this.fts.search(query, limit);
+    const codeSymbols = this.code.search(query, limit);
+    const seen = /* @__PURE__ */ new Set();
+    const episodeIds = [];
+    for (const id of [...graphIds, ...ftsIds]) {
+      if (!seen.has(id)) {
+        seen.add(id);
+        episodeIds.push(id);
+      }
+    }
+    const hasGraph = graphIds.length > 0;
+    const hasFts = ftsIds.length > 0;
+    const hasCode = codeSymbols.length > 0;
+    const backendCount = (hasGraph ? 1 : 0) + (hasFts ? 1 : 0) + (hasCode ? 1 : 0);
+    let source;
+    if (backendCount > 1) {
+      source = "combined";
+    } else if (hasGraph) {
+      source = "graph";
+    } else if (hasCode) {
+      source = "code";
+    } else {
+      source = "fts5";
+    }
+    return { episodeIds, codeSymbols, source };
+  }
+};
+
+// src/curator/rir.ts
+var RirScorer = class {
+  recency(createdAt) {
+    const hoursSince = (Date.now() - createdAt.getTime()) / 36e5;
+    return Math.exp(-0.1 * hoursSince);
+  }
+  importance(content) {
+    return Math.min(Math.max(JSON.stringify(content).length / 500, 0.35), 1);
+  }
+  relevance(content, goal) {
+    if (!goal) return 1;
+    const text = JSON.stringify(content).toLowerCase();
+    const goalWords = goal.toLowerCase().split(/\s+/).filter(Boolean);
+    if (goalWords.length === 0) return 1;
+    const matched = goalWords.filter((w) => text.includes(w)).length;
+    return Math.min(matched / goalWords.length, 1);
+  }
+  score(episode) {
+    return {
+      recency: this.recency(episode.validFrom),
+      importance: this.importance(episode.content),
+      relevance: this.relevance(episode.content)
+    };
+  }
+};
+
+// src/curator/semantic.ts
+var import_nanoid = require("nanoid");
+var SemanticCurator = class {
+  async scoreImportance(content) {
+    return Math.min(Math.max(JSON.stringify(content).length / 500, 0.35), 1);
+  }
+  async extractEntities(content) {
+    if (content.kind === "entity") {
+      return [{ id: (0, import_nanoid.nanoid)(), name: content.name, kind: "entity", attributes: content.attributes }];
+    }
+    const text = "text" in content ? content.text : "what" in content ? content.what : "claim" in content ? content.claim : "choice" in content ? content.choice : "";
+    const candidates = Array.from(new Set(text.match(/\b[A-Z][A-Za-z0-9_-]{2,}\b/g) ?? []));
+    return candidates.slice(0, 8).map((name) => ({
+      id: (0, import_nanoid.nanoid)(),
+      name,
+      kind: "concept",
+      attributes: { extractedBy: "semantic-fallback" }
+    }));
+  }
+};
+
+// src/tiers/manager.ts
+function tierForRir(rir) {
+  if (rir > 0.7) return "core";
+  if (rir > 0.3) return "recall";
+  if (rir > 0.1) return "archive";
+  return "delete";
+}
+var TierManager = class {
+  constructor(substrate, scorer, curator, indexes) {
+    this.substrate = substrate;
+    this.scorer = scorer;
+    this.curator = curator;
+    this.indexes = indexes;
+  }
+  substrate;
+  scorer;
+  curator;
+  indexes;
+  async runCuration() {
+    const summary = {
+      promoted: 0,
+      retained: 0,
+      archived: 0,
+      deleted: 0,
+      actions: []
+    };
+    const episodes = this.substrate.listAll();
+    for (const episode of episodes) {
+      const scores = this.scorer.score(episode);
+      const importance = await this.curator.scoreImportance(episode.content);
+      const rir = scores.recency * importance * scores.relevance;
+      const target = tierForRir(rir);
+      if (target === "delete") {
+        this.substrate.invalidate(episode.id, /* @__PURE__ */ new Date());
+        this.indexes?.removeEpisode(episode.id);
+        summary.deleted++;
+        summary.actions.push({
+          action: "invalidated",
+          detail: `${episode.id} scored RIR ${rir.toFixed(3)}`,
+          projectId: episode.projectId
+        });
+      } else {
+        if (target === "core" && episode.tier !== "core") {
+          summary.promoted++;
+        } else if (target === "archive" && episode.tier !== "archive") {
+          summary.archived++;
+        } else {
+          summary.retained++;
+        }
+        const updated = {
+          ...episode,
+          tier: target,
+          rir: { ...scores, importance },
+          curationReason: `RIR ${rir.toFixed(3)} mapped to ${target}`
+        };
+        this.substrate.upsert(updated);
+        this.indexes?.indexEpisode(updated);
+        summary.actions.push({
+          action: target === "core" ? "promoted" : target === "archive" ? "archived" : "retained",
+          detail: `${episode.id} mapped to ${target} at RIR ${rir.toFixed(3)}`,
+          projectId: episode.projectId
+        });
+      }
+    }
+    return summary;
+  }
+  getCoreBlock() {
+    const episodes = this.substrate.listByTier("core");
+    episodes.sort(
+      (a, b) => b.rir.recency * b.rir.importance * b.rir.relevance - a.rir.recency * a.rir.importance * a.rir.relevance
+    );
+    const LIMIT = 2048;
+    let result = "";
+    for (const ep of episodes) {
+      const line2 = `[${ep.tier}] ${JSON.stringify(ep.content)}
+`;
+      if (result.length + line2.length > LIMIT) break;
+      result += line2;
+    }
+    return result;
+  }
+};
+
+// src/services/index-manager.ts
+var IndexManager = class {
+  constructor(memory, code, fts) {
+    this.memory = memory;
+    this.code = code;
+    this.fts = fts;
+  }
+  memory;
+  code;
+  fts;
+  indexEpisode(episode) {
+    this.fts.index(episode);
+    this.memory.index(episode);
+  }
+  removeEpisode(episodeId) {
+    this.fts.remove(episodeId);
+    this.memory.remove(episodeId);
+  }
+  rebuildEpisodes(episodes) {
+    this.fts.clear();
+    this.memory.clear();
+    for (const episode of episodes) {
+      this.indexEpisode(episode);
+    }
+  }
+  indexCodeFile(filePath, source) {
+    this.code.indexFile(filePath, source);
+  }
+  removeCodeFile(filePath) {
+    this.code.removeFile(filePath);
+  }
+};
+
+// src/server/tools.ts
+var path4 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+var import_zod2 = require("zod");
+
+// src/discovery/engine.ts
+var fs2 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var import_nanoid2 = require("nanoid");
+
+// src/security/scanner.ts
+var path2 = __toESM(require("path"), 1);
+var SECRET_PATTERNS = [
+  { name: "private_key", pattern: /-----BEGIN (?:RSA |EC |OPENSSH |)?PRIVATE KEY-----/gi },
+  { name: "github_token", pattern: /gh[pousr]_[A-Za-z0-9_]{20,}/g },
+  { name: "openai_key", pattern: /sk-[A-Za-z0-9_-]{20,}/g },
+  { name: "aws_access_key", pattern: /AKIA[0-9A-Z]{16}/g },
+  { name: "env_secret", pattern: /\b(?:SECRET|TOKEN|PASSWORD|API_KEY|PRIVATE_KEY)\s*=\s*["']?[^"'\s]+/gi }
+];
+function isWithin(root, target) {
+  const relative4 = path2.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path2.isAbsolute(relative4);
+}
+var SecurityScanner = class {
+  scanText(text) {
+    const reasons = SECRET_PATTERNS.filter(({ pattern }) => text.match(pattern)).map(({ name }) => name);
+    let redactedText = text;
+    for (const { pattern } of SECRET_PATTERNS) {
+      redactedText = redactedText.replace(pattern, "[REDACTED]");
+    }
+    return { blocked: reasons.length > 0, reasons, redactedText };
+  }
+  isIgnoredPath(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    return /(^|\/)(node_modules|dist|build|coverage|\.git|\.next|\.cache|vendor)(\/|$)/.test(normalized);
+  }
+  canExportTo(targetPath, stateDir) {
+    const target = path2.resolve(targetPath);
+    const state = path2.resolve(stateDir);
+    const tmp = path2.resolve("/tmp");
+    return isWithin(state, target) || isWithin(tmp, target);
+  }
+};
+
+// src/discovery/policy.ts
+var LOW_RISK = /* @__PURE__ */ new Set([
+  "language",
+  "framework",
+  "package_manager",
+  "script",
+  "command",
+  "entrypoint",
+  "test_strategy",
+  "directory_role",
+  "dependency"
+]);
+var HIGH_RISK = /* @__PURE__ */ new Set([
+  "architecture_note",
+  "decision",
+  "risk",
+  "deployment_note"
+]);
+var DiscoveryPolicy = class {
+  constructor(security = new SecurityScanner()) {
+    this.security = security;
+  }
+  security;
+  version = "2026-05-secure-project-map";
+  decide(input2) {
+    const scan = this.security.scanText(`${input2.claim}
+${JSON.stringify(input2.payload ?? {})}`);
+    if (scan.blocked) {
+      return {
+        status: "blocked",
+        risk: "high",
+        reason: `blocked sensitive content: ${scan.reasons.join(", ")}`
+      };
+    }
+    const hasEvidence = (input2.evidence ?? []).length > 0;
+    if (LOW_RISK.has(input2.type) && hasEvidence) {
+      return {
+        status: "auto_accepted",
+        risk: "low",
+        reason: "low-risk project-map finding with evidence"
+      };
+    }
+    if (HIGH_RISK.has(input2.type)) {
+      return {
+        status: "queued",
+        risk: "high",
+        reason: "high-impact claim requires review or stronger confirmation"
+      };
+    }
+    return {
+      status: "queued",
+      risk: "medium",
+      reason: hasEvidence ? "finding requires review before durable memory" : "finding lacks evidence and was queued as low-confidence"
+    };
+  }
+};
+
+// src/discovery/engine.ts
+var INITIAL_COVERAGE = {
+  languages: 0,
+  scripts: 0,
+  entrypoints: 0,
+  tests: 0,
+  docs: 0,
+  queued: 0,
+  blocked: 0,
+  accepted: 0
+};
+var EXT_LANGUAGE = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript React",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript React",
+  ".py": "Python",
+  ".rs": "Rust",
+  ".go": "Go",
+  ".java": "Java",
+  ".rb": "Ruby",
+  ".php": "PHP"
+};
+function projectIdFor(rootPath) {
+  return path3.basename(path3.resolve(rootPath)).replace(/[^A-Za-z0-9_.-]/g, "-") || "project";
+}
+function rowToSession(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    rootPath: row.rootPath,
+    startedBy: row.startedBy,
+    startedAt: new Date(row.startedAt),
+    status: row.status,
+    scanSummary: JSON.parse(row.scanSummary),
+    coverage: JSON.parse(row.coverage),
+    policyVersion: row.policyVersion
+  };
+}
+function rowToFinding(row) {
+  return {
+    id: row.id,
+    sessionId: row.sessionId,
+    projectId: row.projectId,
+    type: row.type,
+    claim: row.claim,
+    payload: JSON.parse(row.payload),
+    evidence: JSON.parse(row.evidence),
+    confidence: row.confidence,
+    source: row.source,
+    freshness: row.freshness,
+    risk: row.risk,
+    status: row.status,
+    createdAt: new Date(row.createdAt),
+    reason: row.reason
+  };
+}
+var DiscoveryEngine = class {
+  constructor(substrate, policy = new DiscoveryPolicy(), security = new SecurityScanner()) {
+    this.substrate = substrate;
+    this.policy = policy;
+    this.security = security;
+  }
+  substrate;
+  policy;
+  security;
+  start(rootPath, startedBy = "agent", projectId = projectIdFor(rootPath)) {
+    const resolved = path3.resolve(rootPath);
+    const session = {
+      id: (0, import_nanoid2.nanoid)(),
+      projectId,
+      rootPath: resolved,
+      startedBy,
+      startedAt: /* @__PURE__ */ new Date(),
+      status: "active",
+      scanSummary: {},
+      coverage: { ...INITIAL_COVERAGE },
+      policyVersion: this.policy.version
+    };
+    this.substrate.raw().prepare(
+      `INSERT INTO discovery_sessions(id, projectId, rootPath, startedBy, startedAt, status, scanSummary, coverage, policyVersion)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      session.id,
+      session.projectId,
+      session.rootPath,
+      session.startedBy,
+      session.startedAt.getTime(),
+      session.status,
+      JSON.stringify(session.scanSummary),
+      JSON.stringify(session.coverage),
+      session.policyVersion
+    );
+    return session;
+  }
+  getSession(sessionId) {
+    const row = this.substrate.raw().prepare(`SELECT * FROM discovery_sessions WHERE id = ?`).get(sessionId);
+    return row ? rowToSession(row) : null;
+  }
+  findings(sessionId) {
+    const rows = this.substrate.raw().prepare(`SELECT * FROM discovery_findings WHERE sessionId = ? ORDER BY createdAt ASC`).all(sessionId);
+    return rows.map(rowToFinding);
+  }
+  submit(sessionId, input2) {
+    const session = this.getSession(sessionId);
+    if (!session) throw new Error(`Unknown discovery session: ${sessionId}`);
+    const decision = this.policy.decide(input2);
+    const scan = this.security.scanText(`${input2.claim}
+${JSON.stringify(input2.payload ?? {})}`);
+    const finding = {
+      id: (0, import_nanoid2.nanoid)(),
+      sessionId,
+      projectId: session.projectId,
+      type: input2.type,
+      claim: scan.blocked ? scan.redactedText.split("\n")[0] : input2.claim,
+      payload: scan.blocked ? { redacted: true } : input2.payload ?? {},
+      evidence: input2.evidence ?? [],
+      confidence: input2.confidence ?? (decision.status === "auto_accepted" ? 0.85 : 0.45),
+      source: input2.source ?? "agent",
+      freshness: input2.freshness ?? "fresh",
+      risk: decision.risk,
+      status: decision.status,
+      createdAt: /* @__PURE__ */ new Date(),
+      reason: decision.reason
+    };
+    this.substrate.raw().prepare(
+      `INSERT INTO discovery_findings(
+        id, sessionId, projectId, type, claim, payload, evidence, confidence,
+        source, freshness, risk, status, createdAt, reason
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      finding.id,
+      finding.sessionId,
+      finding.projectId,
+      finding.type,
+      finding.claim,
+      JSON.stringify(finding.payload),
+      JSON.stringify(finding.evidence),
+      finding.confidence,
+      finding.source,
+      finding.freshness,
+      finding.risk,
+      finding.status,
+      finding.createdAt.getTime(),
+      finding.reason
+    );
+    this.updateCoverage(sessionId);
+    return finding;
+  }
+  scan(sessionId) {
+    const session = this.getSession(sessionId);
+    if (!session) throw new Error(`Unknown discovery session: ${sessionId}`);
+    const root = session.rootPath;
+    const findings = [];
+    const languages = /* @__PURE__ */ new Set();
+    const topDirs = [];
+    let docs = 0;
+    let tests = 0;
+    const walk = (dir, depth) => {
+      if (depth > 3 || this.security.isIgnoredPath(dir)) return;
+      for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+        const full = path3.join(dir, entry.name);
+        const rel = path3.relative(root, full) || entry.name;
+        if (this.security.isIgnoredPath(rel)) continue;
+        if (entry.isDirectory()) {
+          if (depth === 0) topDirs.push(entry.name);
+          if (/test|spec/i.test(entry.name)) tests++;
+          walk(full, depth + 1);
+          continue;
+        }
+        const ext = path3.extname(entry.name);
+        if (EXT_LANGUAGE[ext]) languages.add(EXT_LANGUAGE[ext]);
+        if (/^readme|\.md$/i.test(entry.name) || ext === ".md") docs++;
+        if (/(\.test|\.spec)\.[tj]sx?$|test_/i.test(entry.name)) tests++;
+      }
+    };
+    walk(root, 0);
+    for (const language of languages) {
+      findings.push({
+        type: "language",
+        claim: `Project uses ${language}`,
+        payload: { language },
+        evidence: [{ kind: "file", path: root }],
+        source: "scanner"
+      });
+    }
+    const packagePath = path3.join(root, "package.json");
+    if (fs2.existsSync(packagePath)) {
+      const pkg = JSON.parse(fs2.readFileSync(packagePath, "utf-8"));
+      findings.push({
+        type: "package_manager",
+        claim: "Project has a package.json and uses the Node package ecosystem",
+        payload: { packageManager: fs2.existsSync(path3.join(root, "package-lock.json")) ? "npm" : "node" },
+        evidence: [{ kind: "file", path: packagePath }],
+        source: "scanner"
+      });
+      for (const [name, command] of Object.entries(pkg.scripts ?? {})) {
+        findings.push({
+          type: "script",
+          claim: `npm script ${name}: ${command}`,
+          payload: { name, command },
+          evidence: [{ kind: "package", path: packagePath, key: `scripts.${name}` }],
+          source: "scanner"
+        });
+      }
+      if (pkg.main) {
+        findings.push({
+          type: "entrypoint",
+          claim: `Package main entrypoint is ${pkg.main}`,
+          payload: { main: pkg.main },
+          evidence: [{ kind: "package", path: packagePath, key: "main" }],
+          source: "scanner"
+        });
+      }
+    }
+    for (const dir of topDirs.slice(0, 20)) {
+      findings.push({
+        type: "directory_role",
+        claim: `Top-level project directory: ${dir}`,
+        payload: { directory: dir },
+        evidence: [{ kind: "file", path: path3.join(root, dir) }],
+        source: "scanner"
+      });
+    }
+    if (tests > 0) {
+      findings.push({
+        type: "test_strategy",
+        claim: `Project has ${tests} visible test-related files or directories`,
+        payload: { count: tests },
+        evidence: [{ kind: "file", path: root }],
+        source: "scanner"
+      });
+    }
+    if (docs > 0) {
+      findings.push({
+        type: "convention",
+        claim: `Project has ${docs} visible documentation files`,
+        payload: { count: docs },
+        evidence: [{ kind: "file", path: root }],
+        source: "scanner"
+      });
+    }
+    return findings.map((finding) => this.submit(sessionId, finding));
+  }
+  status(sessionId) {
+    const session = this.getSession(sessionId);
+    if (!session) throw new Error(`Unknown discovery session: ${sessionId}`);
+    const findings = this.findings(sessionId);
+    return { session, findings, coverage: this.coverageFor(findings) };
+  }
+  refresh(sessionId) {
+    this.substrate.raw().prepare(`UPDATE discovery_sessions SET status = 'stale' WHERE id = ?`).run(sessionId);
+    const session = this.getSession(sessionId);
+    if (!session) throw new Error(`Unknown discovery session: ${sessionId}`);
+    return session;
+  }
+  updateCoverage(sessionId) {
+    const coverage = this.coverageFor(this.findings(sessionId));
+    this.substrate.raw().prepare(`UPDATE discovery_sessions SET coverage = ? WHERE id = ?`).run(JSON.stringify(coverage), sessionId);
+  }
+  coverageFor(findings) {
+    return {
+      languages: findings.filter((f) => f.type === "language").length,
+      scripts: findings.filter((f) => f.type === "script").length,
+      entrypoints: findings.filter((f) => f.type === "entrypoint").length,
+      tests: findings.filter((f) => f.type === "test_strategy").length,
+      docs: findings.filter((f) => f.type === "convention").length,
+      queued: findings.filter((f) => f.status === "queued").length,
+      blocked: findings.filter((f) => f.status === "blocked").length,
+      accepted: findings.filter((f) => f.status === "auto_accepted").length
+    };
+  }
+};
+
+// src/services/memory-store.ts
+var fs3 = __toESM(require("fs"), 1);
+var import_nanoid3 = require("nanoid");
+function buildContent(kind, content) {
+  switch (kind) {
+    case "event":
+      return { kind: "event", what: content };
+    case "insight":
+      return { kind: "insight", claim: content, confidence: 0.8 };
+    case "decision":
+      return { kind: "decision", choice: content, rationale: "" };
+    case "entity":
+      return { kind: "entity", name: content, attributes: {} };
+    default:
+      return { kind: "summary", text: content };
+  }
+}
+var MemoryStore = class {
+  constructor(substrate, indexes, router, curator, security = new SecurityScanner(), telemetry) {
+    this.substrate = substrate;
+    this.indexes = indexes;
+    this.router = router;
+    this.curator = curator;
+    this.security = security;
+    this.telemetry = telemetry;
+  }
+  substrate;
+  indexes;
+  router;
+  curator;
+  security;
+  telemetry;
+  async remember(input2) {
+    const scan = this.security.scanText(input2.content);
+    if (scan.blocked) {
+      throw new Error(`Refusing to remember sensitive content: ${scan.reasons.join(", ")}`);
+    }
+    const content = buildContent(input2.kind, scan.redactedText);
+    const entities = await this.curator.extractEntities(content);
+    const importance = await this.curator.scoreImportance(content);
+    const episode = {
+      id: (0, import_nanoid3.nanoid)(),
+      projectId: input2.projectId,
+      content,
+      entities,
+      edges: [],
+      validFrom: /* @__PURE__ */ new Date(),
+      validTo: null,
+      tier: "recall",
+      rir: { recency: 1, importance, relevance: 1 },
+      source: input2.source ?? "user",
+      confidence: input2.confidence ?? 0.8,
+      status: "active",
+      visibility: "local",
+      tags: input2.tags,
+      provenance: {
+        sourceType: input2.sourceType ?? (input2.source === "discovery" ? "discovery" : "mcp"),
+        source: input2.source ?? "user",
+        evidence: input2.evidence
+      },
+      curationReason: "stored through MemoryStore with security scan and curator extraction"
+    };
+    this.substrate.transaction(() => {
+      this.substrate.upsert(episode);
+      this.indexes.indexEpisode(episode);
+    });
+    this.telemetry?.recordMemoryCreated();
+    this.telemetry?.recordSavings(input2.content.length / 4);
+    return episode;
+  }
+  forget(id) {
+    this.substrate.transaction(() => {
+      this.substrate.invalidate(id, /* @__PURE__ */ new Date());
+      this.indexes.removeEpisode(id);
+    });
+    return true;
+  }
+  search(query, limit = 10) {
+    const raw = this.router.search(query, limit);
+    const episodes = this.substrate.listActiveByIds(raw.episodeIds);
+    const activeIds = new Set(episodes.map((ep) => ep.id));
+    this.telemetry?.recordSavings(episodes.length * 500);
+    return {
+      ...raw,
+      episodeIds: raw.episodeIds.filter((id) => activeIds.has(id)),
+      episodes,
+      warnings: []
+    };
+  }
+  listActive() {
+    return this.substrate.listAll();
+  }
+  exportActive(targetPath, stateDir) {
+    if (!this.security.canExportTo(targetPath, stateDir)) {
+      throw new Error("targetPath must be inside the Suture state directory or /tmp");
+    }
+    const episodes = this.substrate.listAllRaw();
+    fs3.writeFileSync(targetPath, JSON.stringify(episodes, null, 2));
+    return episodes.length;
+  }
+  indexCodeFile(filePath, source) {
+    this.indexes.indexCodeFile(filePath, source);
+  }
+};
+
+// src/core/telemetry.ts
+var fs4 = __toESM(require("fs"), 1);
+var import_zod = require("zod");
+var RECENT_LIMIT = 24;
+var CurationActionSchema = import_zod.z.object({
+  at: import_zod.z.string(),
+  action: import_zod.z.string(),
+  detail: import_zod.z.string(),
+  projectId: import_zod.z.string().optional()
+});
+var TelemetryStatsSchema = import_zod.z.object({
+  tokensSaved: import_zod.z.number().default(0),
+  contextRotationsAvoided: import_zod.z.number().default(0),
+  totalInjections: import_zod.z.number().default(0),
+  toolUsage: import_zod.z.record(import_zod.z.string(), import_zod.z.number()).default({}),
+  memoriesCreated: import_zod.z.number().default(0),
+  activeContextTokens: import_zod.z.number().default(0),
+  indexedFiles: import_zod.z.number().default(0),
+  skippedUnchangedFiles: import_zod.z.number().default(0),
+  codeSymbolsIndexed: import_zod.z.number().default(0),
+  projectFactsAccepted: import_zod.z.number().default(0),
+  projectFactsQueued: import_zod.z.number().default(0),
+  projectFactsRejected: import_zod.z.number().default(0),
+  projectFactsStale: import_zod.z.number().default(0),
+  projectFactsSuperseded: import_zod.z.number().default(0),
+  estimatedTokensCached: import_zod.z.number().default(0),
+  estimatedTokensAvoidedFromRereads: import_zod.z.number().default(0),
+  searchHitsServedFromSubstrate: import_zod.z.number().default(0),
+  skippedDuplicateInjections: import_zod.z.number().default(0),
+  recentTokenSavings: import_zod.z.array(import_zod.z.number()).default([]),
+  recentCurationActions: import_zod.z.array(CurationActionSchema).default([]),
+  lastUpdate: import_zod.z.string().default(() => (/* @__PURE__ */ new Date()).toISOString())
+});
+var MODEL_COST_PROFILES = {
+  conservative: 1,
+  standard: 3,
+  premium: 10
+};
+var TelemetryService = class {
+  constructor(statePath) {
+    this.statePath = statePath;
+    this.stats = this.load();
+    if (this.statePath && !fs4.existsSync(this.statePath)) {
+      this.save();
+    }
+  }
+  statePath;
+  stats;
+  load() {
+    if (this.statePath && fs4.existsSync(this.statePath)) {
+      try {
+        const data = JSON.parse(fs4.readFileSync(this.statePath, "utf-8"));
+        return TelemetryStatsSchema.parse(data);
+      } catch (e) {
+        return TelemetryStatsSchema.parse({});
+      }
+    }
+    return TelemetryStatsSchema.parse({});
+  }
+  save() {
+    if (this.statePath) {
+      this.stats.lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+      fs4.writeFileSync(this.statePath, JSON.stringify(this.stats, null, 2));
+    }
+  }
+  recordToolUsage(toolName) {
+    const current = this.stats.toolUsage[toolName] || 0;
+    this.stats.toolUsage[toolName] = current + 1;
+    this.save();
+  }
+  recordSavings(tokens) {
+    const normalized = Math.max(0, Math.round(tokens));
+    this.stats.tokensSaved += normalized;
+    this.stats.recentTokenSavings = [...this.stats.recentTokenSavings, normalized].slice(-RECENT_LIMIT);
+    this.save();
+  }
+  recordMemoryCreated() {
+    this.stats.memoriesCreated += 1;
+    this.save();
+  }
+  recordInjection(tokens) {
+    this.stats.totalInjections += 1;
+    this.stats.activeContextTokens = Math.max(0, Math.round(tokens));
+    this.save();
+  }
+  recordSkippedInjection() {
+    this.stats.skippedDuplicateInjections += 1;
+    this.save();
+  }
+  recordIndexing(summary) {
+    this.stats.indexedFiles += summary.indexedFiles ?? 0;
+    this.stats.skippedUnchangedFiles += summary.skippedFiles ?? 0;
+    this.stats.codeSymbolsIndexed += summary.symbols ?? 0;
+    this.stats.projectFactsAccepted += summary.accepted ?? 0;
+    this.stats.projectFactsQueued += summary.queued ?? 0;
+    this.stats.projectFactsRejected += summary.rejected ?? 0;
+    this.stats.projectFactsStale += summary.stale ?? 0;
+    this.stats.projectFactsSuperseded += summary.superseded ?? 0;
+    this.stats.estimatedTokensCached += Math.max(0, Math.round(summary.tokensCached ?? 0));
+    this.stats.estimatedTokensAvoidedFromRereads += Math.max(0, Math.round(summary.tokensAvoidedFromRereads ?? 0));
+    this.recordSavings((summary.tokensCached ?? 0) + (summary.tokensAvoidedFromRereads ?? 0));
+  }
+  recordSearchHits(count) {
+    this.stats.searchHitsServedFromSubstrate += Math.max(0, Math.round(count));
+    this.save();
+  }
+  recordCurationAction(action) {
+    this.stats.recentCurationActions = [
+      ...this.stats.recentCurationActions,
+      { ...action, at: (/* @__PURE__ */ new Date()).toISOString() }
+    ].slice(-RECENT_LIMIT);
+    this.save();
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  estimateCostSavings(modelProfile = "standard", inputCostPerMillion) {
+    const profileCost = MODEL_COST_PROFILES[modelProfile] ?? MODEL_COST_PROFILES.standard;
+    const cost = inputCostPerMillion ?? profileCost;
+    const estimatedTokens = Math.round(
+      this.stats.estimatedTokensCached + this.stats.estimatedTokensAvoidedFromRereads
+    );
+    return {
+      modelProfile,
+      inputCostPerMillion: cost,
+      estimatedTokens,
+      estimatedUsd: estimatedTokens / 1e6 * cost,
+      formula: `(${estimatedTokens} estimated avoided input tokens / 1,000,000) * $${cost.toFixed(2)}`
+    };
+  }
+};
+
+// src/server/tools.ts
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function makeTools(substrate, gate, router, tierManager, memory, code, fts, services = {}) {
+  const curator = services.curator ?? new SemanticCurator();
+  const security = new SecurityScanner();
+  const indexes = new IndexManager(memory, code, fts);
+  const stateDir = services.stateDir ?? path4.dirname(substrate.raw().name ?? "/tmp");
+  const telemetry = services.telemetry ?? new TelemetryService(path4.join(stateDir, "telemetry.json"));
+  const memoryStore = services.memoryStore ?? new MemoryStore(substrate, indexes, router, curator, security, telemetry);
+  const discovery = services.discovery ?? new DiscoveryEngine(substrate);
+  return [
+    {
+      name: "remember",
+      description: "Store a new memory episode",
+      schema: {
+        content: import_zod2.z.string(),
+        kind: import_zod2.z.enum(["summary", "event", "insight", "decision", "entity"]).default("summary"),
+        source: import_zod2.z.string().optional(),
+        projectId: import_zod2.z.string().optional()
+      },
+      handler: async (args) => {
+        telemetry.recordToolUsage("remember");
+        const episode = await memoryStore.remember({
+          content: args.content,
+          kind: args.kind,
+          source: args.source ?? "user",
+          projectId: args.projectId
+        });
+        const curation = await tierManager.runCuration();
+        indexes.rebuildEpisodes(substrate.listAll());
+        for (const action of curation.actions.slice(-4)) telemetry.recordCurationAction(action);
+        return ok({ id: episode.id });
+      }
+    },
+    {
+      name: "recall",
+      description: "Retrieve the highest-RIR core memory block (\u2264 2 KB). Gated: only returns if core block changed since last injection. Pass isCompaction=true on PreCompact to force re-inject.",
+      schema: {
+        sessionId: import_zod2.z.string().optional(),
+        isCompaction: import_zod2.z.boolean().default(false)
+      },
+      handler: async (args) => {
+        telemetry.recordToolUsage("recall");
+        if (args.isCompaction) gate.forceReinject();
+        const block = tierManager.getCoreBlock();
+        const hash = (0, import_node_crypto.createHash)("sha256").update(block).digest("hex");
+        if (gate.shouldInject(hash)) {
+          gate.markInjected(hash);
+          telemetry.recordInjection(block.length / 4);
+          return ok({ block });
+        }
+        telemetry.recordSkippedInjection();
+        return ok({ block: "" });
+      }
+    },
+    {
+      name: "search",
+      description: "Search across memory graph, code graph, and FTS5 index",
+      schema: {
+        query: import_zod2.z.string(),
+        limit: import_zod2.z.number().int().positive().optional()
+      },
+      handler: async (args) => {
+        telemetry.recordToolUsage("search");
+        const results = memoryStore.search(
+          args.query,
+          args.limit ?? 10
+        );
+        telemetry.recordSearchHits(results.episodeIds.length + results.codeSymbols.length);
+        return ok({ results });
+      }
+    },
+    {
+      name: "suture_stats",
+      description: "Get comprehensive stats on Suture usage, token savings, and agent efficiency metrics",
+      schema: {},
+      handler: async () => ok(telemetry.getStats())
+    },
+    {
+      name: "curate",
+      description: "Trigger a curation cycle: score episodes by RIR and promote, demote, or delete",
+      schema: {},
+      handler: async () => {
+        telemetry.recordToolUsage("curate");
+        const curation = await tierManager.runCuration();
+        indexes.rebuildEpisodes(substrate.listAll());
+        for (const action of curation.actions.slice(-8)) telemetry.recordCurationAction(action);
+        return ok({ ok: true, curation });
+      }
+    },
+    {
+      name: "transfer",
+      description: "Export all active (non-invalidated) episodes to a portable JSON file at the given absolute path",
+      schema: { targetPath: import_zod2.z.string() },
+      handler: async (args) => {
+        telemetry.recordToolUsage("transfer");
+        const targetPath = args.targetPath;
+        if (!path4.isAbsolute(targetPath)) {
+          throw new Error("targetPath must be an absolute path");
+        }
+        const exported = memoryStore.exportActive(targetPath, stateDir);
+        return ok({ exported });
+      }
+    },
+    {
+      name: "forget",
+      description: "Invalidate an active memory and remove it from search indexes",
+      schema: { id: import_zod2.z.string() },
+      handler: async (args) => {
+        telemetry.recordToolUsage("forget");
+        return ok({ ok: memoryStore.forget(args.id) });
+      }
+    },
+    {
+      name: "memory_inspect",
+      description: "List active memories for local review",
+      schema: {
+        limit: import_zod2.z.number().int().positive().optional()
+      },
+      handler: async (args) => {
+        telemetry.recordToolUsage("memory_inspect");
+        const limit = args.limit ?? 50;
+        return ok({ episodes: memoryStore.listActive().slice(0, limit) });
+      }
+    },
+    {
+      name: "discovery_start",
+      description: "Create a secure project discovery session and return setup guidance",
+      schema: {
+        projectPath: import_zod2.z.string(),
+        startedBy: import_zod2.z.string().optional(),
+        projectId: import_zod2.z.string().optional()
+      },
+      handler: async (args) => {
+        telemetry.recordToolUsage("discovery_start");
+        const session = discovery.start(
+          args.projectPath,
+          args.startedBy ?? "agent",
+          args.projectId
+        );
+        return ok({
+          session,
+          resources: [
+            "suture://resources/discovery/schema",
+            "suture://resources/discovery/checklist",
+            "suture://resources/discovery/security-policy"
+          ],
+          ignoredPaths: ["node_modules", "dist", "build", "coverage", ".git", ".next", ".cache", "vendor"],
+          requestedCategories: ["languages", "scripts", "entrypoints", "tests", "docs", "directory roles"]
+        });
+      }
+    },
+    {
+      name: "discovery_scan",
+      description: "Run deterministic local project-map discovery for a session",
+      schema: { sessionId: import_zod2.z.string() },
+      handler: async (args) => {
+        telemetry.recordToolUsage("discovery_scan");
+        return ok({ findings: discovery.scan(args.sessionId) });
+      }
+    },
+    {
+      name: "discovery_submit",
+      description: "Submit one structured agent discovery finding with evidence and confidence",
+      schema: {
+        sessionId: import_zod2.z.string(),
+        type: import_zod2.z.enum([
+          "language",
+          "framework",
+          "package_manager",
+          "script",
+          "command",
+          "entrypoint",
+          "test_strategy",
+          "directory_role",
+          "key_module",
+          "convention",
+          "architecture_note",
+          "decision",
+          "risk",
+          "dependency",
+          "deployment_note"
+        ]),
+        claim: import_zod2.z.string(),
+        payload: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+        evidence: import_zod2.z.array(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())).optional(),
+        confidence: import_zod2.z.number().min(0).max(1).optional(),
+        source: import_zod2.z.string().optional(),
+        freshness: import_zod2.z.enum(["fresh", "unknown", "stale"]).optional()
+      },
+      handler: async (args) => {
+        telemetry.recordToolUsage("discovery_submit");
+        const finding = discovery.submit(args.sessionId, {
+          type: args.type,
+          claim: args.claim,
+          payload: args.payload,
+          evidence: args.evidence,
+          confidence: args.confidence,
+          source: args.source,
+          freshness: args.freshness
+        });
+        return ok({ finding });
+      }
+    },
+    {
+      name: "discovery_status",
+      description: "Report discovery coverage, accepted findings, queued findings, and blocked findings",
+      schema: { sessionId: import_zod2.z.string() },
+      handler: async (args) => {
+        telemetry.recordToolUsage("discovery_status");
+        return ok(discovery.status(args.sessionId));
+      }
+    },
+    {
+      name: "discovery_apply",
+      description: "Apply auto-accepted discovery findings into durable local memory",
+      schema: { sessionId: import_zod2.z.string() },
+      handler: async (args) => {
+        telemetry.recordToolUsage("discovery_apply");
+        const status = discovery.status(args.sessionId);
+        let applied = 0;
+        let skipped = 0;
+        const active = substrate.listAll();
+        const appliedSources = new Set(
+          active.filter((episode) => episode.provenance?.sourceType === "discovery").map((episode) => episode.provenance?.source).filter((source) => Boolean(source))
+        );
+        for (const finding of status.findings) {
+          if (finding.status !== "auto_accepted") continue;
+          const source = `discovery:${finding.id}`;
+          if (appliedSources.has(source)) {
+            skipped++;
+            continue;
+          }
+          await memoryStore.remember({
+            content: finding.claim,
+            kind: "summary",
+            source,
+            sourceType: "discovery",
+            projectId: finding.projectId,
+            evidence: finding.evidence,
+            confidence: finding.confidence,
+            tags: ["discovery", finding.type]
+          });
+          appliedSources.add(source);
+          applied++;
+        }
+        if (applied > 0) {
+          substrate.raw().prepare(`UPDATE discovery_sessions SET status = 'applied' WHERE id = ?`).run(args.sessionId);
+        }
+        const curation = await tierManager.runCuration();
+        indexes.rebuildEpisodes(substrate.listAll());
+        for (const action of curation.actions.slice(-8)) telemetry.recordCurationAction(action);
+        return ok({ applied, skipped });
+      }
+    },
+    {
+      name: "discovery_refresh",
+      description: "Mark a discovery session stale so an agent can refresh project context",
+      schema: { sessionId: import_zod2.z.string() },
+      handler: async (args) => {
+        telemetry.recordToolUsage("discovery_refresh");
+        return ok({ session: discovery.refresh(args.sessionId) });
+      }
+    }
+  ];
+}
+
+// src/server/prompts.ts
+var import_zod3 = require("zod");
+var DISCOVERY_SCHEMA = {
+  type: "object",
+  required: ["type", "claim", "evidence"],
+  properties: {
+    type: {
+      enum: [
+        "language",
+        "framework",
+        "package_manager",
+        "script",
+        "command",
+        "entrypoint",
+        "test_strategy",
+        "directory_role",
+        "key_module",
+        "convention",
+        "architecture_note",
+        "decision",
+        "risk",
+        "dependency",
+        "deployment_note"
+      ]
+    },
+    claim: { type: "string" },
+    payload: { type: "object" },
+    evidence: { type: "array" },
+    confidence: { type: "number", minimum: 0, maximum: 1 },
+    freshness: { enum: ["fresh", "unknown", "stale"] }
+  }
+};
+var DISCOVERY_CHECKLIST = [
+  "Identify languages, frameworks, package manager, and primary scripts.",
+  "Identify entrypoints, top-level directory roles, and test commands.",
+  "Submit only structured JSON findings through discovery_submit.",
+  "Attach file/package/GitHub evidence for every setup fact.",
+  "Do not submit secrets, tokens, .env values, or private keys.",
+  "Queue architecture decisions or undocumented assumptions as lower-confidence findings."
+];
+var DISCOVERY_SECURITY_POLICY = [
+  "Sensitive content is blocked before persistence.",
+  "Low-risk setup facts with evidence may be accepted automatically.",
+  "Architecture claims, risks, and decisions require review or stronger confirmation.",
+  "GitHub ingestion is explicit-only; broad automatic PR/issue ingestion is disabled."
+].join("\n");
+function registerDiscoveryPrompts(server) {
+  server.registerResource(
+    "suture-discovery-schema",
+    "suture://resources/discovery/schema",
+    {
+      title: "Suture Discovery JSON Schema",
+      description: "Strict schema for agent-submitted project discovery findings.",
+      mimeType: "application/json"
+    },
+    (uri) => ({
+      contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(DISCOVERY_SCHEMA, null, 2) }]
+    })
+  );
+  server.registerResource(
+    "suture-discovery-checklist",
+    "suture://resources/discovery/checklist",
+    {
+      title: "Suture Discovery Checklist",
+      description: "Project-map checklist for connected agents.",
+      mimeType: "text/plain"
+    },
+    (uri) => ({
+      contents: [{ uri: uri.href, mimeType: "text/plain", text: DISCOVERY_CHECKLIST.join("\n") }]
+    })
+  );
+  server.registerResource(
+    "suture-discovery-security-policy",
+    "suture://resources/discovery/security-policy",
+    {
+      title: "Suture Discovery Security Policy",
+      description: "Security rules for discovery memory ingestion.",
+      mimeType: "text/plain"
+    },
+    (uri) => ({
+      contents: [{ uri: uri.href, mimeType: "text/plain", text: DISCOVERY_SECURITY_POLICY }]
+    })
+  );
+  server.registerPrompt(
+    "suture_project_map_discovery",
+    {
+      title: "Suture Project Map Discovery",
+      description: "Guide a connected agent to produce secure, evidence-backed project setup findings.",
+      argsSchema: {
+        projectPath: import_zod3.z.string()
+      }
+    },
+    ({ projectPath }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              `Start Suture discovery for project path: ${projectPath}`,
+              "Use discovery_start, discovery_scan, and discovery_submit.",
+              "Submit project-map findings only as strict JSON matching suture://resources/discovery/schema.",
+              "Prefer low-risk setup facts: languages, scripts, entrypoints, tests, docs, directory roles.",
+              "Attach evidence for each claim. Do not submit secrets, tokens, .env values, or private keys."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/core/paths.ts
+var path5 = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+var DEFAULT_STATE_DIR = process.env.SUTURE_STATE_DIR || path5.join(os.homedir(), ".suture");
+function resolveStateDir(explicitPath) {
+  if (explicitPath) return path5.resolve(explicitPath);
+  return DEFAULT_STATE_DIR;
+}
+
+// src/server/mcp.ts
+function createSyncStdout() {
+  return new import_node_stream.Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        if (typeof chunk === "string") {
+          fs5.writeSync(1, chunk);
+        } else {
+          fs5.writeSync(1, Buffer.from(chunk));
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  });
+}
+async function startMcpServer(stateDirInput, io = {}) {
+  const stateDir = resolveStateDir(stateDirInput);
+  fs5.mkdirSync(stateDir, { recursive: true });
+  const substrate = new SqliteSubstrate(path6.join(stateDir, "suture.db"));
+  const gate = new SessionGate(stateDir);
+  const db = substrate.raw();
+  const memory = new MemoryGraph(db);
+  const code = new CodeGraph(db);
+  const fts = new Fts5Index(db);
+  const indexes = new IndexManager(memory, code, fts);
+  const router = new SearchRouter(memory, code, fts);
+  const scorer = new RirScorer();
+  const curator = new SemanticCurator();
+  const tierManager = new TierManager(substrate, scorer, curator, indexes);
+  const server = new import_mcp.McpServer({ name: "suture-mcp", version: "0.1.0" });
+  registerDiscoveryPrompts(server);
+  for (const t of makeTools(substrate, gate, router, tierManager, memory, code, fts, { stateDir, curator })) {
+    server.tool(t.name, t.schema, async (args) => t.handler(args));
+  }
+  const stdin = io.stdin ?? fs5.createReadStream("", { fd: 0, autoClose: false });
+  const stdout = io.stdout ?? createSyncStdout();
+  const transport = new import_stdio.StdioServerTransport(stdin, stdout);
+  await server.connect(transport);
+  stdin.resume();
+  return {
+    close: async () => {
+      await transport.close();
+      substrate.close();
+    }
+  };
+}
+
+// src/services/project-indexer.ts
+var fs6 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+var import_node_crypto2 = require("crypto");
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var LANGUAGE_BY_EXT = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript React",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript React"
+};
+var MANIFEST_NAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "tsconfig.json",
+  "tsup.config.ts",
+  "vite.config.ts",
+  "vitest.config.ts",
+  "next.config.js",
+  "eslint.config.js"
+]);
+var SECRET_FILE_PATTERN = /(^|\/)(\.env|\.env\..*|.*\.pem|.*\.key)$/i;
+var LOCAL_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+  ".agents",
+  ".codex",
+  ".suture",
+  ".suture-data",
+  ".suture-index-test",
+  "--dir",
+  "archive"
+]);
+var MAX_INDEX_FILES = 500;
+var MAX_CODE_FILE_BYTES = 5e5;
+function slug(value) {
+  return value.replace(/[^A-Za-z0-9_.-]/g, "-").replace(/^-+|-+$/g, "") || "project";
+}
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function hashText(text) {
+  return (0, import_node_crypto2.createHash)("sha256").update(text).digest("hex");
+}
+function isLocalOnlyDirectory(name) {
+  return name.startsWith(".") || LOCAL_DIRECTORY_NAMES.has(name);
+}
+function safeReadJson(filePath) {
+  try {
+    return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readGitRemote(root) {
+  const configPath = path7.join(root, ".git", "config");
+  if (!fs6.existsSync(configPath)) return void 0;
+  const config = fs6.readFileSync(configPath, "utf-8");
+  const match = config.match(/\[remote "origin"\][\s\S]*?\n\s*url\s*=\s*(.+)/);
+  return match?.[1]?.trim();
+}
+function readPackageName(pkg) {
+  if (pkg && typeof pkg === "object" && "name" in pkg && typeof pkg.name === "string") {
+    return pkg.name;
+  }
+  return void 0;
+}
+function buildIdentity(root, pkg) {
+  const packageName = readPackageName(pkg);
+  const gitRemote = readGitRemote(root);
+  const basis = [
+    gitRemote ? `git:${gitRemote}` : null,
+    packageName ? `package:${packageName}` : null,
+    gitRemote || packageName ? null : `path:${fs6.realpathSync(root)}`
+  ].filter((item) => Boolean(item));
+  return {
+    packageName,
+    gitRemote,
+    rootPath: root,
+    basis
+  };
+}
+function fingerprintFor(identity) {
+  return hashText(identity.basis.join("\n"));
+}
+function projectIdFor2(rootPath, identity, fingerprint) {
+  const base = identity.packageName ?? path7.basename(path7.resolve(rootPath));
+  return `${slug(base)}-${fingerprint.slice(0, 8)}`;
+}
+var ProjectIndexer = class {
+  constructor(substrate, memoryStore, codeGraph, tierManager, telemetry, security = new SecurityScanner()) {
+    this.substrate = substrate;
+    this.memoryStore = memoryStore;
+    this.codeGraph = codeGraph;
+    this.tierManager = tierManager;
+    this.telemetry = telemetry;
+    this.security = security;
+  }
+  substrate;
+  memoryStore;
+  codeGraph;
+  tierManager;
+  telemetry;
+  security;
+  preview(projectPath) {
+    const root = path7.resolve(projectPath);
+    if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) {
+      throw new Error(`Project path must be an existing directory: ${root}`);
+    }
+    const ignoredPaths = [];
+    const manifestFiles = [];
+    const codeFiles = [];
+    const languages = /* @__PURE__ */ new Set();
+    const topDirs = /* @__PURE__ */ new Set();
+    let docs = 0;
+    let tests = 0;
+    const walk = (dir, depth) => {
+      if (depth > 4 || codeFiles.length + manifestFiles.length >= MAX_INDEX_FILES) return;
+      const entries = fs6.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const full = path7.join(dir, entry.name);
+        const rel = path7.relative(root, full) || entry.name;
+        const normalizedRel = rel.replace(/\\/g, "/");
+        if (entry.isDirectory() && isLocalOnlyDirectory(entry.name)) {
+          ignoredPaths.push(normalizedRel);
+          continue;
+        }
+        if (this.security.isIgnoredPath(normalizedRel) || SECRET_FILE_PATTERN.test(normalizedRel)) {
+          ignoredPaths.push(normalizedRel);
+          continue;
+        }
+        if (entry.isDirectory()) {
+          if (depth === 0) topDirs.add(entry.name);
+          if (/test|spec/i.test(entry.name)) tests++;
+          walk(full, depth + 1);
+          continue;
+        }
+        const ext = path7.extname(entry.name);
+        if (LANGUAGE_BY_EXT[ext]) languages.add(LANGUAGE_BY_EXT[ext]);
+        if (MANIFEST_NAMES.has(entry.name)) manifestFiles.push(full);
+        if (CODE_EXTENSIONS.has(ext)) {
+          const size = fs6.statSync(full).size;
+          if (size <= MAX_CODE_FILE_BYTES) codeFiles.push(full);
+        }
+        if (ext === ".md") docs++;
+        if (/(\.test|\.spec)\.[tj]sx?$|test_/i.test(entry.name)) tests++;
+      }
+    };
+    walk(root, 0);
+    const packagePath = path7.join(root, "package.json");
+    const pkg = safeReadJson(packagePath);
+    const identity = buildIdentity(root, pkg);
+    const fingerprint = fingerprintFor(identity);
+    const existingIndex = this.getExistingIndex(fingerprint, root);
+    const projectId = existingIndex?.projectId ?? projectIdFor2(root, identity, fingerprint);
+    const findings = [];
+    for (const language of languages) {
+      findings.push({
+        type: "language",
+        claim: `Project uses ${language}`,
+        payload: { language },
+        evidence: [{ kind: "file", path: root }],
+        source: "indexer"
+      });
+    }
+    if (pkg) {
+      findings.push({
+        type: "package_manager",
+        claim: "Project has a package.json and uses the Node package ecosystem",
+        payload: { packageManager: fs6.existsSync(path7.join(root, "package-lock.json")) ? "npm" : "node" },
+        evidence: [{ kind: "package", path: packagePath, key: "name" }],
+        source: "indexer"
+      });
+      for (const [name, command] of Object.entries(pkg.scripts ?? {})) {
+        findings.push({
+          type: "script",
+          claim: `npm script ${name}: ${command}`,
+          payload: { name, command },
+          evidence: [{ kind: "package", path: packagePath, key: `scripts.${name}` }],
+          source: "indexer"
+        });
+      }
+      if (pkg.main) {
+        findings.push({
+          type: "entrypoint",
+          claim: `Package main entrypoint is ${pkg.main}`,
+          payload: { main: pkg.main },
+          evidence: [{ kind: "package", path: packagePath, key: "main" }],
+          source: "indexer"
+        });
+      }
+      const dependencies = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} }).slice(0, 12);
+      for (const dependency of dependencies) {
+        findings.push({
+          type: "dependency",
+          claim: `Project depends on ${dependency}`,
+          payload: { dependency },
+          evidence: [{ kind: "package", path: packagePath, key: `dependencies.${dependency}` }],
+          source: "indexer"
+        });
+      }
+    }
+    for (const dir of Array.from(topDirs).slice(0, 20)) {
+      findings.push({
+        type: "directory_role",
+        claim: `Top-level project directory: ${dir}`,
+        payload: { directory: dir },
+        evidence: [{ kind: "file", path: path7.join(root, dir) }],
+        source: "indexer"
+      });
+    }
+    if (tests > 0) {
+      findings.push({
+        type: "test_strategy",
+        claim: `Project has ${tests} visible test-related files or directories`,
+        payload: { count: tests },
+        evidence: [{ kind: "file", path: root }],
+        source: "indexer"
+      });
+    }
+    if (docs > 0) {
+      findings.push({
+        type: "convention",
+        claim: `Project has ${docs} documentation files available as evidence but does not generate markdown memory files`,
+        payload: { count: docs, rawMarkdownIngested: false },
+        evidence: [{ kind: "file", path: root }],
+        source: "indexer"
+      });
+    }
+    return {
+      projectId,
+      fingerprint,
+      identity,
+      existingIndex,
+      projectPath: root,
+      scanPatterns: ["package/config manifests", "project structure", "test signals", "TypeScript/JavaScript symbols"],
+      ignoredPaths: Array.from(new Set(ignoredPaths)).slice(0, 40),
+      manifestFiles,
+      codeFiles,
+      findings,
+      estimatedTokensToCache: findings.reduce((total, finding) => total + estimateTokens(finding.claim), 0),
+      estimatedTokensAvoidedFromRereads: 0
+    };
+  }
+  async apply(projectPath, options = {}) {
+    const plan = this.preview(projectPath);
+    const discovery = new DiscoveryEngine(this.substrate);
+    const session = discovery.start(plan.projectPath, "suture-indexer", plan.projectId);
+    const enabledIndexes = options.enabledFindingIndexes ? new Set(options.enabledFindingIndexes) : null;
+    const selectedFindings = enabledIndexes ? plan.findings.filter((_, index) => enabledIndexes.has(index)) : plan.findings;
+    const findings = selectedFindings.map((finding) => discovery.submit(session.id, finding));
+    const acceptedFindings = findings.filter((finding) => finding.status === "auto_accepted");
+    let applied = 0;
+    let skippedDuplicateFacts = 0;
+    for (const finding of acceptedFindings) {
+      if (this.hasExistingFact(plan.projectId, finding.claim)) {
+        skippedDuplicateFacts++;
+        continue;
+      }
+      await this.memoryStore.remember({
+        content: finding.claim,
+        kind: "summary",
+        source: `project-index:${finding.id}`,
+        sourceType: "discovery",
+        projectId: plan.projectId,
+        evidence: finding.evidence,
+        confidence: finding.confidence,
+        tags: ["project-index", finding.type]
+      });
+      applied++;
+    }
+    let indexedFiles = 0;
+    let skippedFiles = 0;
+    let codeSymbolsIndexed = 0;
+    let estimatedTokensAvoidedFromRereads = 0;
+    for (const filePath of plan.codeFiles) {
+      const source = fs6.readFileSync(filePath, "utf-8");
+      const hash = hashText(source);
+      const rel = path7.relative(plan.projectPath, filePath).replace(/\\/g, "/");
+      const previous = this.substrate.raw().prepare(`SELECT hash, estimatedTokens FROM project_index_files WHERE projectId = ? AND filePath = ?`).get(plan.projectId, rel);
+      if (previous?.hash === hash) {
+        skippedFiles++;
+        estimatedTokensAvoidedFromRereads += previous.estimatedTokens;
+        continue;
+      }
+      this.memoryStore.indexCodeFile(rel, source);
+      const symbols = this.codeGraph.countSymbolsForFile(rel);
+      const estimatedTokens = estimateTokens(source);
+      this.substrate.raw().prepare(
+        `INSERT OR REPLACE INTO project_index_files(projectId, filePath, hash, kind, indexedAt, estimatedTokens)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(plan.projectId, rel, hash, "code", Date.now(), estimatedTokens);
+      indexedFiles++;
+      codeSymbolsIndexed += symbols;
+    }
+    const totalIndexedFiles = this.substrate.raw().prepare(`SELECT COUNT(*) AS count FROM project_index_files WHERE projectId = ?`).get(plan.projectId).count;
+    this.recordProjectIndex(
+      plan,
+      totalIndexedFiles,
+      codeSymbolsIndexed > 0 ? codeSymbolsIndexed : plan.existingIndex?.codeSymbols ?? 0
+    );
+    const curation = await this.tierManager.runCuration();
+    const queued = findings.filter((finding) => finding.status === "queued").length;
+    const blocked = findings.filter((finding) => finding.status === "blocked").length;
+    const estimatedTokensCached = plan.estimatedTokensToCache + codeSymbolsIndexed * 5;
+    this.telemetry?.recordIndexing({
+      indexedFiles,
+      skippedFiles,
+      symbols: codeSymbolsIndexed,
+      accepted: acceptedFindings.length,
+      queued,
+      rejected: blocked,
+      tokensCached: estimatedTokensCached,
+      tokensAvoidedFromRereads: estimatedTokensAvoidedFromRereads
+    });
+    for (const action of curation.actions.slice(-8)) {
+      this.telemetry?.recordCurationAction(action);
+    }
+    return {
+      projectId: plan.projectId,
+      fingerprint: plan.fingerprint,
+      existingIndex: plan.existingIndex,
+      projectPath: plan.projectPath,
+      sessionId: session.id,
+      accepted: acceptedFindings.length,
+      queued,
+      blocked,
+      applied,
+      skippedDuplicateFacts,
+      indexedFiles,
+      skippedFiles,
+      codeSymbolsIndexed,
+      estimatedTokensCached,
+      estimatedTokensAvoidedFromRereads,
+      curationActions: curation.actions.length,
+      findings
+    };
+  }
+  hasExistingFact(projectId, claim) {
+    return this.substrate.listAll().some((episode) => {
+      if (episode.projectId !== projectId) return false;
+      return episode.content.kind === "summary" && episode.content.text === claim;
+    });
+  }
+  getExistingIndex(fingerprint, rootPath) {
+    const row = this.substrate.raw().prepare(`SELECT * FROM project_index_projects WHERE fingerprint = ?`).get(fingerprint);
+    if (!row) return null;
+    return {
+      projectId: row.projectId,
+      fingerprint: row.fingerprint,
+      rootPath: row.rootPath,
+      packageName: row.packageName ?? void 0,
+      gitRemote: row.gitRemote ?? void 0,
+      indexedFiles: row.indexedFiles,
+      codeSymbols: row.codeSymbols,
+      lastIndexedAt: new Date(row.lastIndexedAt).toISOString(),
+      sameRoot: path7.resolve(row.rootPath) === path7.resolve(rootPath)
+    };
+  }
+  recordProjectIndex(plan, indexedFiles, codeSymbols) {
+    const now = Date.now();
+    const existing = this.getExistingIndex(plan.fingerprint, plan.projectPath);
+    this.substrate.raw().prepare(
+      `INSERT INTO project_index_projects(
+        projectId, fingerprint, rootPath, packageName, gitRemote, firstIndexedAt, lastIndexedAt, indexedFiles, codeSymbols
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(projectId) DO UPDATE SET
+        fingerprint = excluded.fingerprint,
+        rootPath = excluded.rootPath,
+        packageName = excluded.packageName,
+        gitRemote = excluded.gitRemote,
+        lastIndexedAt = excluded.lastIndexedAt,
+        indexedFiles = excluded.indexedFiles,
+        codeSymbols = excluded.codeSymbols`
+    ).run(
+      plan.projectId,
+      plan.fingerprint,
+      plan.projectPath,
+      plan.identity.packageName ?? null,
+      plan.identity.gitRemote ?? null,
+      existing ? new Date(existing.lastIndexedAt).getTime() : now,
+      now,
+      indexedFiles,
+      codeSymbols
+    );
+  }
+};
+
+// src/hooks/service.ts
+var fs7 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+var import_node_crypto3 = require("crypto");
+function projectIdFor3(rootPath) {
+  return path8.basename(path8.resolve(rootPath)).replace(/[^A-Za-z0-9_.-]/g, "-") || "project";
+}
+function hashContent(content) {
+  return (0, import_node_crypto3.createHash)("sha256").update(content).digest("hex");
+}
+function setupSignal(projectId, projectPath) {
+  return [
+    "<suture-setup>",
+    `Project: ${projectId}`,
+    `Path: ${path8.resolve(projectPath)}`,
+    "Suture has no accepted project-map memory for this project yet.",
+    "Use the Suture MCP discovery tools in this order:",
+    "1. discovery_start with this project path",
+    "2. discovery_scan for deterministic setup facts",
+    "3. discovery_submit for structured, evidence-backed agent findings",
+    "4. discovery_apply to persist accepted low-risk findings",
+    "Do not submit secrets, tokens, .env values, private keys, or sensitive personal data.",
+    "</suture-setup>"
+  ].join("\n");
+}
+var HookService = class {
+  constructor(substrate, tierManager, memoryStore) {
+    this.substrate = substrate;
+    this.tierManager = tierManager;
+    this.memoryStore = memoryStore;
+  }
+  substrate;
+  tierManager;
+  memoryStore;
+  decideSessionStart(input2) {
+    const projectId = projectIdFor3(input2.projectPath);
+    const client = input2.client ?? "claude-code";
+    const budget = input2.budget ?? 2048;
+    const acceptedFindings = this.acceptedFindings(projectId);
+    const coreBlock = this.tierManager.getCoreBlock();
+    const force = this.hasReinjectFlag(projectId, input2.sessionId, client);
+    let content = "";
+    let kind = "skip_empty";
+    let reason = "no core memory or accepted discovery findings";
+    if (coreBlock || acceptedFindings.length > 0) {
+      content = this.memoryBlock(projectId, coreBlock, acceptedFindings, budget);
+      kind = "inject_memory";
+      reason = force ? "forced by compaction reinjection flag" : "core memory or accepted discovery findings changed";
+    } else {
+      content = setupSignal(projectId, input2.projectPath).slice(0, budget);
+      kind = "inject_setup_signal";
+      reason = "first-run setup signal";
+    }
+    const hash = hashContent(content);
+    const previous = this.lastHash(projectId, input2.sessionId, client, "SessionStart");
+    if (!force && previous === hash) {
+      return {
+        kind: "skip_unchanged",
+        projectId,
+        sessionId: input2.sessionId,
+        client,
+        hash,
+        content: "",
+        reason: "unchanged hook context hash already injected for this session",
+        forced: false
+      };
+    }
+    if (!content) {
+      return { kind: "skip_empty", projectId, sessionId: input2.sessionId, client, hash, content, reason, forced: force };
+    }
+    this.recordInjection(projectId, input2.sessionId, client, "SessionStart", hash, kind, reason);
+    if (force) this.consumeReinjectFlag(projectId, input2.sessionId, client);
+    return { kind, projectId, sessionId: input2.sessionId, client, hash, content, reason, forced: force };
+  }
+  preCompact(input2) {
+    const projectId = projectIdFor3(input2.projectPath);
+    const client = input2.client ?? "claude-code";
+    this.substrate.raw().prepare(
+      `INSERT OR REPLACE INTO hook_reinject_flags(projectId, sessionId, client, source, reason, createdAt, consumedAt)
+       VALUES (?, ?, ?, ?, ?, ?, NULL)`
+    ).run(projectId, input2.sessionId, client, "hook:pre-compact", "force next SessionStart memory injection", Date.now());
+    return { projectId, sessionId: input2.sessionId, client, flagged: true };
+  }
+  async postCompact(input2) {
+    const projectId = projectIdFor3(input2.projectPath);
+    const client = input2.client ?? "claude-code";
+    const summary = input2.summary ?? (input2.summaryFile ? fs7.readFileSync(input2.summaryFile, "utf-8") : "");
+    if (summary.trim()) {
+      await this.memoryStore.remember({
+        content: summary.trim(),
+        kind: "summary",
+        source: "hook:post-compact",
+        projectId,
+        tags: ["hook", "compact"],
+        confidence: 0.75
+      });
+    }
+    this.preCompact({ ...input2, client });
+    return { projectId, sessionId: input2.sessionId, client, stored: Boolean(summary.trim()) };
+  }
+  status(input2) {
+    const projectId = projectIdFor3(input2.projectPath);
+    const client = input2.client ?? "claude-code";
+    return {
+      projectId,
+      sessionId: input2.sessionId,
+      client,
+      lastHash: this.lastHash(projectId, input2.sessionId, client, "SessionStart"),
+      reinjectPending: this.hasReinjectFlag(projectId, input2.sessionId, client),
+      acceptedFindings: this.acceptedFindings(projectId).length
+    };
+  }
+  formatDecision(decision, format = "claude-json") {
+    if (format === "text") {
+      return decision.content ? `${decision.content}
+` : "";
+    }
+    if (format === "json") {
+      return JSON.stringify(decision);
+    }
+    const output2 = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart"
+      }
+    };
+    if (decision.content) {
+      output2.hookSpecificOutput.additionalContext = decision.content;
+    }
+    return JSON.stringify(output2);
+  }
+  memoryBlock(projectId, coreBlock, findings, budget) {
+    const lines = ["<suture-memory>", `Project: ${projectId}`];
+    if (coreBlock) {
+      lines.push("", "Core memory:", coreBlock.trim());
+    }
+    if (findings.length > 0) {
+      lines.push("", "Accepted project-map findings:");
+      for (const finding of findings) lines.push(`- ${finding}`);
+    }
+    lines.push("</suture-memory>");
+    const block = lines.join("\n");
+    return block.length <= budget ? block : `${block.slice(0, Math.max(0, budget - 32))}
+</suture-memory>`;
+  }
+  acceptedFindings(projectId) {
+    const rows = this.substrate.raw().prepare(
+      `SELECT claim FROM discovery_findings WHERE projectId = ? AND status = 'auto_accepted' ORDER BY createdAt ASC LIMIT 20`
+    ).all(projectId);
+    return rows.map((row) => row.claim);
+  }
+  lastHash(projectId, sessionId, client, event) {
+    const row = this.substrate.raw().prepare(
+      `SELECT lastHash FROM hook_injection_ledger WHERE projectId = ? AND sessionId = ? AND client = ? AND event = ?`
+    ).get(projectId, sessionId, client, event);
+    return row?.lastHash ?? null;
+  }
+  recordInjection(projectId, sessionId, client, event, hash, source, reason) {
+    this.substrate.raw().prepare(
+      `INSERT OR REPLACE INTO hook_injection_ledger(
+        projectId, sessionId, client, event, lastHash, lastInjectedAt, source, reason
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(projectId, sessionId, client, event, hash, Date.now(), source, reason);
+  }
+  hasReinjectFlag(projectId, sessionId, client) {
+    const row = this.substrate.raw().prepare(
+      `SELECT createdAt FROM hook_reinject_flags
+       WHERE projectId = ? AND sessionId = ? AND client = ? AND consumedAt IS NULL`
+    ).get(projectId, sessionId, client);
+    return Boolean(row);
+  }
+  consumeReinjectFlag(projectId, sessionId, client) {
+    this.substrate.raw().prepare(
+      `UPDATE hook_reinject_flags SET consumedAt = ? WHERE projectId = ? AND sessionId = ? AND client = ? AND consumedAt IS NULL`
+    ).run(Date.now(), projectId, sessionId, client);
+  }
+};
+
+// src/cli/ascii.ts
+var DEFAULT_WIDTH = 78;
+function clampWidth(width) {
+  return Math.max(48, Math.min(width ?? DEFAULT_WIDTH, 120));
+}
+function line(char, width) {
+  return char.repeat(Math.max(0, width));
+}
+function pad(text, width) {
+  const clipped = text.length > width ? text.slice(0, Math.max(0, width - 1)) + "." : text;
+  return clipped + " ".repeat(Math.max(0, width - clipped.length));
+}
+function box(title, rows, width = DEFAULT_WIDTH) {
+  const w = clampWidth(width);
+  const inner = w - 4;
+  const header = `+${line("-", w - 2)}+`;
+  const titleRow = `| ${pad(title, inner)} |`;
+  const body = rows.map((row) => `| ${pad(row, inner)} |`);
+  return [header, titleRow, header, ...body, header].join("\n");
+}
+function progressBar(value, max, width = 24) {
+  const normalizedMax = Math.max(1, max);
+  const pct = Math.max(0, Math.min(1, value / normalizedMax));
+  const filled = Math.round(pct * width);
+  return `[${"#".repeat(filled)}${".".repeat(width - filled)}] ${(pct * 100).toFixed(0)}%`;
+}
+function sparkline(values, width = 24) {
+  if (values.length === 0) return ".".repeat(width);
+  const recent = values.slice(-width);
+  const max = Math.max(...recent, 1);
+  return recent.map((value) => {
+    const pct = value / max;
+    if (pct > 0.8) return "#";
+    if (pct > 0.45) return "+";
+    if (pct > 0.1) return "-";
+    return ".";
+  }).join("").padStart(width, ".");
+}
+function renderSetupWelcome(stateDir, projectPath, width = DEFAULT_WIDTH) {
+  return box("Suture MCP setup", [
+    "[ok] terminal-first local memory substrate",
+    `[ok] state dir: ${stateDir}`,
+    `[ok] project:   ${projectPath}`,
+    "[..] checking SQLite, FTS5, tree-sitter, and MCP command wiring"
+  ], width);
+}
+function renderIndexPlan(plan, width = DEFAULT_WIDTH) {
+  const rows = [
+    `Project id: ${plan.projectId}`,
+    `Fingerprint: ${plan.fingerprint.slice(0, 12)}`,
+    `Identity:   ${plan.identity.basis.join(" + ")}`,
+    ...plan.existingIndex ? [
+      "",
+      "Existing substrate:",
+      `  ${plan.existingIndex.sameRoot ? "reuse same project" : "reuse matching fingerprint"}`,
+      `  ${plan.existingIndex.indexedFiles} files, ${plan.existingIndex.codeSymbols} symbols`,
+      `  last indexed: ${plan.existingIndex.lastIndexedAt}`
+    ] : ["Existing substrate: none found"],
+    `Manifests:  ${plan.manifestFiles.length}`,
+    `Code files: ${plan.codeFiles.length}`,
+    `Findings:   ${plan.findings.length}`,
+    `Ignored:    ${plan.ignoredPaths.length}`,
+    `Cache estimate: ${plan.estimatedTokensToCache.toLocaleString()} tokens`,
+    "",
+    "Scan scope:",
+    ...plan.scanPatterns.slice(0, 5).map((item) => `  + ${item}`),
+    "",
+    "Ignored examples:",
+    ...plan.ignoredPaths.length ? plan.ignoredPaths.slice(0, 5).map((item) => `  - ${item}`) : ["  - none found"],
+    "",
+    "Findings preview:",
+    ...plan.findings.length ? plan.findings.slice(0, 8).map((finding) => `  [${finding.type}] ${finding.claim}`) : ["  - none"]
+  ];
+  return box("Index preview", rows, width);
+}
+function renderIndexResult(result, width = DEFAULT_WIDTH) {
+  return box("Index applied", [
+    `Project id:      ${result.projectId}`,
+    `Fingerprint:     ${result.fingerprint.slice(0, 12)}`,
+    result.existingIndex ? `Substrate:       reused existing ${result.existingIndex.sameRoot ? "project" : "fingerprint"}` : "Substrate:       created new project substrate",
+    `Accepted facts:  ${result.accepted} (${result.applied} new, ${result.skippedDuplicateFacts} duplicate)`,
+    `Queued facts:    ${result.queued}`,
+    `Blocked facts:   ${result.blocked}`,
+    `Files indexed:   ${result.indexedFiles}`,
+    `Files skipped:   ${result.skippedFiles}`,
+    `Code symbols:    ${result.codeSymbolsIndexed}`,
+    `Tokens cached:   ~${result.estimatedTokensCached.toLocaleString()}`,
+    `Reread avoided:  ~${result.estimatedTokensAvoidedFromRereads.toLocaleString()} tokens`,
+    `Curation events: ${result.curationActions}`
+  ], width);
+}
+function renderStatsDashboard(stats, cost, width = DEFAULT_WIDTH) {
+  const coreBudget = progressBar(stats.activeContextTokens, 2048);
+  const rows = [
+    `Estimated token savings: ${Math.round(stats.tokensSaved).toLocaleString()} (local estimate)`,
+    `Savings sparkline:       ${sparkline(stats.recentTokenSavings)}`,
+    `Estimated cost saved:    $${cost.estimatedUsd.toFixed(4)} (${cost.modelProfile})`,
+    `Formula: ${cost.formula}`,
+    "",
+    `Core block budget:       ${coreBudget} ${stats.activeContextTokens.toLocaleString()} / 2,048`,
+    `Recall injections:       ${stats.totalInjections}`,
+    `Duplicate injections skipped: ${stats.skippedDuplicateInjections}`,
+    `Search hits from substrate:   ${stats.searchHitsServedFromSubstrate}`,
+    "",
+    `Indexed files:           ${stats.indexedFiles}`,
+    `Skipped unchanged files: ${stats.skippedUnchangedFiles}`,
+    `Code symbols indexed:    ${stats.codeSymbolsIndexed}`,
+    `Accepted project facts:  ${stats.projectFactsAccepted}`,
+    `Queued project facts:    ${stats.projectFactsQueued}`,
+    `Rejected/blocked facts:  ${stats.projectFactsRejected}`,
+    `Avoided reread tokens:   ~${stats.estimatedTokensAvoidedFromRereads.toLocaleString()}`,
+    "",
+    "Recent curation:",
+    ...stats.recentCurationActions.length ? stats.recentCurationActions.slice(-6).map((action) => `  ${action.action}: ${action.detail}`) : ["  none yet"]
+  ];
+  return box("Suture value dashboard", rows, width);
+}
+function renderSetupSuccess(result, stats, cost, width = DEFAULT_WIDTH, selfTest) {
+  const selfTestRows = selfTest ? [
+    selfTest.ok ? `[ok] MCP stdio self-test passed (${selfTest.tools} tools)` : `[!!] MCP stdio self-test failed: ${selfTest.error ?? "unknown error"}`,
+    "[ok] MCP server config generated",
+    "[ok] First project index complete",
+    "[ok] First value dashboard ready"
+  ] : [
+    "[ok] MCP server config generated",
+    "[ok] First project index complete",
+    "[ok] First value dashboard ready"
+  ];
+  return [
+    renderIndexResult(result, width),
+    "",
+    box("Install checks", selfTestRows, width),
+    "",
+    renderStatsDashboard(stats, cost, width),
+    "",
+    box("Next steps", [
+      "1. Add the printed MCP config to your agent.",
+      "2. Ask the agent to search Suture before rereading large files.",
+      "3. Run `suture-mcp stats` to see value accumulate."
+    ], width)
+  ].join("\n");
+}
+
+// src/cli/tui.ts
+var readline = __toESM(require("readline"), 1);
+function confidenceMarker(plan, index) {
+  const finding = plan.findings[index];
+  if (!finding) return " ";
+  if (!finding.evidence?.length) return "!";
+  if (finding.type === "convention" || (finding.confidence ?? 1) < 0.6) return "~";
+  return "+";
+}
+function renderFindingPicker(plan, state, width = 78) {
+  const selectedCount = state.selected.filter(Boolean).length;
+  const start = Math.max(0, Math.min(state.cursor - 6, Math.max(0, plan.findings.length - 12)));
+  const visible = plan.findings.slice(start, start + 12);
+  const rows = [
+    `Select durable project facts: ${selectedCount}/${plan.findings.length}`,
+    "Keys: up/down move  space toggle  a all  n none  enter apply  q cancel",
+    "Confidence: + evidence-backed  ~ review/queued  ! no evidence",
+    "",
+    ...visible.map((finding, offset) => {
+      const index = start + offset;
+      const cursor = index === state.cursor ? ">" : " ";
+      const check = state.selected[index] ? "x" : " ";
+      const confidence = confidenceMarker(plan, index);
+      return `${cursor} [${check}] ${confidence} ${finding.type}: ${finding.claim}`;
+    })
+  ];
+  return box("Index curation", rows, width);
+}
+async function pickFindings(plan, width = 78) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || !process.stdin.setRawMode) {
+    return plan.findings.map((_, index) => index);
+  }
+  const state = {
+    cursor: 0,
+    selected: plan.findings.map(() => true)
+  };
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  const render = () => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(`${renderFindingPicker(plan, state, width)}
+`);
+  };
+  try {
+    render();
+    return await new Promise((resolve7) => {
+      const cleanup = () => {
+        process.stdin.off("keypress", onKeypress);
+        process.stdin.setRawMode(false);
+      };
+      const finish = (value) => {
+        cleanup();
+        process.stdout.write("\n");
+        resolve7(value);
+      };
+      const onKeypress = (_str, key) => {
+        if (key.name === "up" || key.name === "k") {
+          state.cursor = Math.max(0, state.cursor - 1);
+          render();
+          return;
+        }
+        if (key.name === "down" || key.name === "j") {
+          state.cursor = Math.min(plan.findings.length - 1, state.cursor + 1);
+          render();
+          return;
+        }
+        if (key.name === "space") {
+          state.selected[state.cursor] = !state.selected[state.cursor];
+          render();
+          return;
+        }
+        if (key.name === "a") {
+          state.selected = state.selected.map(() => true);
+          render();
+          return;
+        }
+        if (key.name === "n") {
+          state.selected = state.selected.map(() => false);
+          render();
+          return;
+        }
+        if (key.name === "return") {
+          finish(state.selected.flatMap((selected, index) => selected ? [index] : []));
+          return;
+        }
+        if (key.name === "escape" || key.name === "q" || key.ctrl && key.name === "c") {
+          finish(null);
+        }
+      };
+      process.stdin.on("keypress", onKeypress);
+    });
+  } catch (error) {
+    process.stdin.setRawMode(false);
+    throw error;
+  }
+}
+
+// src/cli.ts
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith("--")) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function positional(args) {
+  const values = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      if (args[i + 1] && !args[i + 1].startsWith("--")) i++;
+      continue;
+    }
+    values.push(arg);
+  }
+  return values;
+}
+function terminalWidth() {
+  return process.stdout.columns ? Math.min(process.stdout.columns, 100) : 78;
+}
+function ensureStateDir(dir) {
+  if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+}
+function createRuntime(stateDir) {
+  ensureStateDir(stateDir);
+  const substrate = new SqliteSubstrate(path9.join(stateDir, "suture.db"));
+  const db = substrate.raw();
+  const memory = new MemoryGraph(db);
+  const code = new CodeGraph(db);
+  const fts = new Fts5Index(db);
+  const indexes = new IndexManager(memory, code, fts);
+  const router = new SearchRouter(memory, code, fts);
+  const curator = new SemanticCurator();
+  const tierManager = new TierManager(substrate, new RirScorer(), curator, indexes);
+  const telemetry = new TelemetryService(path9.join(stateDir, "telemetry.json"));
+  const memoryStore = new MemoryStore(substrate, indexes, router, curator, void 0, telemetry);
+  return { substrate, telemetry, tierManager, memoryStore, code };
+}
+function printUsage(exitCode = 0) {
+  const usage = [
+    "Usage: suture-mcp <command> [options]",
+    "",
+    "Commands:",
+    "  setup [--project <path>] [--dir <state>] [--yes] [--json]",
+    "  init [--dir <state>]",
+    "  serve [--dir <state>]",
+    "  doctor [--dir <state>] [--json]",
+    "  index <project> [--dir <state>] [--apply-safe] [--json]",
+    "  hook session-start|pre-compact|post-compact|status --project <path> --session <id> [--client <name>]",
+    "  stats [--dir <state>] [--json] [--model-profile conservative|standard|premium]",
+    "  recall [--dir <state>]",
+    "",
+    "Beta defaults: local SQLite, no markdown memory files, safe opt-in indexing."
+  ].join("\n");
+  process.stdout.write(`${usage}
+`);
+  process.exit(exitCode);
+}
+function mcpConfig(command = "suture-mcp", stateDir) {
+  return JSON.stringify({
+    mcpServers: {
+      suture: {
+        command,
+        args: ["serve", "--dir", stateDir]
+      }
+    }
+  }, null, 2);
+}
+async function runMcpSelfTest(stateDir) {
+  return await new Promise((resolve7) => {
+    const clientInput = new import_node_stream2.PassThrough();
+    const serverOutput = new import_node_stream2.PassThrough();
+    let stdout = "";
+    let settled = false;
+    let initialized = false;
+    let handle = null;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clientInput.destroy();
+      serverOutput.destroy();
+      void handle?.close();
+      resolve7(result);
+    };
+    const send = (message) => {
+      clientInput.write(`${JSON.stringify(message)}
+`);
+    };
+    const handleLine = (line2) => {
+      if (!line2.trim()) return;
+      const message = JSON.parse(line2);
+      if (message.error) {
+        finish({ ok: false, tools: 0, error: message.error.message ?? "MCP self-test returned an error" });
+        return;
+      }
+      if (message.id === 1) {
+        initialized = true;
+        send({ jsonrpc: "2.0", method: "notifications/initialized" });
+        send({ jsonrpc: "2.0", method: "tools/list", id: 2 });
+        return;
+      }
+      if (message.id === 2) {
+        const tools = Array.isArray(message.result?.tools) ? message.result.tools.length : 0;
+        finish({ ok: initialized && tools > 0, tools, error: tools > 0 ? void 0 : "No MCP tools were listed" });
+      }
+    };
+    const timer = setTimeout(() => {
+      finish({ ok: false, tools: 0, error: "MCP self-test timed out" });
+    }, 1e4);
+    serverOutput.on("data", (chunk) => {
+      stdout += String(chunk);
+      let newline = stdout.indexOf("\n");
+      while (newline !== -1) {
+        const line2 = stdout.slice(0, newline);
+        stdout = stdout.slice(newline + 1);
+        try {
+          handleLine(line2);
+        } catch (error) {
+          finish({ ok: false, tools: 0, error: error instanceof Error ? error.message : String(error) });
+          return;
+        }
+        newline = stdout.indexOf("\n");
+      }
+    });
+    startMcpServer(stateDir, { stdin: clientInput, stdout: serverOutput }).then((serverHandle) => {
+      handle = serverHandle;
+      send({
+        jsonrpc: "2.0",
+        method: "initialize",
+        params: {
+          protocolVersion: "2025-11-25",
+          capabilities: {},
+          clientInfo: { name: "suture-setup", version: "0.1.0" }
+        },
+        id: 1
+      });
+    }).catch((error) => {
+      finish({ ok: false, tools: 0, error: error instanceof Error ? error.message : String(error) });
+    });
+  });
+}
+async function promptFor(defaultValue, label) {
+  const rl = readline2.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    const answer = await rl.question(`${label} [${defaultValue}]: `);
+    return answer.trim() || defaultValue;
+  } finally {
+    rl.close();
+  }
+}
+async function confirm(defaultNoPrompt) {
+  const rl = readline2.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    const answer = await rl.question(`${defaultNoPrompt} [y/N]: `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function runSetup(args, initialStateDir) {
+  const json = hasFlag(args, "--json");
+  const yes = hasFlag(args, "--yes");
+  let stateDir = initialStateDir;
+  let projectPath = path9.resolve(getFlag(args, "--project") ?? process.cwd());
+  const interactive = !yes && !json && process.stdin.isTTY && process.stdout.isTTY;
+  if (interactive) {
+    process.stdout.write(`${renderSetupWelcome(stateDir, projectPath, terminalWidth())}
+
+`);
+    stateDir = resolveStateDir(await promptFor(stateDir, "State directory"));
+    projectPath = path9.resolve(await promptFor(projectPath, "Project path"));
+  }
+  const runtime = createRuntime(stateDir);
+  try {
+    const indexer = new ProjectIndexer(
+      runtime.substrate,
+      runtime.memoryStore,
+      runtime.code,
+      runtime.tierManager,
+      runtime.telemetry
+    );
+    const plan = indexer.preview(projectPath);
+    if (json && !yes) {
+      process.stdout.write(`${JSON.stringify({ stateDir, mcpConfig: JSON.parse(mcpConfig("suture-mcp", stateDir)), plan }, null, 2)}
+`);
+      return;
+    }
+    if (!json) {
+      process.stdout.write(`${renderIndexPlan(plan, terminalWidth())}
+
+`);
+      process.stdout.write(box("MCP config preview", mcpConfig("suture-mcp", stateDir).split("\n"), terminalWidth()) + "\n\n");
+    }
+    let enabledFindingIndexes;
+    if (interactive) {
+      enabledFindingIndexes = await pickFindings(plan, terminalWidth()) ?? void 0;
+      if (!enabledFindingIndexes) {
+        process.stdout.write("Setup stopped before persistence. No project facts were stored.\n");
+        return;
+      }
+    } else if (!yes && !json && process.stdin.isTTY && !await confirm("Apply this safe project index now?")) {
+      process.stdout.write("Setup stopped before persistence. No project facts were stored.\n");
+      return;
+    }
+    if (!json) {
+      process.stdout.write(box("Indexing", [
+        `Applying ${enabledFindingIndexes?.length ?? plan.findings.length} selected findings`,
+        "Indexing code symbols and updating local value metrics",
+        "Running event-based curation after persistence"
+      ], terminalWidth()) + "\n\n");
+    }
+    const result = await indexer.apply(projectPath, { enabledFindingIndexes });
+    const cost = runtime.telemetry.estimateCostSavings(getFlag(args, "--model-profile") ?? "standard");
+    const selfTest = await runMcpSelfTest(stateDir);
+    if (json) {
+      process.stdout.write(`${JSON.stringify({
+        stateDir,
+        mcpConfig: JSON.parse(mcpConfig("suture-mcp", stateDir)),
+        mcpSelfTest: selfTest,
+        result,
+        stats: runtime.telemetry.getStats(),
+        cost
+      }, null, 2)}
+`);
+      return;
+    }
+    process.stdout.write(`${renderSetupSuccess(result, runtime.telemetry.getStats(), cost, terminalWidth(), selfTest)}
+`);
+  } finally {
+    runtime.substrate.close();
+  }
+}
+function runDoctor(args, stateDir) {
+  const checks = [];
+  let runtime = null;
+  try {
+    runtime = createRuntime(stateDir);
+    checks.push({ name: "node", ok: Number(process.versions.node.split(".")[0]) >= 20, detail: process.versions.node });
+    checks.push({ name: "state-dir", ok: fs8.existsSync(stateDir), detail: stateDir });
+    const fts = runtime.substrate.raw().prepare(`SELECT sqlite_version() AS version`).get();
+    checks.push({ name: "sqlite", ok: true, detail: fts.version });
+    runtime.code.indexFile("doctor.ts", "export function doctorCheck(): boolean { return true; }");
+    checks.push({ name: "tree-sitter", ok: runtime.code.countSymbolsForFile("doctor.ts") > 0, detail: "TypeScript parser loaded" });
+  } catch (error) {
+    checks.push({ name: "runtime", ok: false, detail: error instanceof Error ? error.message : String(error) });
+  } finally {
+    runtime?.substrate.close();
+  }
+  if (hasFlag(args, "--json")) {
+    process.stdout.write(`${JSON.stringify({ checks }, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(box("Suture doctor", checks.map((check) => {
+    return `[${check.ok ? "ok" : "!!"}] ${check.name}: ${check.detail}`;
+  }), terminalWidth()) + "\n");
+  if (checks.some((check) => !check.ok)) process.exit(1);
+}
+async function runIndex(args, stateDir) {
+  const projectPath = path9.resolve(positional(args)[0] ?? getFlag(args, "--project") ?? process.cwd());
+  const runtime = createRuntime(stateDir);
+  try {
+    const indexer = new ProjectIndexer(
+      runtime.substrate,
+      runtime.memoryStore,
+      runtime.code,
+      runtime.tierManager,
+      runtime.telemetry
+    );
+    if (!hasFlag(args, "--apply-safe")) {
+      const plan = indexer.preview(projectPath);
+      if (hasFlag(args, "--json")) {
+        process.stdout.write(`${JSON.stringify(plan, null, 2)}
+`);
+      } else {
+        process.stdout.write(`${renderIndexPlan(plan, terminalWidth())}
+`);
+      }
+      return;
+    }
+    const result = await indexer.apply(projectPath);
+    if (hasFlag(args, "--json")) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    } else {
+      process.stdout.write(`${renderIndexResult(result, terminalWidth())}
+`);
+    }
+  } finally {
+    runtime.substrate.close();
+  }
+}
+function runStats(args, stateDir) {
+  const telemetry = new TelemetryService(path9.join(stateDir, "telemetry.json"));
+  const modelProfile = getFlag(args, "--model-profile") ?? "standard";
+  const explicitCost = getFlag(args, "--input-cost-per-million");
+  const cost = telemetry.estimateCostSavings(
+    modelProfile,
+    explicitCost ? Number(explicitCost) : void 0
+  );
+  const stats = telemetry.getStats();
+  if (hasFlag(args, "--json")) {
+    process.stdout.write(`${JSON.stringify({ stats, cost }, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${renderStatsDashboard(stats, cost, terminalWidth())}
+`);
+}
+async function runRecall(stateDir) {
+  const runtime = createRuntime(stateDir);
+  try {
+    const block = runtime.tierManager.getCoreBlock();
+    runtime.telemetry.recordToolUsage("recall");
+    runtime.telemetry.recordInjection(block.length / 4);
+    runtime.telemetry.recordSavings(block.length / 4);
+    process.stdout.write(block + "\n");
+  } finally {
+    runtime.substrate.close();
+  }
+}
+function hookInput(args) {
+  return {
+    projectPath: path9.resolve(getFlag(args, "--project") ?? process.cwd()),
+    sessionId: getFlag(args, "--session") ?? getFlag(args, "--session-id") ?? "default",
+    client: getFlag(args, "--client"),
+    format: getFlag(args, "--format") ?? (hasFlag(args, "--json") ? "json" : void 0),
+    budget: getFlag(args, "--budget") ? Number(getFlag(args, "--budget")) : void 0
+  };
+}
+async function runHook(args, stateDir) {
+  const [event, ...eventArgs] = args;
+  const runtime = createRuntime(stateDir);
+  const hook = new HookService(runtime.substrate, runtime.tierManager, runtime.memoryStore);
+  const input2 = hookInput(eventArgs);
+  try {
+    if (event === "session-start") {
+      process.stdout.write(hook.formatDecision(
+        hook.decideSessionStart(input2),
+        input2.format ?? "claude-json"
+      ) + "\n");
+      return;
+    }
+    if (event === "pre-compact") {
+      const result = hook.preCompact(input2);
+      process.stdout.write(hasFlag(eventArgs, "--json") ? `${JSON.stringify(result)}
+` : `Flagged next session-start reinjection for ${result.projectId}/${result.sessionId}
+`);
+      return;
+    }
+    if (event === "post-compact") {
+      const result = await hook.postCompact({
+        ...input2,
+        summary: getFlag(eventArgs, "--summary"),
+        summaryFile: getFlag(eventArgs, "--summary-file")
+      });
+      process.stdout.write(hasFlag(eventArgs, "--json") ? `${JSON.stringify(result)}
+` : `${result.stored ? "Stored compact summary and flagged" : "Flagged"} next session-start reinjection for ${result.projectId}/${result.sessionId}
+`);
+      return;
+    }
+    if (event === "status") {
+      const result = hook.status(input2);
+      process.stdout.write(hasFlag(eventArgs, "--json") ? `${JSON.stringify(result)}
+` : box("Suture hook status", [
+        `Project: ${result.projectId}`,
+        `Session: ${result.sessionId}`,
+        `Client:  ${result.client}`,
+        `Last hash: ${result.lastHash ?? "none"}`,
+        `Reinject pending: ${result.reinjectPending ? "yes" : "no"}`,
+        `Accepted findings: ${result.acceptedFindings}`
+      ], terminalWidth()) + "\n");
+      return;
+    }
+  } finally {
+    runtime.substrate.close();
+  }
+  process.stderr.write("Unknown hook event. Use: session-start, pre-compact, post-compact, or status.\n");
+  process.exit(1);
+}
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+  const dir = resolveStateDir(getFlag(args, "--dir"));
+  if (!cmd || cmd === "--help" || cmd === "-h") printUsage(0);
+  if (cmd === "init") {
+    const runtime = createRuntime(dir);
+    runtime.substrate.close();
+    process.stdout.write(`Initialized suture at ${dir}
+`);
+    return;
+  }
+  if (cmd === "setup") {
+    await runSetup(args, dir);
+    return;
+  }
+  if (cmd === "serve") {
+    const serverHandle = await startMcpServer(dir);
+    await new Promise((resolve7) => {
+      const keepAlive = setInterval(() => void 0, 2147483647);
+      const stop = () => {
+        clearInterval(keepAlive);
+        void serverHandle.close();
+        resolve7();
+      };
+      process.once("SIGTERM", stop);
+      process.once("SIGINT", stop);
+    });
+    return;
+  }
+  if (cmd === "doctor") {
+    runDoctor(args, dir);
+    return;
+  }
+  if (cmd === "index" || cmd === "discover") {
+    await runIndex(args, dir);
+    return;
+  }
+  if (cmd === "hook") {
+    await runHook(args, dir);
+    return;
+  }
+  if (cmd === "stats") {
+    runStats(args, dir);
+    return;
+  }
+  if (cmd === "recall") {
+    await runRecall(dir);
+    return;
+  }
+  process.stderr.write(`Unknown command: ${cmd}
+
+`);
+  printUsage(1);
+}
+main().catch((err) => {
+  process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});