@jefuriiij/synthra 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,4284 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// package.json
+var package_exports = {};
+__export(package_exports, {
+  default: () => package_default
+});
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@jefuriiij/synthra",
+      version: "0.1.0",
+      publishConfig: {
+        access: "public"
+      },
+      description: "Local context engine for AI coding assistants \u2014 graph-based context, branch-aware memory, real-time human-activity awareness, deterministic Grep/Glob gating, and a live token dashboard.",
+      type: "module",
+      bin: {
+        syn: "./bin/syn",
+        synthra: "./bin/syn"
+      },
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        test: "vitest run",
+        "test:watch": "vitest",
+        typecheck: "tsc --noEmit"
+      },
+      files: [
+        "dist",
+        "bin",
+        "README.md",
+        "LICENSE",
+        "ROADMAP.md"
+      ],
+      keywords: [
+        "claude-code",
+        "mcp",
+        "context-engine",
+        "code-graph",
+        "ai-coding",
+        "token-savings"
+      ],
+      author: "Jeff (@jefuriiij)",
+      license: "MIT",
+      homepage: "https://github.com/jefuriiij/synthra#readme",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/jefuriiij/synthra.git"
+      },
+      bugs: {
+        url: "https://github.com/jefuriiij/synthra/issues"
+      },
+      engines: {
+        node: ">=18"
+      },
+      dependencies: {
+        "@hono/node-server": "^1.18.0",
+        chokidar: "^5.0.0",
+        hono: "^4.12.23",
+        ignore: "^7.0.0",
+        sade: "^1.8.1",
+        "tree-sitter-wasms": "^0.1.12",
+        "web-tree-sitter": "~0.22.6"
+      },
+      devDependencies: {
+        "@types/node": "^25.9.1",
+        tsup: "^8.5.1",
+        typescript: "^6.0.3",
+        vitest: "^4.1.7"
+      }
+    };
+  }
+});
+
+// src/cli/index.ts
+import sade from "sade";
+import { resolve as resolve4 } from "path";
+
+// src/dashboard/server.ts
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+
+// src/shared/logger.ts
+var LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var activeLevel = process.env.SYN_LOG_LEVEL ?? "info";
+function shouldLog(level) {
+  return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[activeLevel];
+}
+function emit(level, msg, ...args) {
+  if (!shouldLog(level)) return;
+  const stream = level === "error" || level === "warn" ? process.stderr : process.stdout;
+  stream.write(`[syn] ${msg}${args.length ? " " + args.map(String).join(" ") : ""}
+`);
+}
+var log = {
+  debug: (m, ...a) => emit("debug", m, ...a),
+  info: (m, ...a) => emit("info", m, ...a),
+  warn: (m, ...a) => emit("warn", m, ...a),
+  error: (m, ...a) => emit("error", m, ...a)
+};
+
+// src/server/port.ts
+import { createServer } from "net";
+var PORT_RANGE_START = 8080;
+var PORT_RANGE_END = 8099;
+async function findFreePort(start = PORT_RANGE_START, end = PORT_RANGE_END) {
+  for (let port = start; port <= end; port++) {
+    if (await isFree(port)) return port;
+  }
+  throw new Error(`Synthra: no free port in ${start}-${end}`);
+}
+function isFree(port) {
+  return new Promise((resolve5) => {
+    const s = createServer();
+    s.once("error", () => resolve5(false));
+    s.once("listening", () => s.close(() => resolve5(true)));
+    s.listen(port, "127.0.0.1");
+  });
+}
+
+// src/dashboard/delta.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/shared/paths.ts
+import { join } from "path";
+function resolvePaths(projectRoot) {
+  const graphDir = join(projectRoot, ".synthra-graph");
+  const contextDir = join(projectRoot, ".synthra");
+  const claudeDir = join(projectRoot, ".claude");
+  return {
+    projectRoot,
+    graphDir,
+    contextDir,
+    infoGraph: join(graphDir, "info_graph.json"),
+    symbolIndex: join(graphDir, "symbol_index.json"),
+    sessionState: join(graphDir, "session.json"),
+    activityLog: join(graphDir, "activity.jsonl"),
+    tokenLog: join(graphDir, "token_log.jsonl"),
+    gateLog: join(graphDir, "gate_log.jsonl"),
+    mcpPort: join(graphDir, "mcp_port"),
+    mcpServerLog: join(graphDir, "mcp_server.log"),
+    mcpServerErrLog: join(graphDir, "mcp_server.err.log"),
+    contextStore: join(contextDir, "context-store.json"),
+    contextMd: join(contextDir, "CONTEXT.md"),
+    branchesDir: join(contextDir, "branches"),
+    claudeDir,
+    claudeSettings: join(claudeDir, "settings.local.json"),
+    claudeHooksDir: join(claudeDir, "hooks"),
+    claudeMd: join(projectRoot, "CLAUDE.md"),
+    gitignore: join(projectRoot, ".gitignore")
+  };
+}
+
+// src/shared/pricing.ts
+var PRICING = {
+  // Opus-class models — premium tier
+  "claude-opus-4-7": { input: 15, output: 75, cacheRead: 1.5, cacheCreate: 18.75 },
+  "claude-opus-4-6": { input: 15, output: 75, cacheRead: 1.5, cacheCreate: 18.75 },
+  "claude-opus-4-5": { input: 15, output: 75, cacheRead: 1.5, cacheCreate: 18.75 },
+  // Sonnet-class — workhorse
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheCreate: 3.75 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheCreate: 3.75 },
+  // Haiku-class — fast and cheap
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheCreate: 1.25 }
+};
+var FALLBACK = { input: 3, output: 15, cacheRead: 0.3, cacheCreate: 3.75 };
+function pricingFor(model) {
+  if (!model) return FALLBACK;
+  const direct = PRICING[model];
+  if (direct) return direct;
+  if (model.includes("opus")) return PRICING["claude-opus-4-7"] ?? FALLBACK;
+  if (model.includes("sonnet")) return PRICING["claude-sonnet-4-6"] ?? FALLBACK;
+  if (model.includes("haiku")) return PRICING["claude-haiku-4-5"] ?? FALLBACK;
+  return FALLBACK;
+}
+function estimateCostUsd(usage) {
+  const p = pricingFor(usage.model);
+  return usage.input_tokens / 1e6 * p.input + usage.output_tokens / 1e6 * p.output + (usage.cache_read_input_tokens ?? 0) / 1e6 * p.cacheRead + (usage.cache_creation_input_tokens ?? 0) / 1e6 * p.cacheCreate;
+}
+
+// src/shared/project-registry.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { basename, dirname, join as join2 } from "path";
+var REGISTRY_DIR = join2(homedir(), ".synthra");
+var REGISTRY_PATH = join2(REGISTRY_DIR, "projects.json");
+var SCHEMA_VERSION = 1;
+async function readRegistry() {
+  try {
+    const raw = await readFile(REGISTRY_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.projects)) return { schema_version: SCHEMA_VERSION, projects: [] };
+    return { schema_version: parsed.schema_version ?? SCHEMA_VERSION, projects: parsed.projects };
+  } catch {
+    return { schema_version: SCHEMA_VERSION, projects: [] };
+  }
+}
+async function writeRegistry(registry) {
+  await mkdir(dirname(REGISTRY_PATH), { recursive: true });
+  await writeFile(REGISTRY_PATH, JSON.stringify(registry, null, 2) + "\n", "utf8");
+}
+async function recordProject(projectRoot) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const registry = await readRegistry();
+  const existing = registry.projects.find((p) => p.path === projectRoot);
+  if (existing) {
+    existing.last_seen = now;
+    existing.name = basename(projectRoot);
+  } else {
+    registry.projects.push({
+      path: projectRoot,
+      name: basename(projectRoot),
+      first_seen: now,
+      last_seen: now
+    });
+  }
+  try {
+    await writeRegistry(registry);
+  } catch {
+  }
+}
+async function listProjects() {
+  const registry = await readRegistry();
+  return registry.projects.slice().sort((a, b) => a.last_seen > b.last_seen ? -1 : a.last_seen < b.last_seen ? 1 : 0);
+}
+
+// src/dashboard/delta.ts
+var AVG_TOKENS_PER_BLOCKED_GREP = 500;
+async function readJsonl(path) {
+  try {
+    const text = await readFile2(path, "utf8");
+    return text.split(/\r?\n/).filter((l) => l.length > 0).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter((v) => v !== null);
+  } catch {
+    return [];
+  }
+}
+function basename2(p) {
+  const parts = p.split(/[\\/]/);
+  return parts[parts.length - 1] || p;
+}
+function summarize(p) {
+  let totalIn = 0;
+  let totalOut = 0;
+  let totalCacheRead = 0;
+  let totalCacheCreate = 0;
+  let costUsd = 0;
+  const models = {};
+  for (const t of p.tokens) {
+    totalIn += t.input_tokens ?? 0;
+    totalOut += t.output_tokens ?? 0;
+    totalCacheRead += t.cache_read_input_tokens ?? 0;
+    totalCacheCreate += t.cache_creation_input_tokens ?? 0;
+    costUsd += estimateCostUsd(t);
+    if (t.model) models[t.model] = (models[t.model] ?? 0) + 1;
+  }
+  const blocked = p.gates.filter((g) => g.decision === "block").length;
+  const saved = blocked * AVG_TOKENS_PER_BLOCKED_GREP;
+  return {
+    path: p.path,
+    name: p.name,
+    last_seen: p.last_seen,
+    total_turns: p.tokens.length,
+    total_input_tokens: totalIn,
+    total_output_tokens: totalOut,
+    total_cache_read: totalCacheRead,
+    total_cache_create: totalCacheCreate,
+    total_gate_calls: p.gates.length,
+    blocked_count: blocked,
+    estimated_tokens_saved: saved,
+    estimated_cost_usd: Math.round(costUsd * 100) / 100,
+    models
+  };
+}
+async function loadProjectFiles(path, name, lastSeen) {
+  const paths = resolvePaths(path);
+  const [rawTokens, gates] = await Promise.all([
+    readJsonl(paths.tokenLog),
+    readJsonl(paths.gateLog)
+  ]);
+  return { path, name, last_seen: lastSeen, tokens: dedupeTokens(rawTokens), gates };
+}
+function dedupeTokens(entries) {
+  const score2 = (model) => {
+    if (!model) return 0;
+    if (model === "<synthetic>") return 1;
+    return 2;
+  };
+  const groups = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const ts = e.ts ?? e.written_at ?? "";
+    const second = ts.slice(0, 19);
+    const key = [
+      e.project ?? "",
+      e.input_tokens ?? 0,
+      e.output_tokens ?? 0,
+      e.cache_creation_input_tokens ?? 0,
+      e.cache_read_input_tokens ?? 0,
+      second
+    ].join("|");
+    const arr = groups.get(key) ?? [];
+    arr.push(e);
+    groups.set(key, arr);
+  }
+  const out = [];
+  for (const arr of groups.values()) {
+    if (arr.length === 1) {
+      out.push(arr[0]);
+      continue;
+    }
+    arr.sort((a, b) => score2(b.model) - score2(a.model));
+    out.push(arr[0]);
+  }
+  out.sort((a, b) => {
+    const at = a.ts ?? a.written_at ?? "";
+    const bt = b.ts ?? b.written_at ?? "";
+    return at.localeCompare(bt);
+  });
+  return out;
+}
+async function computeDashboardData(activePaths, recentN = 25) {
+  const registered = await listProjects();
+  const activePath = activePaths.projectRoot;
+  const activeName = basename2(activePath);
+  const knownPaths = new Set(registered.map((p) => p.path));
+  const allEntries = [
+    ...registered.map((p) => ({ path: p.path, name: p.name, last_seen: p.last_seen }))
+  ];
+  if (!knownPaths.has(activePath)) {
+    allEntries.unshift({ path: activePath, name: activeName, last_seen: null });
+  }
+  const loaded = await Promise.all(
+    allEntries.map((e) => loadProjectFiles(e.path, e.name, e.last_seen))
+  );
+  const projects = loaded.map(summarize).sort((a, b) => b.total_input_tokens + b.total_output_tokens - (a.total_input_tokens + a.total_output_tokens));
+  const activeFiles = loaded.find((p) => p.path === activePath) ?? {
+    path: activePath,
+    name: activeName,
+    last_seen: null,
+    tokens: [],
+    gates: []
+  };
+  const activeStats = summarize(activeFiles);
+  let g_in = 0, g_out = 0, g_cr = 0, g_cc = 0, g_gate = 0, g_block = 0, g_cost = 0, g_turns = 0;
+  for (const s of projects) {
+    g_turns += s.total_turns;
+    g_in += s.total_input_tokens;
+    g_out += s.total_output_tokens;
+    g_cr += s.total_cache_read;
+    g_cc += s.total_cache_create;
+    g_gate += s.total_gate_calls;
+    g_block += s.blocked_count;
+    g_cost += s.estimated_cost_usd;
+  }
+  const g_saved = g_block * AVG_TOKENS_PER_BLOCKED_GREP;
+  const g_used = g_in + g_out + g_cc;
+  const g_saved_pct = g_used + g_saved > 0 ? g_saved / (g_used + g_saved) * 100 : 0;
+  const allTurns = [];
+  const allGates = [];
+  for (const p of loaded) {
+    for (const t of p.tokens) {
+      allTurns.push({
+        // Fall back to written_at — the Stop hook today posts entries without
+        // a `ts` field, and the server tags them with written_at on receive.
+        ts: t.ts ?? t.written_at ?? "",
+        project_name: p.name,
+        project_path: p.path,
+        input: t.input_tokens ?? 0,
+        output: t.output_tokens ?? 0,
+        cache_read: t.cache_read_input_tokens ?? 0,
+        cache_create: t.cache_creation_input_tokens ?? 0,
+        model: t.model ?? "",
+        cost_usd: Math.round(estimateCostUsd(t) * 1e3) / 1e3
+      });
+    }
+    for (const gate of p.gates) {
+      allGates.push({
+        ts: gate.ts,
+        project_name: p.name,
+        project_path: p.path,
+        tool: gate.tool,
+        decision: gate.decision,
+        query: gate.query
+      });
+    }
+  }
+  allTurns.sort((a, b) => a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0);
+  allGates.sort((a, b) => a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0);
+  return {
+    active: {
+      project_root: activePath,
+      project_name: activeName,
+      stats: activeStats
+    },
+    global: {
+      project_count: projects.length,
+      total_turns: g_turns,
+      total_input_tokens: g_in,
+      total_output_tokens: g_out,
+      total_cache_read: g_cr,
+      total_cache_create: g_cc,
+      total_gate_calls: g_gate,
+      blocked_count: g_block,
+      estimated_tokens_saved: g_saved,
+      saved_percent: Math.round(g_saved_pct * 10) / 10,
+      estimated_cost_usd: Math.round(g_cost * 100) / 100
+    },
+    projects,
+    recent_turns: allTurns.slice(0, recentN),
+    recent_gates: allGates.slice(0, recentN)
+  };
+}
+
+// src/dashboard/public/index.html
+var public_default = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Synthra \u2014 Token Dashboard</title>
+  <link rel="stylesheet" href="./style.css" />
+</head>
+<body>
+  <header>
+    <div class="brand">
+      <h1>Synthra</h1>
+      <span class="tag">Token Dashboard</span>
+    </div>
+    <div class="meta">
+      <span class="active-project" id="active-project">\u2026</span>
+      <span class="dot" id="dot"></span>
+      <span id="status">connecting\u2026</span>
+    </div>
+  </header>
+
+  <main>
+    <section>
+      <h2>Global totals  <span class="muted">(all projects)</span></h2>
+      <div class="cards" id="cards"></div>
+    </section>
+
+    <section>
+      <h2>Projects</h2>
+      <div class="projects" id="projects"></div>
+      <p class="empty hidden" id="projects-empty">No projects registered yet. Run <code>syn .</code> in any project to add it.</p>
+    </section>
+
+    <section>
+      <h2>Recent calls  <span class="muted">(across all projects)</span></h2>
+      <table id="turns">
+        <thead>
+          <tr>
+            <th>Time</th>
+            <th>Project</th>
+            <th>Model</th>
+            <th class="num">Input</th>
+            <th class="num">Output</th>
+            <th class="num">Cache R / W</th>
+            <th class="num">Cost</th>
+          </tr>
+        </thead>
+        <tbody></tbody>
+      </table>
+      <p class="empty hidden" id="turns-empty">No turns logged yet. Use Claude via the IDE extension or <code>claude</code> CLI while <code>syn .</code> is running.</p>
+    </section>
+
+    <section>
+      <h2>Recent gate decisions</h2>
+      <table id="gates">
+        <thead>
+          <tr>
+            <th>Time</th>
+            <th>Project</th>
+            <th>Tool</th>
+            <th>Decision</th>
+            <th>Query</th>
+          </tr>
+        </thead>
+        <tbody></tbody>
+      </table>
+      <p class="empty hidden" id="gates-empty">No gate decisions yet.</p>
+    </section>
+  </main>
+
+  <footer>
+    <span>Token Counter MCP \xB7 live polling every 2s</span>
+    <span class="muted">Cost figures are approximate \u2014 see /docs/PROTOCOL.md</span>
+  </footer>
+
+  <script>
+    const $ = (sel) => document.querySelector(sel);
+    const cardsEl = $("#cards");
+    const projectsEl = $("#projects");
+    const turnsBody = $("#turns tbody");
+    const gatesBody = $("#gates tbody");
+    const turnsEmpty = $("#turns-empty");
+    const gatesEmpty = $("#gates-empty");
+    const projectsEmpty = $("#projects-empty");
+    const statusEl = $("#status");
+    const dotEl = $("#dot");
+    const activeProjectEl = $("#active-project");
+
+    function fmt(n) {
+      if (typeof n !== "number" || !Number.isFinite(n)) return "0";
+      if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M";
+      if (n >= 1000) return (n / 1000).toFixed(1) + "K";
+      return n.toLocaleString();
+    }
+
+    function fmtFull(n) {
+      return (typeof n === "number" ? n : 0).toLocaleString();
+    }
+
+    function fmtCost(usd) {
+      if (typeof usd !== "number") return "~$0.00";
+      if (usd >= 1) return "~$" + usd.toFixed(2);
+      if (usd >= 0.01) return "~$" + usd.toFixed(3);
+      return "~$" + usd.toFixed(4);
+    }
+
+    function fmtTs(iso) {
+      try {
+        const d = new Date(iso);
+        const today = new Date();
+        const isToday = d.toDateString() === today.toDateString();
+        if (isToday) return d.toLocaleTimeString();
+        return d.toLocaleString();
+      } catch {
+        return iso;
+      }
+    }
+
+    function renderCards(g) {
+      cardsEl.innerHTML = "";
+      const cards = [
+        { label: "Total cost", value: fmtCost(g.estimated_cost_usd), accent: true },
+        { label: "Turns",        value: fmt(g.total_turns) },
+        { label: "Input",        value: fmt(g.total_input_tokens) },
+        { label: "Output",       value: fmt(g.total_output_tokens) },
+        { label: "Cache read",   value: fmt(g.total_cache_read) },
+        { label: "Cache write",  value: fmt(g.total_cache_create) },
+        { label: "Projects",     value: fmt(g.project_count) },
+        { label: "Blocked Grep / Glob", value: fmt(g.blocked_count), accent: true },
+        { label: "Tokens saved",        value: fmt(g.estimated_tokens_saved), accent: true },
+      ];
+      for (const c of cards) {
+        const el = document.createElement("div");
+        el.className = "card" + (c.accent ? " accent" : "");
+        el.innerHTML = '<div class="card-label">' + c.label + '</div><div class="card-value">' + c.value + '</div>';
+        cardsEl.appendChild(el);
+      }
+    }
+
+    function renderProjects(projects, globalCost) {
+      projectsEl.innerHTML = "";
+      if (!projects.length) {
+        projectsEmpty.classList.remove("hidden");
+        return;
+      }
+      projectsEmpty.classList.add("hidden");
+      const maxTokens = Math.max(1, ...projects.map((p) => p.total_input_tokens + p.total_output_tokens));
+      for (const p of projects) {
+        const total = p.total_input_tokens + p.total_output_tokens;
+        const pct = Math.round((total / maxTokens) * 100);
+        const sharePct = globalCost > 0 ? ((p.estimated_cost_usd / globalCost) * 100).toFixed(1) : "0.0";
+        const row = document.createElement("div");
+        row.className = "project-row";
+        row.innerHTML =
+          '<div class="project-name">' +
+            '<strong>' + p.name + '</strong>' +
+            '<code class="project-path">' + p.path + '</code>' +
+          '</div>' +
+          '<div class="project-stats">' +
+            '<div class="stat"><span class="stat-value cost">' + fmtCost(p.estimated_cost_usd) + '</span><span class="stat-label">cost (' + sharePct + '%)</span></div>' +
+            '<div class="stat"><span class="stat-value">' + fmt(total) + '</span><span class="stat-label">tokens</span></div>' +
+            '<div class="stat"><span class="stat-value">' + fmt(p.total_turns) + '</span><span class="stat-label">turns</span></div>' +
+            '<div class="stat"><span class="stat-value">' + fmt(p.blocked_count) + '</span><span class="stat-label">blocks</span></div>' +
+          '</div>' +
+          '<div class="bar"><div class="bar-fill" style="width:' + pct + '%"></div></div>';
+        projectsEl.appendChild(row);
+      }
+    }
+
+    function renderTurns(turns) {
+      turnsBody.innerHTML = "";
+      if (!turns.length) {
+        turnsEmpty.classList.remove("hidden");
+        return;
+      }
+      turnsEmpty.classList.add("hidden");
+      for (const t of turns) {
+        const tr = document.createElement("tr");
+        const modelCell =
+          t.model && t.model !== "<synthetic>"
+            ? "<code>" + t.model + "</code>"
+            : '<span class="muted">' + (t.model === "<synthetic>" ? "synthetic" : "unknown") + "</span>";
+        tr.innerHTML =
+          "<td>" + fmtTs(t.ts) + "</td>" +
+          "<td><code>" + t.project_name + "</code></td>" +
+          "<td>" + modelCell + "</td>" +
+          '<td class="num">' + fmtFull(t.input) + "</td>" +
+          '<td class="num">' + fmtFull(t.output) + "</td>" +
+          '<td class="num">' + fmt(t.cache_read) + " / " + fmt(t.cache_create) + "</td>" +
+          '<td class="num cost">' + fmtCost(t.cost_usd) + "</td>";
+        turnsBody.appendChild(tr);
+      }
+    }
+
+    function renderGates(gates) {
+      gatesBody.innerHTML = "";
+      if (!gates.length) {
+        gatesEmpty.classList.remove("hidden");
+        return;
+      }
+      gatesEmpty.classList.add("hidden");
+      for (const g of gates) {
+        const tr = document.createElement("tr");
+        const cls = g.decision === "block" ? "decision-block" : "decision-allow";
+        tr.innerHTML =
+          "<td>" + fmtTs(g.ts) + "</td>" +
+          "<td><code>" + g.project_name + "</code></td>" +
+          "<td><code>" + g.tool + "</code></td>" +
+          '<td class="' + cls + '">' + g.decision + "</td>" +
+          "<td><code>" + (g.query || "") + "</code></td>";
+        gatesBody.appendChild(tr);
+      }
+    }
+
+    async function tick() {
+      try {
+        const res = await fetch("/data");
+        if (!res.ok) throw new Error("HTTP " + res.status);
+        const data = await res.json();
+        activeProjectEl.textContent = data.active.project_root;
+        renderCards(data.global);
+        renderProjects(data.projects, data.global.estimated_cost_usd);
+        renderTurns(data.recent_turns);
+        renderGates(data.recent_gates);
+        statusEl.textContent = "live \xB7 " + new Date().toLocaleTimeString();
+        dotEl.classList.add("live");
+        dotEl.classList.remove("dead");
+      } catch (e) {
+        statusEl.textContent = "disconnected \xB7 " + e.message;
+        dotEl.classList.add("dead");
+        dotEl.classList.remove("live");
+      }
+    }
+
+    tick();
+    setInterval(tick, 2000);
+  </script>
+</body>
+</html>
+`;
+
+// src/dashboard/public/style.css
+var style_default = '/* Synthra token dashboard \u2014 palette per project brief. */\n\n:root {\n  --color-heading: #ECEBD8;\n  --color-body: #EDECD9;\n  --color-bg: #000000;\n  --color-surface: #140009;\n  --color-surface-raised: #1E000D;\n  --color-border: #4D0020;\n  --color-accent: #FF0073;\n  --color-accent-darker: #EB006A;\n  --color-form-bg: #2E0014;\n  --color-muted: rgba(237, 236, 217, 0.55);\n  --color-very-muted: rgba(237, 236, 217, 0.35);\n  --color-block: #FF0073;\n  --color-allow: #ECEBD8;\n}\n\n* {\n  box-sizing: border-box;\n  margin: 0;\n  padding: 0;\n}\n\nhtml, body {\n  background: var(--color-bg);\n  color: var(--color-body);\n  font-family:\n    ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI",\n    system-ui, sans-serif;\n  font-size: 14px;\n  line-height: 1.5;\n  min-height: 100vh;\n}\n\ncode, .num, table, .project-path {\n  font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;\n}\n\nheader {\n  display: flex;\n  align-items: center;\n  gap: 1.5rem;\n  padding: 1.1rem 2rem;\n  background: var(--color-surface);\n  border-bottom: 1px solid var(--color-border);\n}\n\nheader .brand {\n  display: flex;\n  align-items: baseline;\n  gap: 0.75rem;\n}\n\nheader h1 {\n  color: var(--color-heading);\n  font-size: 1.35rem;\n  font-weight: 700;\n  letter-spacing: 0.02em;\n}\n\nheader .tag {\n  color: var(--color-muted);\n  font-size: 0.78rem;\n  text-transform: uppercase;\n  letter-spacing: 0.1em;\n}\n\nheader .meta {\n  margin-left: auto;\n  display: flex;\n  align-items: center;\n  gap: 0.75rem;\n  font-size: 0.78rem;\n  font-family: ui-monospace, monospace;\n  color: var(--color-muted);\n}\n\nheader .active-project {\n  max-width: 480px;\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n}\n\nmain {\n  padding: 2rem;\n  display: flex;\n  flex-direction: column;\n  gap: 2rem;\n  max-width: 1400px;\n  margin: 0 auto;\n}\n\nsection {\n  display: flex;\n  flex-direction: column;\n  gap: 0.85rem;\n}\n\nh2 {\n  color: var(--color-heading);\n  font-size: 0.85rem;\n  font-weight: 600;\n  letter-spacing: 0.08em;\n  text-transform: uppercase;\n}\n\nh2 .muted {\n  color: var(--color-very-muted);\n  font-size: 0.78rem;\n  font-weight: 400;\n  letter-spacing: 0.06em;\n  text-transform: none;\n  margin-left: 0.5rem;\n}\n\n/* Cards row */\n.cards {\n  display: grid;\n  grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));\n  gap: 0.7rem;\n}\n\n.card {\n  background: var(--color-surface);\n  border: 1px solid var(--color-border);\n  border-radius: 6px;\n  padding: 0.85rem 1rem;\n}\n\n.card.accent {\n  background: var(--color-surface-raised);\n  border-color: var(--color-accent);\n}\n\n.card-label {\n  color: var(--color-muted);\n  font-size: 0.66rem;\n  text-transform: uppercase;\n  letter-spacing: 0.08em;\n  margin-bottom: 0.35rem;\n}\n\n.card-value {\n  color: var(--color-heading);\n  font-family: ui-monospace, monospace;\n  font-size: 1.5rem;\n  font-weight: 600;\n}\n\n.card.accent .card-value {\n  color: var(--color-accent);\n}\n\n/* Projects list */\n.projects {\n  display: flex;\n  flex-direction: column;\n  gap: 0.6rem;\n}\n\n.project-row {\n  display: grid;\n  grid-template-columns: minmax(220px, 1fr) auto;\n  grid-template-rows: auto auto;\n  gap: 0.6rem 1.25rem;\n  align-items: center;\n  background: var(--color-surface);\n  border: 1px solid var(--color-border);\n  border-radius: 6px;\n  padding: 0.9rem 1.2rem;\n}\n\n.project-row:hover {\n  background: var(--color-surface-raised);\n}\n\n.project-name {\n  display: flex;\n  flex-direction: column;\n  gap: 0.15rem;\n  overflow: hidden;\n}\n\n.project-name strong {\n  color: var(--color-heading);\n  font-size: 0.95rem;\n  font-weight: 600;\n}\n\n.project-name .project-path {\n  color: var(--color-very-muted);\n  font-size: 0.72rem;\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n}\n\n.project-stats {\n  display: flex;\n  gap: 1.6rem;\n  justify-self: end;\n  text-align: right;\n}\n\n.stat {\n  display: flex;\n  flex-direction: column;\n  gap: 0.15rem;\n  min-width: 70px;\n}\n\n.stat-value {\n  color: var(--color-heading);\n  font-family: ui-monospace, monospace;\n  font-size: 0.95rem;\n  font-weight: 600;\n}\n\n.stat-value.cost {\n  color: var(--color-accent);\n}\n\n.stat-label {\n  color: var(--color-muted);\n  font-size: 0.66rem;\n  text-transform: uppercase;\n  letter-spacing: 0.08em;\n}\n\n.bar {\n  grid-column: 1 / -1;\n  height: 3px;\n  background: var(--color-form-bg);\n  border-radius: 2px;\n  overflow: hidden;\n}\n\n.bar-fill {\n  height: 100%;\n  background: linear-gradient(90deg, var(--color-accent-darker), var(--color-accent));\n  border-radius: 2px;\n  transition: width 400ms ease;\n}\n\n/* Tables */\ntable {\n  width: 100%;\n  border-collapse: collapse;\n  font-size: 0.83rem;\n  background: var(--color-surface);\n  border: 1px solid var(--color-border);\n  border-radius: 6px;\n  overflow: hidden;\n}\n\ntable thead th {\n  text-align: left;\n  color: var(--color-muted);\n  text-transform: uppercase;\n  font-size: 0.66rem;\n  letter-spacing: 0.08em;\n  font-weight: 600;\n  padding: 0.65rem 0.85rem;\n  border-bottom: 1px solid var(--color-border);\n  background: var(--color-surface);\n}\n\ntable thead th.num {\n  text-align: right;\n}\n\ntable tbody td {\n  padding: 0.55rem 0.85rem;\n  border-bottom: 1px solid rgba(77, 0, 32, 0.4);\n  color: var(--color-body);\n}\n\ntable tbody td.num {\n  text-align: right;\n}\n\ntable tbody td.cost {\n  color: var(--color-accent);\n  font-weight: 600;\n}\n\ntable tbody tr:last-child td {\n  border-bottom: none;\n}\n\ntable tbody tr:hover {\n  background: var(--color-surface-raised);\n}\n\ncode {\n  color: var(--color-heading);\n  background: var(--color-form-bg);\n  padding: 0.1rem 0.4rem;\n  border-radius: 3px;\n  font-size: 0.85em;\n}\n\n.decision-block {\n  color: var(--color-block);\n  font-weight: 700;\n  text-transform: uppercase;\n  font-size: 0.72rem;\n  letter-spacing: 0.06em;\n}\n\n.decision-allow {\n  color: var(--color-allow);\n  opacity: 0.7;\n  text-transform: uppercase;\n  font-size: 0.72rem;\n  letter-spacing: 0.06em;\n}\n\n.empty {\n  color: var(--color-muted);\n  font-style: italic;\n  padding: 1rem;\n  background: var(--color-surface);\n  border: 1px dashed var(--color-border);\n  border-radius: 6px;\n}\n\n.hidden {\n  display: none;\n}\n\nfooter {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  padding: 0.85rem 2rem;\n  background: var(--color-surface);\n  border-top: 1px solid var(--color-border);\n  color: var(--color-muted);\n  font-size: 0.72rem;\n  font-family: ui-monospace, monospace;\n}\n\nfooter .muted {\n  color: var(--color-very-muted);\n}\n\n.dot {\n  width: 8px;\n  height: 8px;\n  border-radius: 50%;\n  background: var(--color-muted);\n  transition: background 200ms ease, box-shadow 200ms ease;\n}\n\n.dot.live {\n  background: var(--color-accent);\n  box-shadow: 0 0 8px var(--color-accent-darker);\n}\n\n.dot.dead {\n  background: var(--color-border);\n  box-shadow: none;\n}\n';
+
+// src/dashboard/server.ts
+var FALLBACK_RANGE = 9;
+async function startDashboard(paths, preferredPort = 8901) {
+  const port = await findFreePort(preferredPort, preferredPort + FALLBACK_RANGE);
+  if (port !== preferredPort) {
+    log.info(
+      `dashboard port ${preferredPort} was busy \u2014 bound to ${port} instead (likely another dashboard from a coexisting tool).`
+    );
+  }
+  const app = new Hono();
+  app.get("/", (c) => c.html(public_default));
+  app.get("/style.css", (c) => {
+    c.header("Content-Type", "text/css; charset=utf-8");
+    c.header("Cache-Control", "no-cache");
+    return c.body(style_default);
+  });
+  app.get("/health", (c) => c.json({ ok: true }));
+  app.get("/data", async (c) => {
+    const data = await computeDashboardData(paths);
+    return c.json(data);
+  });
+  const nodeServer = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" });
+  return {
+    port,
+    url: `http://127.0.0.1:${port}`,
+    async stop() {
+      await new Promise((resolve5, reject) => {
+        nodeServer.close((err2) => err2 ? reject(err2) : resolve5());
+      });
+    }
+  };
+}
+
+// src/hooks/installer.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+
+// src/hooks/scripts/pre-compact.ps1
+var pre_compact_default = '# PreCompact hook \u2014 Windows PowerShell.\n# Re-injects the primer after Claude auto-compacts. Same logic as prime.ps1.\n\n$ErrorActionPreference = "SilentlyContinue"\n\n$portFile = Join-Path $PWD ".synthra-graph\\mcp_port"\nif (-not (Test-Path $portFile)) { exit 0 }\n$port = (Get-Content -Path $portFile -Raw).Trim()\nif (-not $port) { exit 0 }\n\ntry {\n    $resp = Invoke-RestMethod -Uri "http://127.0.0.1:$port/prime" -Method GET -TimeoutSec 3\n    if ($resp.primer) { Write-Output $resp.primer }\n} catch {\n    # silent\n}\nexit 0\n';
+
+// src/hooks/scripts/pre-compact.sh
+var pre_compact_default2 = `#!/usr/bin/env bash
+# PreCompact hook \u2014 bash. Re-injects the primer after Claude auto-compacts.
+
+set +e
+
+PORT_FILE="$PWD/.synthra-graph/mcp_port"
+if [ ! -f "$PORT_FILE" ]; then exit 0; fi
+PORT=$(cat "$PORT_FILE" 2>/dev/null | tr -d '[:space:]')
+if [ -z "$PORT" ]; then exit 0; fi
+
+PRIMER=$(curl -sS --max-time 3 "http://127.0.0.1:$PORT/prime" 2>/dev/null \\
+  | sed -n 's/.*"primer"[[:space:]]*:[[:space:]]*"\\(.*\\)".*/\\1/p' \\
+  | head -c 8000)
+
+if [ -n "$PRIMER" ]; then
+  printf '%b\\n' "$PRIMER"
+fi
+exit 0
+`;
+
+// src/hooks/scripts/pre-tool-use.ps1
+var pre_tool_use_default = '# PreToolUse hook \u2014 Windows PowerShell.\n# THE MOAT (improvement #1). Reads the tool call from stdin (JSON), POSTs it\n# to /gate, and if the server says "block" emits a JSON deny-decision to\n# stdout. Claude Code reads stdout JSON to enforce the decision.\n# Always exits 0; failure-to-reach-server leaves Claude untouched.\n\n$ErrorActionPreference = "SilentlyContinue"\n\n$raw = [Console]::In.ReadToEnd()\nif (-not $raw) { exit 0 }\n\ntry {\n    $hookInput = $raw | ConvertFrom-Json -ErrorAction Stop\n} catch {\n    exit 0\n}\n\n$portFile = Join-Path $PWD ".synthra-graph\\mcp_port"\nif (-not (Test-Path $portFile)) { exit 0 }\n$port = (Get-Content -Path $portFile -Raw).Trim()\nif (-not $port) { exit 0 }\n\n$payload = @{\n    tool_name  = $hookInput.tool_name\n    tool_input = $hookInput.tool_input\n} | ConvertTo-Json -Depth 10 -Compress\n\ntry {\n    $resp = Invoke-RestMethod -Uri "http://127.0.0.1:$port/gate" -Method POST `\n        -Body $payload -ContentType "application/json" -TimeoutSec 3\n} catch {\n    exit 0\n}\n\nif ($resp.decision -eq "block") {\n    $denyJson = @{\n        hookSpecificOutput = @{\n            hookEventName            = "PreToolUse"\n            permissionDecision       = "deny"\n            permissionDecisionReason = $resp.reason\n        }\n    } | ConvertTo-Json -Depth 5 -Compress\n    Write-Output $denyJson\n}\nexit 0\n';
+
+// src/hooks/scripts/pre-tool-use.sh
+var pre_tool_use_default2 = `#!/usr/bin/env bash
+# PreToolUse hook \u2014 bash. POSTs the tool call to /gate; if server returns
+# "block", emits the deny-decision JSON to stdout for Claude Code to enforce.
+# Always exits 0; server failures leave Claude untouched.
+
+set +e
+
+PORT_FILE="$PWD/.synthra-graph/mcp_port"
+if [ ! -f "$PORT_FILE" ]; then exit 0; fi
+PORT=$(cat "$PORT_FILE" 2>/dev/null | tr -d '[:space:]')
+if [ -z "$PORT" ]; then exit 0; fi
+
+INPUT=$(cat 2>/dev/null)
+if [ -z "$INPUT" ]; then exit 0; fi
+
+RESP=$(curl -sS --max-time 3 -X POST -H "Content-Type: application/json" \\
+  --data "$INPUT" "http://127.0.0.1:$PORT/gate" 2>/dev/null)
+
+case "$RESP" in
+  *'"decision":"block"'*)
+    REASON=$(printf '%s' "$RESP" | sed -n 's/.*"reason"[[:space:]]*:[[:space:]]*"\\(.*\\)".*/\\1/p')
+    cat <<EOF
+{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"\${REASON}"}}
+EOF
+    ;;
+esac
+exit 0
+`;
+
+// src/hooks/scripts/prime.ps1
+var prime_default = `# SessionStart + PreCompact hook \u2014 Windows PowerShell.
+# Reads .synthra-graph/mcp_port, calls GET /prime, prints the primer to stdout
+# (Claude Code appends stdout to the session's system prompt). Always exits 0;
+# any failure leaves Claude with the prompt it would have gotten without Synthra.
+
+$ErrorActionPreference = "SilentlyContinue"
+
+$portFile = Join-Path $PWD ".synthra-graph\\mcp_port"
+if (-not (Test-Path $portFile)) { exit 0 }
+$port = (Get-Content -Path $portFile -Raw).Trim()
+if (-not $port) { exit 0 }
+
+try {
+    $resp = Invoke-RestMethod -Uri "http://127.0.0.1:$port/prime" -Method GET -TimeoutSec 3
+    if ($resp.primer) { Write-Output $resp.primer }
+} catch {
+    # silent on failure \u2014 Claude continues without the primer
+}
+exit 0
+`;
+
+// src/hooks/scripts/prime.sh
+var prime_default2 = `#!/usr/bin/env bash
+# SessionStart + PreCompact hook \u2014 bash.
+# Reads .synthra-graph/mcp_port, calls GET /prime, prints the primer to stdout.
+# Always exits 0; any failure leaves Claude with the prompt it would have had
+# without Synthra.
+
+set +e
+
+PORT_FILE="$PWD/.synthra-graph/mcp_port"
+if [ ! -f "$PORT_FILE" ]; then exit 0; fi
+PORT=$(cat "$PORT_FILE" 2>/dev/null | tr -d '[:space:]')
+if [ -z "$PORT" ]; then exit 0; fi
+
+PRIMER=$(curl -sS --max-time 3 "http://127.0.0.1:$PORT/prime" 2>/dev/null \\
+  | sed -n 's/.*"primer"[[:space:]]*:[[:space:]]*"\\(.*\\)".*/\\1/p' \\
+  | head -c 8000)
+
+if [ -n "$PRIMER" ]; then
+  printf '%b\\n' "$PRIMER"
+fi
+exit 0
+`;
+
+// src/hooks/scripts/stop.ps1
+var stop_default = `# Stop hook \u2014 Windows PowerShell.
+# Reads Claude's transcript JSONL from $hookInput.transcript_path, sums
+# usage.* token counts across all assistant turns since the last offset, and
+# POSTs the totals to /log. Uses a per-transcript .stopoffset file to avoid
+# double-counting on session resume.
+
+$ErrorActionPreference = "SilentlyContinue"
+
+$raw = [Console]::In.ReadToEnd()
+if (-not $raw) { exit 0 }
+try { $hookInput = $raw | ConvertFrom-Json -ErrorAction Stop } catch { exit 0 }
+
+$transcript = $hookInput.transcript_path
+if (-not $transcript -or -not (Test-Path $transcript)) { exit 0 }
+
+$portFile = Join-Path $PWD ".synthra-graph\\mcp_port"
+if (-not (Test-Path $portFile)) { exit 0 }
+$port = (Get-Content -Path $portFile -Raw).Trim()
+if (-not $port) { exit 0 }
+
+$offsetFile = "$transcript.stopoffset"
+$startOffset = 0
+if (Test-Path $offsetFile) {
+    $val = (Get-Content -Path $offsetFile -Raw).Trim()
+    if ($val -match '^\\d+$') { $startOffset = [int]$val }
+}
+
+$lines = Get-Content -Path $transcript
+$inT = 0; $outT = 0; $cc = 0; $cr = 0; $model = ""
+$lineNum = 0
+foreach ($line in $lines) {
+    $lineNum++
+    if ($lineNum -le $startOffset) { continue }
+    if (-not $line) { continue }
+    try { $e = $line | ConvertFrom-Json -ErrorAction Stop } catch { continue }
+    $usage = $e.message.usage
+    if (-not $usage) { continue }
+    $inT  += [int]($usage.input_tokens               | ForEach-Object { if ($_) { $_ } else { 0 } })
+    $outT += [int]($usage.output_tokens              | ForEach-Object { if ($_) { $_ } else { 0 } })
+    $cc   += [int]($usage.cache_creation_input_tokens | ForEach-Object { if ($_) { $_ } else { 0 } })
+    $cr   += [int]($usage.cache_read_input_tokens     | ForEach-Object { if ($_) { $_ } else { 0 } })
+    if ($e.message.model) { $model = $e.message.model }
+}
+
+Set-Content -Path $offsetFile -Value $lineNum -Encoding ASCII
+
+if ($inT -eq 0 -and $outT -eq 0) { exit 0 }
+
+$payload = @{
+    input_tokens                = $inT
+    output_tokens               = $outT
+    cache_creation_input_tokens = $cc
+    cache_read_input_tokens     = $cr
+    model                       = $model
+    description                 = "synthra-stop-hook"
+    project                     = $PWD.Path
+} | ConvertTo-Json -Compress
+
+try {
+    Invoke-RestMethod -Uri "http://127.0.0.1:$port/log" -Method POST \`
+        -Body $payload -ContentType "application/json" -TimeoutSec 3 | Out-Null
+} catch {
+    # silent
+}
+
+# Refresh CONTEXT.md from the branch-scoped store.
+$ctxPayload = @{ transcript_path = $transcript } | ConvertTo-Json -Compress
+try {
+    Invoke-RestMethod -Uri "http://127.0.0.1:$port/context-update" -Method POST \`
+        -Body $ctxPayload -ContentType "application/json" -TimeoutSec 3 | Out-Null
+} catch {
+    # silent
+}
+exit 0
+`;
+
+// src/hooks/scripts/stop.sh
+var stop_default2 = `#!/usr/bin/env bash
+# Stop hook \u2014 bash. Reads transcript JSONL, sums usage.* across new lines,
+# POSTs totals to /log. Uses a .stopoffset file to avoid double-counting.
+# Requires \`jq\` for robust JSON parsing; falls back to silent no-op if absent.
+
+set +e
+
+INPUT=$(cat 2>/dev/null)
+if [ -z "$INPUT" ]; then exit 0; fi
+
+TRANSCRIPT=$(printf '%s' "$INPUT" | sed -n 's/.*"transcript_path"[[:space:]]*:[[:space:]]*"\\(.*\\)".*/\\1/p')
+if [ -z "$TRANSCRIPT" ] || [ ! -f "$TRANSCRIPT" ]; then exit 0; fi
+
+PORT_FILE="$PWD/.synthra-graph/mcp_port"
+if [ ! -f "$PORT_FILE" ]; then exit 0; fi
+PORT=$(cat "$PORT_FILE" 2>/dev/null | tr -d '[:space:]')
+if [ -z "$PORT" ]; then exit 0; fi
+
+if ! command -v jq >/dev/null 2>&1; then exit 0; fi
+
+OFFSET_FILE="\${TRANSCRIPT}.stopoffset"
+START_OFFSET=0
+if [ -f "$OFFSET_FILE" ]; then
+  START_OFFSET=$(cat "$OFFSET_FILE" 2>/dev/null | tr -d '[:space:]')
+  case "$START_OFFSET" in ''|*[!0-9]*) START_OFFSET=0 ;; esac
+fi
+
+TOTAL_LINES=$(wc -l < "$TRANSCRIPT" 2>/dev/null | tr -d ' ')
+TOTAL_LINES=\${TOTAL_LINES:-0}
+
+if [ "$TOTAL_LINES" -le "$START_OFFSET" ]; then exit 0; fi
+
+USAGE=$(tail -n +$((START_OFFSET + 1)) "$TRANSCRIPT" 2>/dev/null \\
+  | jq -s '
+      map(select(.message.usage != null) | .message)
+      | reduce .[] as $m (
+          {in:0, out:0, cc:0, cr:0, model:""};
+          .in    += ($m.usage.input_tokens // 0)
+          | .out += ($m.usage.output_tokens // 0)
+          | .cc  += ($m.usage.cache_creation_input_tokens // 0)
+          | .cr  += ($m.usage.cache_read_input_tokens // 0)
+          | .model = ($m.model // .model)
+        )
+    ' 2>/dev/null)
+
+printf '%s' "$TOTAL_LINES" > "$OFFSET_FILE"
+
+IN=$(printf '%s' "$USAGE" | jq -r '.in // 0')
+OUT=$(printf '%s' "$USAGE" | jq -r '.out // 0')
+CC=$(printf '%s' "$USAGE" | jq -r '.cc // 0')
+CR=$(printf '%s' "$USAGE" | jq -r '.cr // 0')
+MODEL=$(printf '%s' "$USAGE" | jq -r '.model // ""')
+
+if [ "$IN" = "0" ] && [ "$OUT" = "0" ]; then exit 0; fi
+
+curl -sS --max-time 3 -X POST -H "Content-Type: application/json" \\
+  --data "$(jq -nc --argjson i "$IN" --argjson o "$OUT" --argjson cc "$CC" --argjson cr "$CR" --arg m "$MODEL" --arg p "$PWD" \\
+    '{input_tokens:$i, output_tokens:$o, cache_creation_input_tokens:$cc, cache_read_input_tokens:$cr, model:$m, description:"synthra-stop-hook", project:$p}')" \\
+  "http://127.0.0.1:$PORT/log" >/dev/null 2>&1
+
+# Refresh CONTEXT.md from the branch-scoped store.
+curl -sS --max-time 3 -X POST -H "Content-Type: application/json" \\
+  --data "$(jq -nc --arg t "$TRANSCRIPT" '{transcript_path:$t}')" \\
+  "http://127.0.0.1:$PORT/context-update" >/dev/null 2>&1
+
+exit 0
+`;
+
+// src/hooks/installer.ts
+var SCRIPTS = [
+  { event: "SessionStart", baseName: "synthra-prime", ps1: prime_default, sh: prime_default2 },
+  { event: "PreToolUse", matcher: "Grep|Glob", baseName: "synthra-pre-tool-use", ps1: pre_tool_use_default, sh: pre_tool_use_default2 },
+  { event: "PreCompact", baseName: "synthra-pre-compact", ps1: pre_compact_default, sh: pre_compact_default2 },
+  { event: "Stop", baseName: "synthra-stop", ps1: stop_default, sh: stop_default2 }
+];
+var SYNTHRA_HOOK_MARKER = "synthra-hook=true";
+function commandFor(scriptPath) {
+  if (process.platform === "win32") {
+    return `powershell.exe -ExecutionPolicy Bypass -NoProfile -File "${scriptPath}"`;
+  }
+  return `bash "${scriptPath}"`;
+}
+function chosenScriptBody(s) {
+  return process.platform === "win32" ? s.ps1 : s.sh;
+}
+function chosenScriptExt() {
+  return process.platform === "win32" ? ".ps1" : ".sh";
+}
+async function readSettings(path) {
+  try {
+    const raw = await readFile3(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function stripOurHooks(config) {
+  if (!config.hooks) return config;
+  const next = {};
+  for (const [event, entries] of Object.entries(config.hooks)) {
+    const filtered = entries.map((entry) => ({
+      ...entry,
+      hooks: (entry.hooks ?? []).filter((h) => h.meta !== SYNTHRA_HOOK_MARKER)
+    })).filter((entry) => (entry.hooks?.length ?? 0) > 0);
+    if (filtered.length) next[event] = filtered;
+  }
+  config.hooks = next;
+  return config;
+}
+function mergeOurHooks(config, paths) {
+  const hooks = config.hooks = config.hooks ?? {};
+  for (const s of SCRIPTS) {
+    const scriptPath = join3(paths.claudeHooksDir, `${s.baseName}${chosenScriptExt()}`);
+    const entry = {
+      ...s.matcher ? { matcher: s.matcher } : {},
+      hooks: [
+        {
+          type: "command",
+          command: commandFor(scriptPath),
+          meta: SYNTHRA_HOOK_MARKER
+        }
+      ]
+    };
+    const list = hooks[s.event] = hooks[s.event] ?? [];
+    list.push(entry);
+  }
+  return config;
+}
+async function installHooks(paths) {
+  await mkdir2(paths.claudeHooksDir, { recursive: true });
+  const scriptsWritten = [];
+  for (const s of SCRIPTS) {
+    const target = join3(paths.claudeHooksDir, `${s.baseName}${chosenScriptExt()}`);
+    await writeFile2(target, chosenScriptBody(s), "utf8");
+    scriptsWritten.push(target);
+  }
+  await mkdir2(dirname2(paths.claudeSettings), { recursive: true });
+  const existing = await readSettings(paths.claudeSettings);
+  const stripped = stripOurHooks(existing);
+  const merged = mergeOurHooks(stripped, paths);
+  await writeFile2(paths.claudeSettings, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  log.debug(`installed ${scriptsWritten.length} hook script(s) into ${paths.claudeHooksDir}`);
+  return { scriptsWritten, settingsUpdated: true };
+}
+
+// src/server/http.ts
+import { serve as serve2 } from "@hono/node-server";
+import { Hono as Hono2 } from "hono";
+import { writeFile as writeFile8 } from "fs/promises";
+
+// src/activity/activity-log.ts
+import { appendFile, mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+var DEFAULT_RING_SIZE = 100;
+var ActivityStore = class {
+  ring = [];
+  maxRingSize;
+  persistPath;
+  constructor(persistPath, maxRingSize = DEFAULT_RING_SIZE) {
+    this.persistPath = persistPath;
+    this.maxRingSize = maxRingSize;
+  }
+  async add(event) {
+    this.ring.push(event);
+    while (this.ring.length > this.maxRingSize) this.ring.shift();
+    await this.persist(event);
+  }
+  /** Get events newer than `sinceMs` (epoch ms). If omitted, returns the full ring. */
+  getEvents(sinceMs) {
+    if (!sinceMs || !Number.isFinite(sinceMs)) return this.ring.slice();
+    const cutoff = new Date(sinceMs).toISOString();
+    return this.ring.filter((e) => e.ts >= cutoff);
+  }
+  /** Project-relative file paths that have a save/create event newer than `maxAgeMs` ms ago. */
+  recentFilePaths(maxAgeMs) {
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    const out = /* @__PURE__ */ new Set();
+    for (const e of this.ring) {
+      if ("path" in e && (e.kind === "save" || e.kind === "create") && e.ts >= cutoff) {
+        out.add(e.path);
+      }
+    }
+    return Array.from(out);
+  }
+  size() {
+    return this.ring.length;
+  }
+  async persist(event) {
+    try {
+      await mkdir3(dirname3(this.persistPath), { recursive: true });
+      await appendFile(this.persistPath, JSON.stringify(event) + "\n", "utf8");
+    } catch {
+    }
+  }
+};
+
+// src/activity/file-watcher.ts
+import chokidar from "chokidar";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join4, relative, sep } from "path";
+import ignore from "ignore";
+var ALWAYS_IGNORE = [
+  ".git",
+  ".synthra",
+  ".synthra-graph",
+  ".claude",
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".cache",
+  ".vscode",
+  ".idea"
+];
+async function readIgnoreFile(path) {
+  try {
+    const text = await readFile4(path, "utf8");
+    return text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+async function buildMatcher(root) {
+  const ig = ignore();
+  ig.add(ALWAYS_IGNORE.map((d) => `${d}/`));
+  ig.add(await readIgnoreFile(join4(root, ".gitignore")));
+  ig.add(await readIgnoreFile(join4(root, ".synthraignore")));
+  return ig;
+}
+function toPosixRel(root, abs) {
+  const rel = relative(root, abs);
+  return sep === "/" ? rel : rel.split(sep).join("/");
+}
+function createFileWatcher(root, onEvent) {
+  let watcher = null;
+  let ig = null;
+  const emit2 = async (kind, abs) => {
+    if (!ig) return;
+    const rel = toPosixRel(root, abs);
+    if (!rel || rel.startsWith("..")) return;
+    if (ig.ignores(rel)) return;
+    try {
+      await onEvent({ kind, path: rel, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    } catch {
+    }
+  };
+  return {
+    async start() {
+      ig = await buildMatcher(root);
+      watcher = chokidar.watch(root, {
+        // Cross-platform glob ignore. We match both the directory itself and
+        // anything inside it. picomatch (chokidar's matcher) normalizes path
+        // separators so a single set of forward-slash globs handles
+        // Windows + POSIX. Function-based ignore was unreliable on Windows
+        // and let chokidar descend into .git/, which crashed on transient
+        // index.lock files held exclusively by git.
+        ignored: ALWAYS_IGNORE.flatMap((d) => [`**/${d}`, `**/${d}/**`]),
+        ignoreInitial: true,
+        persistent: true,
+        awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
+      });
+      watcher.on("error", (err2) => {
+        const e = err2;
+        log.debug(`file watcher error (swallowed): ${e?.code ?? ""} ${e?.message ?? String(err2)}`);
+      });
+      watcher.on("add", (path) => emit2("create", path));
+      watcher.on("change", (path) => emit2("save", path));
+      watcher.on("unlink", (path) => emit2("delete", path));
+    },
+    async stop() {
+      if (watcher) {
+        await watcher.close();
+        watcher = null;
+      }
+    }
+  };
+}
+
+// src/activity/git-watcher.ts
+import { execFile } from "child_process";
+import { watch } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join5 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var POLL_MS = 2e3;
+async function readHeadBranch(projectRoot) {
+  try {
+    const head = await readFile5(join5(projectRoot, ".git", "HEAD"), "utf8");
+    const m = head.trim().match(/^ref:\s+refs\/heads\/(.+)$/);
+    return m?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function readStatusPorcelain(projectRoot) {
+  try {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain"], {
+      cwd: projectRoot
+    });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+function createGitWatcher(root, onEvent) {
+  let headWatcher = null;
+  let pollTimer = null;
+  let lastBranch = null;
+  let lastStatus = null;
+  const emitSafe = async (event) => {
+    try {
+      await onEvent(event);
+    } catch {
+    }
+  };
+  const checkHead = async () => {
+    const branch = await readHeadBranch(root);
+    if (branch && branch !== lastBranch) {
+      const prev = lastBranch;
+      lastBranch = branch;
+      if (prev !== null) {
+        await emitSafe({
+          kind: "branch-switch",
+          details: { from: prev, to: branch },
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+  };
+  const pollStatus = async () => {
+    const status = await readStatusPorcelain(root);
+    if (status === null) return;
+    if (lastStatus !== null && status !== lastStatus) {
+      const prevFiles = parseStatusFiles(lastStatus);
+      const nowFiles = parseStatusFiles(status);
+      const added = nowFiles.filter((f) => !prevFiles.includes(f));
+      const removed = prevFiles.filter((f) => !nowFiles.includes(f));
+      await emitSafe({
+        kind: "diff-change",
+        details: {
+          changed_count: nowFiles.length,
+          newly_dirty: added,
+          newly_clean: removed
+        },
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    lastStatus = status;
+  };
+  return {
+    async start() {
+      lastBranch = await readHeadBranch(root);
+      lastStatus = await readStatusPorcelain(root);
+      try {
+        headWatcher = watch(join5(root, ".git", "HEAD"), () => {
+          void checkHead();
+        });
+        headWatcher.on("error", () => {
+        });
+      } catch {
+      }
+      pollTimer = setInterval(() => {
+        void pollStatus();
+      }, POLL_MS);
+      pollTimer.unref?.();
+    },
+    async stop() {
+      if (headWatcher) {
+        headWatcher.close();
+        headWatcher = null;
+      }
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+    }
+  };
+}
+function parseStatusFiles(porcelain) {
+  return porcelain.split(/\r?\n/).map((l) => l.slice(3).trim()).filter((l) => l.length > 0);
+}
+
+// src/cli/scan-command.ts
+import { resolve } from "path";
+
+// src/scanner/extract.ts
+import { dirname as dirname4, join as join6, posix } from "path";
+
+// src/scanner/hash.ts
+import { createHash } from "crypto";
+function fileHash(content) {
+  return createHash("sha1").update(content).digest("hex").slice(0, 8);
+}
+
+// src/scanner/keywords.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "do",
+  "for",
+  "from",
+  "has",
+  "have",
+  "he",
+  "if",
+  "in",
+  "is",
+  "it",
+  "its",
+  "not",
+  "of",
+  "on",
+  "or",
+  "she",
+  "that",
+  "the",
+  "they",
+  "this",
+  "to",
+  "was",
+  "we",
+  "were",
+  "will",
+  "with",
+  "you",
+  "your",
+  "i",
+  "me",
+  "my",
+  "our",
+  "us",
+  "their",
+  "them",
+  "his",
+  "her",
+  // common code words that add no signal
+  "function",
+  "const",
+  "let",
+  "var",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "import",
+  "export",
+  "from",
+  "default",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "new",
+  "this",
+  "super",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "async",
+  "await",
+  "yield",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "void",
+  "any",
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array",
+  "self",
+  "cls",
+  "def",
+  "lambda",
+  "pass",
+  "raise",
+  "with",
+  "as",
+  "in",
+  "todo",
+  "fixme",
+  "note"
+]);
+var COMMON_CODE = /* @__PURE__ */ new Set([
+  "value",
+  "data",
+  "result",
+  "args",
+  "kwargs",
+  "options",
+  "config",
+  "params",
+  "name",
+  "id",
+  "key",
+  "index",
+  "item",
+  "items",
+  "list",
+  "map",
+  "set",
+  "get",
+  "set",
+  "add",
+  "remove",
+  "delete",
+  "create",
+  "update",
+  "find",
+  "fetch",
+  "load",
+  "save",
+  "init",
+  "main",
+  "run",
+  "start",
+  "stop",
+  "test",
+  "check",
+  "validate",
+  "error",
+  "err",
+  "warn",
+  "info",
+  "debug",
+  "log",
+  "trace",
+  "msg",
+  "message",
+  "path",
+  "file",
+  "dir",
+  "url",
+  "host",
+  "port",
+  "size",
+  "length",
+  "count",
+  "input",
+  "output",
+  "source",
+  "target",
+  "callback",
+  "handler",
+  "listener",
+  "props",
+  "state",
+  "context",
+  "render",
+  "component",
+  "node",
+  "tree",
+  "root"
+]);
+function score(token) {
+  if (STOPWORDS.has(token)) return 0;
+  if (COMMON_CODE.has(token)) return 0.2;
+  if (token.length <= 2) return 0.1;
+  return 1;
+}
+function splitIdentifier(id) {
+  const partsRaw = id.split(/[_\-./]+/).filter(Boolean);
+  const out = [];
+  for (const part of partsRaw) {
+    const camelParts = part.match(/[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|[0-9]+/g);
+    if (camelParts) out.push(...camelParts);
+    else out.push(part);
+  }
+  return out.map((w) => w.toLowerCase()).filter((w) => /[a-z]/.test(w));
+}
+function extractKeywords(content, _ext) {
+  const tokens = content.match(/[A-Za-z_][A-Za-z0-9_]{1,40}/g) ?? [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const tok of tokens) {
+    for (const word of splitIdentifier(tok)) {
+      const w = score(word);
+      if (w === 0) continue;
+      counts.set(word, (counts.get(word) ?? 0) + w);
+    }
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 32).map(([w]) => w);
+}
+
+// src/scanner/extract.ts
+var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".svelte", ".vue"];
+var INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.jsx", "__init__.py"];
+function fileId(relPath) {
+  return `file:${relPath}`;
+}
+function symbolId(relPath, sym) {
+  return `symbol:${relPath}::${sym.name}:${sym.startLine}`;
+}
+function toFileNode(parsed) {
+  const content = parsed.source;
+  return {
+    id: fileId(parsed.file.relPath),
+    kind: "file",
+    path: parsed.file.relPath,
+    ext: parsed.file.ext,
+    size: parsed.file.size,
+    keywords: extractKeywords(content, parsed.file.ext),
+    content,
+    summary: extractSummary(content),
+    file_hash: fileHash(content)
+  };
+}
+function extractSummary(content) {
+  const trimmed = content.replace(/^\s+/, "");
+  const slashMatch = trimmed.match(/^\/\/\s?(.*(?:\r?\n\/\/\s?.*)*)/);
+  if (slashMatch?.[1]) return slashMatch[1].split(/\r?\n/).join(" ").trim().slice(0, 200);
+  const blockMatch = trimmed.match(/^\/\*\*?([\s\S]*?)\*\//);
+  if (blockMatch?.[1]) {
+    return blockMatch[1].split(/\r?\n/).map((l) => l.replace(/^\s*\*\s?/, "")).join(" ").trim().slice(0, 200);
+  }
+  const hashMatch = trimmed.match(/^#\s?(.*(?:\r?\n#\s?.*)*)/);
+  if (hashMatch?.[1]) return hashMatch[1].split(/\r?\n/).join(" ").trim().slice(0, 200);
+  return "";
+}
+function toSymbolNode(parsed, sym) {
+  return {
+    id: symbolId(parsed.file.relPath, sym),
+    kind: "symbol",
+    symbol_kind: sym.kind,
+    name: sym.name,
+    file: parsed.file.relPath,
+    start_line: sym.startLine,
+    end_line: sym.endLine,
+    signature: sym.signature
+  };
+}
+var REWRITE_EXT_RE = /\.(js|jsx|mjs|cjs)$/;
+function resolveImport(fromRelPath, spec, filesByPath) {
+  if (!spec.startsWith(".")) return null;
+  const fromDir = posix.dirname(toPosix(fromRelPath));
+  const base = posix.normalize(posix.join(fromDir, toPosix(spec)));
+  const candidates = [base];
+  const rewritten = base.replace(REWRITE_EXT_RE, "");
+  if (rewritten !== base) candidates.push(rewritten);
+  for (const c of candidates) {
+    if (filesByPath.has(c)) return c;
+    for (const ext of RESOLVE_EXTS) {
+      if (filesByPath.has(c + ext)) return c + ext;
+    }
+    for (const idx of INDEX_FILES) {
+      const candidate = posix.join(c, idx);
+      if (filesByPath.has(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function toPosix(p) {
+  return p.split(/[\\/]/).join("/");
+}
+var TEST_RE = /^(?<base>.+?)\.(test|spec)\.(?<ext>[tj]sx?|py)$/;
+function testTarget(relPath, filesByPath) {
+  const fileName = relPath.split("/").pop() ?? relPath;
+  const match = TEST_RE.exec(fileName);
+  if (!match) return null;
+  const dir = relPath.includes("/") ? relPath.slice(0, relPath.lastIndexOf("/") + 1) : "";
+  const base = match.groups?.base ?? "";
+  const ext = match.groups?.ext ?? "";
+  if (!base || !ext) return null;
+  const candidate = `${dir}${base}.${ext}`;
+  if (filesByPath.has(candidate)) return candidate;
+  for (const e of RESOLVE_EXTS) {
+    const alt = `${dir}${base}${e}`;
+    if (filesByPath.has(alt)) return alt;
+  }
+  return null;
+}
+async function buildGraph(root, parsed) {
+  const filesByPath = /* @__PURE__ */ new Map();
+  for (const p of parsed) filesByPath.set(p.file.relPath, true);
+  const nodes = [];
+  const edges = [];
+  for (const p of parsed) {
+    const fileNode = toFileNode(p);
+    nodes.push(fileNode);
+    for (const sym of p.symbols) {
+      const symNode = toSymbolNode(p, sym);
+      nodes.push(symNode);
+      edges.push({ from: fileNode.id, to: symNode.id, kind: "defines" });
+    }
+    const importEdges = /* @__PURE__ */ new Set();
+    for (const spec of p.imports) {
+      const target = resolveImport(p.file.relPath, spec, filesByPath);
+      if (!target) continue;
+      const key = `${fileNode.id}->${fileId(target)}`;
+      if (importEdges.has(key)) continue;
+      importEdges.add(key);
+      edges.push({ from: fileNode.id, to: fileId(target), kind: "imports" });
+    }
+    const testTargetPath = testTarget(p.file.relPath, filesByPath);
+    if (testTargetPath && testTargetPath !== p.file.relPath) {
+      edges.push({ from: fileNode.id, to: fileId(testTargetPath), kind: "tests" });
+    }
+  }
+  const symbolCount = nodes.filter((n) => n.kind === "symbol").length;
+  const fileCount = nodes.length - symbolCount;
+  return {
+    root,
+    node_count: nodes.length,
+    edge_count: edges.length,
+    file_count: fileCount,
+    symbol_count: symbolCount,
+    nodes,
+    edges,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    schema_version: 1
+  };
+}
+function buildSymbolIndex(graph) {
+  const out = {};
+  for (const node of graph.nodes) {
+    if (node.kind !== "symbol") continue;
+    const list = out[node.name] ?? (out[node.name] = []);
+    list.push({ file: node.file, line: node.start_line, kind: node.symbol_kind });
+  }
+  return out;
+}
+
+// src/scanner/parser.ts
+import { readFile as readFile6 } from "fs/promises";
+import { createRequire } from "module";
+import Parser from "web-tree-sitter";
+
+// src/scanner/parsers/_generic.ts
+function firstLine(text, max = 200) {
+  const line = text.split(/\r?\n/, 1)[0] ?? "";
+  return line.length > max ? line.slice(0, max) + "\u2026" : line;
+}
+function cleanImport(s) {
+  return s.replace(/^["'`<]+|["'`>]+$/g, "").trim();
+}
+async function runGenericParser(config, f, source) {
+  let symbols = [];
+  let imports = [];
+  try {
+    const { parser, language } = await createParser(config.grammar);
+    const tree = parser.parse(source);
+    if (!tree) return { file: f, source, symbols, imports, calls: [] };
+    const query = language.query(config.query);
+    const matches = query.matches(tree.rootNode);
+    for (const match of matches) {
+      const byName = /* @__PURE__ */ new Map();
+      for (const cap of match.captures) byName.set(cap.name, cap.node);
+      let matched = null;
+      for (const d of config.decls) {
+        if (byName.has(d.declCapture) && byName.has(d.nameCapture)) {
+          matched = d;
+          break;
+        }
+      }
+      if (matched) {
+        const declNode = byName.get(matched.declCapture);
+        const nameNode = byName.get(matched.nameCapture);
+        symbols.push({
+          name: nameNode.text,
+          kind: matched.kind,
+          startLine: declNode.startPosition.row + 1,
+          endLine: declNode.endPosition.row + 1,
+          signature: firstLine(declNode.text)
+        });
+        continue;
+      }
+      if (config.importCapture) {
+        const imp = byName.get(config.importCapture);
+        if (imp) imports.push(cleanImport(imp.text));
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    symbols = symbols.filter((s) => {
+      const k = `${s.name}:${s.startLine}`;
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+    imports = Array.from(new Set(imports)).filter((s) => s.length > 0);
+  } catch {
+  }
+  return { file: f, source, symbols, imports, calls: [] };
+}
+
+// src/scanner/parsers/c.ts
+var QUERY = `
+(function_definition declarator: (function_declarator declarator: (identifier) @function.name)) @function
+(struct_specifier name: (type_identifier) @struct.name) @struct
+(enum_specifier name: (type_identifier) @enum.name) @enum
+(type_definition declarator: (type_identifier) @type.name) @type
+(preproc_include path: (string_literal) @import)
+(preproc_include path: (system_lib_string) @import)
+`;
+async function parseC(f, source) {
+  return runGenericParser(
+    {
+      grammar: "c",
+      query: QUERY,
+      decls: [
+        { declCapture: "function", nameCapture: "function.name", kind: "function" },
+        { declCapture: "struct", nameCapture: "struct.name", kind: "class" },
+        { declCapture: "enum", nameCapture: "enum.name", kind: "enum" },
+        { declCapture: "type", nameCapture: "type.name", kind: "type" }
+      ],
+      importCapture: "import"
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/cpp.ts
+var QUERY2 = `
+(function_definition declarator: (function_declarator declarator: (identifier) @function.name)) @function
+(function_definition declarator: (function_declarator declarator: (qualified_identifier) @method.name)) @method
+(class_specifier name: (type_identifier) @class.name) @class
+(struct_specifier name: (type_identifier) @struct.name) @struct
+(enum_specifier name: (type_identifier) @enum.name) @enum
+(namespace_definition name: (namespace_identifier) @namespace.name) @namespace
+(preproc_include path: (string_literal) @import)
+(preproc_include path: (system_lib_string) @import)
+`;
+async function parseCpp(f, source) {
+  return runGenericParser(
+    {
+      grammar: "cpp",
+      query: QUERY2,
+      decls: [
+        { declCapture: "function", nameCapture: "function.name", kind: "function" },
+        { declCapture: "method", nameCapture: "method.name", kind: "method" },
+        { declCapture: "class", nameCapture: "class.name", kind: "class" },
+        { declCapture: "struct", nameCapture: "struct.name", kind: "class" },
+        { declCapture: "enum", nameCapture: "enum.name", kind: "enum" },
+        { declCapture: "namespace", nameCapture: "namespace.name", kind: "class" }
+      ],
+      importCapture: "import"
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/csharp.ts
+var QUERY3 = `
+(class_declaration name: (identifier) @class.name) @class
+(interface_declaration name: (identifier) @interface.name) @interface
+(struct_declaration name: (identifier) @struct.name) @struct
+(enum_declaration name: (identifier) @enum.name) @enum
+(method_declaration name: (identifier) @method.name) @method
+(namespace_declaration name: (_) @namespace.name) @namespace
+(using_directive (_) @import)
+`;
+async function parseCSharp(f, source) {
+  return runGenericParser(
+    {
+      grammar: "csharp",
+      query: QUERY3,
+      decls: [
+        { declCapture: "class", nameCapture: "class.name", kind: "class" },
+        { declCapture: "interface", nameCapture: "interface.name", kind: "interface" },
+        { declCapture: "struct", nameCapture: "struct.name", kind: "class" },
+        { declCapture: "enum", nameCapture: "enum.name", kind: "enum" },
+        { declCapture: "method", nameCapture: "method.name", kind: "method" },
+        { declCapture: "namespace", nameCapture: "namespace.name", kind: "class" }
+      ],
+      importCapture: "import"
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/dart.ts
+var QUERY4 = `
+(class_definition (identifier) @class.name) @class
+(mixin_declaration (identifier) @class.name) @mixin
+(extension_declaration (identifier) @class.name) @ext
+(function_signature (identifier) @function.name) @function
+`;
+async function parseDart(f, source) {
+  return runGenericParser(
+    {
+      grammar: "dart",
+      query: QUERY4,
+      decls: [
+        { declCapture: "class", nameCapture: "class.name", kind: "class" },
+        { declCapture: "mixin", nameCapture: "class.name", kind: "class" },
+        { declCapture: "ext", nameCapture: "class.name", kind: "class" },
+        { declCapture: "function", nameCapture: "function.name", kind: "function" }
+      ]
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/go.ts
+var QUERY5 = `
+(function_declaration name: (identifier) @function.name) @function
+(method_declaration name: (field_identifier) @method.name) @method
+(type_spec name: (type_identifier) @type.name) @type
+(import_spec path: (interpreted_string_literal) @import)
+`;
+async function parseGo(f, source) {
+  return runGenericParser(
+    {
+      grammar: "go",
+      query: QUERY5,
+      decls: [
+        { declCapture: "function", nameCapture: "function.name", kind: "function" },
+        { declCapture: "method", nameCapture: "method.name", kind: "method" },
+        { declCapture: "type", nameCapture: "type.name", kind: "type" }
+      ],
+      importCapture: "import"
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/java.ts
+var QUERY6 = `
+(class_declaration name: (identifier) @class.name) @class
+(interface_declaration name: (identifier) @interface.name) @interface
+(method_declaration name: (identifier) @method.name) @method
+(enum_declaration name: (identifier) @enum.name) @enum
+(import_declaration (scoped_identifier) @import)
+`;
+async function parseJava(f, source) {
+  return runGenericParser(
+    {
+      grammar: "java",
+      query: QUERY6,
+      decls: [
+        { declCapture: "class", nameCapture: "class.name", kind: "class" },
+        { declCapture: "interface", nameCapture: "interface.name", kind: "interface" },
+        { declCapture: "method", nameCapture: "method.name", kind: "method" },
+        { declCapture: "enum", nameCapture: "enum.name", kind: "enum" }
+      ],
+      importCapture: "import"
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/kotlin.ts
+var QUERY7 = `
+(function_declaration (simple_identifier) @function.name) @function
+(class_declaration (type_identifier) @class.name) @class
+(object_declaration (type_identifier) @object.name) @object
+(import_header (identifier) @import)
+`;
+async function parseKotlin(f, source) {
+  return runGenericParser(
+    {
+      grammar: "kotlin",
+      query: QUERY7,
+      decls: [
+        { declCapture: "function", nameCapture: "function.name", kind: "function" },
+        { declCapture: "class", nameCapture: "class.name", kind: "class" },
+        { declCapture: "object", nameCapture: "object.name", kind: "class" }
+      ],
+      importCapture: "import"
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/php.ts
+var QUERY8 = `
+(function_definition name: (name) @function.name) @function
+(class_declaration name: (name) @class.name) @class
+(interface_declaration name: (name) @interface.name) @interface
+(trait_declaration name: (name) @trait.name) @trait
+(method_declaration name: (name) @method.name) @method
+`;
+async function parsePhp(f, source) {
+  return runGenericParser(
+    {
+      grammar: "php",
+      query: QUERY8,
+      decls: [
+        { declCapture: "function", nameCapture: "function.name", kind: "function" },
+        { declCapture: "class", nameCapture: "class.name", kind: "class" },
+        { declCapture: "interface", nameCapture: "interface.name", kind: "interface" },
+        { declCapture: "trait", nameCapture: "trait.name", kind: "class" },
+        { declCapture: "method", nameCapture: "method.name", kind: "method" }
+      ]
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/python.ts
+var QUERY9 = `
+(function_definition name: (identifier) @function.name) @function
+(class_definition name: (identifier) @class.name) @class
+(import_statement name: (dotted_name) @import.module)
+(import_from_statement module_name: (dotted_name) @import.from)
+(import_from_statement module_name: (relative_import) @import.from)
+`;
+function firstLine2(text, max = 200) {
+  const line = text.split(/\r?\n/, 1)[0] ?? "";
+  return line.length > max ? line.slice(0, max) + "\u2026" : line;
+}
+async function parsePython(f, source) {
+  let symbols = [];
+  let imports = [];
+  try {
+    const { parser, language } = await createParser("python");
+    const tree = parser.parse(source);
+    if (!tree) return { file: f, source, symbols, imports, calls: [] };
+    const query = language.query(QUERY9);
+    const matches = query.matches(tree.rootNode);
+    for (const match of matches) {
+      const byName = /* @__PURE__ */ new Map();
+      for (const cap of match.captures) byName.set(cap.name, cap.node);
+      const funcDecl = byName.get("function");
+      const funcName = byName.get("function.name");
+      if (funcDecl && funcName) {
+        const parentType = funcDecl.parent?.parent?.type;
+        const isMethod = parentType === "class_definition";
+        symbols.push({
+          name: funcName.text,
+          kind: isMethod ? "method" : "function",
+          startLine: funcDecl.startPosition.row + 1,
+          endLine: funcDecl.endPosition.row + 1,
+          signature: firstLine2(funcDecl.text)
+        });
+        continue;
+      }
+      const classDecl = byName.get("class");
+      const className = byName.get("class.name");
+      if (classDecl && className) {
+        symbols.push({
+          name: className.text,
+          kind: "class",
+          startLine: classDecl.startPosition.row + 1,
+          endLine: classDecl.endPosition.row + 1,
+          signature: firstLine2(classDecl.text)
+        });
+        continue;
+      }
+      const importNode = byName.get("import.module") ?? byName.get("import.from");
+      if (importNode) imports.push(importNode.text);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    symbols = symbols.filter((s) => {
+      const key = `${s.name}:${s.startLine}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    imports = Array.from(new Set(imports));
+  } catch {
+  }
+  return { file: f, source, symbols, imports, calls: [] };
+}
+
+// src/scanner/parsers/ruby.ts
+var QUERY10 = `
+(method name: (identifier) @function.name) @function
+(singleton_method name: (identifier) @method.name) @method
+(class name: (constant) @class.name) @class
+(module name: (constant) @module.name) @module
+`;
+async function parseRuby(f, source) {
+  return runGenericParser(
+    {
+      grammar: "ruby",
+      query: QUERY10,
+      decls: [
+        { declCapture: "function", nameCapture: "function.name", kind: "function" },
+        { declCapture: "method", nameCapture: "method.name", kind: "method" },
+        { declCapture: "class", nameCapture: "class.name", kind: "class" },
+        { declCapture: "module", nameCapture: "module.name", kind: "class" }
+      ]
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/rust.ts
+var QUERY11 = `
+(function_item name: (identifier) @function.name) @function
+(struct_item name: (type_identifier) @struct.name) @struct
+(enum_item name: (type_identifier) @enum.name) @enum
+(trait_item name: (type_identifier) @trait.name) @trait
+(impl_item type: (type_identifier) @impl.name) @impl
+`;
+async function parseRust(f, source) {
+  return runGenericParser(
+    {
+      grammar: "rust",
+      query: QUERY11,
+      decls: [
+        { declCapture: "function", nameCapture: "function.name", kind: "function" },
+        { declCapture: "struct", nameCapture: "struct.name", kind: "class" },
+        { declCapture: "enum", nameCapture: "enum.name", kind: "enum" },
+        { declCapture: "trait", nameCapture: "trait.name", kind: "interface" },
+        { declCapture: "impl", nameCapture: "impl.name", kind: "class" }
+      ]
+    },
+    f,
+    source
+  );
+}
+
+// src/scanner/parsers/typescript.ts
+var QUERY12 = `
+(function_declaration name: (identifier) @function.name) @function
+(class_declaration name: (type_identifier) @class.name) @class
+(interface_declaration name: (type_identifier) @interface.name) @interface
+(type_alias_declaration name: (type_identifier) @type.name) @type
+(enum_declaration name: (identifier) @enum.name) @enum
+(method_definition name: (property_identifier) @method.name) @method
+(lexical_declaration (variable_declarator name: (identifier) @const-fn.name value: [(arrow_function) (function_expression)])) @const-fn
+(import_statement source: (string) @import)
+`;
+function grammarFor(ext) {
+  if (ext === ".tsx" || ext === ".jsx") return "tsx";
+  if (ext === ".js" || ext === ".cjs" || ext === ".mjs") return "javascript";
+  return "typescript";
+}
+function unquote(s) {
+  return s.replace(/^["'`]|["'`]$/g, "");
+}
+function firstLine3(text, max = 200) {
+  const line = text.split(/\r?\n/, 1)[0] ?? "";
+  return line.length > max ? line.slice(0, max) + "\u2026" : line;
+}
+function shapeFromCaptures(captures) {
+  const findDecl = (k, sk) => {
+    const decl = captures.get(k);
+    const name = captures.get(`${k}.name`);
+    return decl && name ? { decl, name, kind: sk } : null;
+  };
+  return findDecl("function", "function") ?? findDecl("class", "class") ?? findDecl("interface", "interface") ?? findDecl("type", "type") ?? findDecl("enum", "enum") ?? findDecl("method", "method") ?? findDecl("const-fn", "function");
+}
+async function parseTypeScript(f, source) {
+  const grammar = grammarFor(f.ext);
+  let symbols = [];
+  let imports = [];
+  try {
+    const { parser, language } = await createParser(grammar);
+    const tree = parser.parse(source);
+    if (!tree) return { file: f, source, symbols, imports, calls: [] };
+    const query = language.query(QUERY12);
+    const matches = query.matches(tree.rootNode);
+    for (const match of matches) {
+      const byName = /* @__PURE__ */ new Map();
+      for (const cap of match.captures) byName.set(cap.name, cap.node);
+      const shape = shapeFromCaptures(byName);
+      if (shape) {
+        symbols.push({
+          name: shape.name.text,
+          kind: shape.kind,
+          startLine: shape.decl.startPosition.row + 1,
+          endLine: shape.decl.endPosition.row + 1,
+          signature: firstLine3(shape.decl.text)
+        });
+        continue;
+      }
+      const importNode = byName.get("import");
+      if (importNode) imports.push(unquote(importNode.text));
+    }
+    const seen = /* @__PURE__ */ new Set();
+    symbols = symbols.filter((s) => {
+      const key = `${s.name}:${s.startLine}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    imports = Array.from(new Set(imports));
+  } catch {
+  }
+  return { file: f, source, symbols, imports, calls: [] };
+}
+
+// src/scanner/parsers/svelte.ts
+var SCRIPT_RE = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+function extractScripts(source) {
+  const out = [];
+  for (const match of source.matchAll(SCRIPT_RE)) {
+    const full = match[0];
+    const inner = match[1] ?? "";
+    const openTag = full.slice(0, full.indexOf(">") + 1);
+    const tagStart = match.index ?? 0;
+    const contentStart = tagStart + openTag.length;
+    const startLine = source.slice(0, contentStart).split(/\r?\n/).length;
+    const isTsx = /\blang\s*=\s*["']?(ts|tsx|typescript)["']?/i.test(openTag);
+    out.push({ source: inner, startLine, isTsx });
+  }
+  return out;
+}
+async function parseSvelte(f, source) {
+  const blocks = extractScripts(source);
+  const out = { file: f, source, symbols: [], imports: [], calls: [] };
+  for (const block of blocks) {
+    const virtual = { ...f, ext: block.isTsx ? ".ts" : ".js" };
+    const parsed = await parseTypeScript(virtual, block.source);
+    const offset = block.startLine - 1;
+    for (const sym of parsed.symbols) {
+      out.symbols.push({
+        ...sym,
+        startLine: sym.startLine + offset,
+        endLine: sym.endLine + offset
+      });
+    }
+    for (const imp of parsed.imports) out.imports.push(imp);
+  }
+  out.symbols.push({
+    name: f.relPath.split("/").pop()?.replace(/\.svelte$/i, "") ?? f.relPath,
+    kind: "component",
+    startLine: 1,
+    endLine: source.split(/\r?\n/).length,
+    signature: f.relPath
+  });
+  out.imports = Array.from(new Set(out.imports));
+  return out;
+}
+
+// src/scanner/parsers/vue.ts
+var SCRIPT_RE2 = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+function extractScripts2(source) {
+  const out = [];
+  for (const match of source.matchAll(SCRIPT_RE2)) {
+    const full = match[0];
+    const inner = match[1] ?? "";
+    const openTag = full.slice(0, full.indexOf(">") + 1);
+    const tagStart = match.index ?? 0;
+    const contentStart = tagStart + openTag.length;
+    const startLine = source.slice(0, contentStart).split(/\r?\n/).length;
+    const isTs = /\blang\s*=\s*["']?(ts|tsx|typescript)["']?/i.test(openTag);
+    out.push({ source: inner, startLine, isTs });
+  }
+  return out;
+}
+async function parseVue(f, source) {
+  const blocks = extractScripts2(source);
+  const out = { file: f, source, symbols: [], imports: [], calls: [] };
+  for (const block of blocks) {
+    const virtual = { ...f, ext: block.isTs ? ".ts" : ".js" };
+    const parsed = await parseTypeScript(virtual, block.source);
+    const offset = block.startLine - 1;
+    for (const sym of parsed.symbols) {
+      out.symbols.push({
+        ...sym,
+        startLine: sym.startLine + offset,
+        endLine: sym.endLine + offset
+      });
+    }
+    for (const imp of parsed.imports) out.imports.push(imp);
+  }
+  out.symbols.push({
+    name: f.relPath.split("/").pop()?.replace(/\.vue$/i, "") ?? f.relPath,
+    kind: "component",
+    startLine: 1,
+    endLine: source.split(/\r?\n/).length,
+    signature: f.relPath
+  });
+  out.imports = Array.from(new Set(out.imports));
+  return out;
+}
+
+// src/scanner/parser.ts
+var require2 = createRequire(import.meta.url);
+var GRAMMAR_FILES = {
+  typescript: "tree-sitter-wasms/out/tree-sitter-typescript.wasm",
+  tsx: "tree-sitter-wasms/out/tree-sitter-tsx.wasm",
+  javascript: "tree-sitter-wasms/out/tree-sitter-javascript.wasm",
+  python: "tree-sitter-wasms/out/tree-sitter-python.wasm",
+  go: "tree-sitter-wasms/out/tree-sitter-go.wasm",
+  rust: "tree-sitter-wasms/out/tree-sitter-rust.wasm",
+  java: "tree-sitter-wasms/out/tree-sitter-java.wasm",
+  kotlin: "tree-sitter-wasms/out/tree-sitter-kotlin.wasm",
+  php: "tree-sitter-wasms/out/tree-sitter-php.wasm",
+  ruby: "tree-sitter-wasms/out/tree-sitter-ruby.wasm",
+  c: "tree-sitter-wasms/out/tree-sitter-c.wasm",
+  cpp: "tree-sitter-wasms/out/tree-sitter-cpp.wasm",
+  dart: "tree-sitter-wasms/out/tree-sitter-dart.wasm",
+  csharp: "tree-sitter-wasms/out/tree-sitter-c_sharp.wasm"
+};
+var parserInit = null;
+var languageCache = /* @__PURE__ */ new Map();
+async function ensureParserInit() {
+  if (!parserInit) {
+    parserInit = Parser.init();
+  }
+  return parserInit;
+}
+async function loadGrammar(name) {
+  await ensureParserInit();
+  const cached = languageCache.get(name);
+  if (cached) return cached;
+  const wasmPath = require2.resolve(GRAMMAR_FILES[name]);
+  const lang = await Parser.Language.load(wasmPath);
+  languageCache.set(name, lang);
+  return lang;
+}
+async function createParser(name) {
+  const language = await loadGrammar(name);
+  const parser = new Parser();
+  parser.setLanguage(language);
+  return { parser, language };
+}
+function emptyParsed(file, source) {
+  return { file, source, symbols: [], imports: [], calls: [] };
+}
+async function parseFile(f) {
+  let source;
+  try {
+    source = await readFile6(f.absPath, "utf8");
+  } catch {
+    return emptyParsed(f, "");
+  }
+  switch (f.ext) {
+    case ".ts":
+    case ".tsx":
+    case ".cts":
+    case ".mts":
+    case ".js":
+    case ".jsx":
+    case ".cjs":
+    case ".mjs":
+      return parseTypeScript(f, source);
+    case ".py":
+    case ".pyi":
+      return parsePython(f, source);
+    case ".svelte":
+      return parseSvelte(f, source);
+    case ".vue":
+      return parseVue(f, source);
+    case ".go":
+      return parseGo(f, source);
+    case ".rs":
+      return parseRust(f, source);
+    case ".java":
+      return parseJava(f, source);
+    case ".kt":
+    case ".kts":
+      return parseKotlin(f, source);
+    case ".php":
+      return parsePhp(f, source);
+    case ".rb":
+      return parseRuby(f, source);
+    case ".c":
+    case ".h":
+      return parseC(f, source);
+    case ".cpp":
+    case ".cc":
+    case ".cxx":
+    case ".hpp":
+    case ".hh":
+    case ".hxx":
+      return parseCpp(f, source);
+    case ".dart":
+      return parseDart(f, source);
+    case ".cs":
+      return parseCSharp(f, source);
+    default:
+      return emptyParsed(f, source);
+  }
+}
+
+// src/scanner/walker.ts
+import { readFile as readFile7, readdir, stat } from "fs/promises";
+import { extname, join as join7, relative as relative2, sep as sep2 } from "path";
+import ignore2 from "ignore";
+var DEFAULT_IGNORE = [
+  ".git/",
+  ".synthra/",
+  ".synthra-graph/",
+  ".claude/",
+  "node_modules/",
+  "dist/",
+  "build/",
+  "out/",
+  "coverage/",
+  ".next/",
+  ".nuxt/",
+  ".svelte-kit/",
+  ".turbo/",
+  ".cache/",
+  ".vscode/",
+  ".idea/"
+];
+var BINARY_EXTS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".svg",
+  ".ico",
+  ".bmp",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".7z",
+  ".rar",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".webm",
+  ".wav",
+  ".ogg",
+  ".ttf",
+  ".otf",
+  ".woff",
+  ".woff2",
+  ".eot",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".wasm",
+  ".lock",
+  ".lockb"
+]);
+async function readIgnoreFile2(path) {
+  try {
+    const text = await readFile7(path, "utf8");
+    return text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+async function buildMatcher2(root, extra) {
+  const ig = ignore2();
+  ig.add(DEFAULT_IGNORE);
+  ig.add(await readIgnoreFile2(join7(root, ".gitignore")));
+  ig.add(await readIgnoreFile2(join7(root, ".synthraignore")));
+  if (extra.length) ig.add(extra);
+  return ig;
+}
+function toPosix2(p) {
+  return sep2 === "/" ? p : p.split(sep2).join("/");
+}
+async function* walk(root, options = {}) {
+  const maxFileSize = options.maxFileSize ?? 2e6;
+  const ig = await buildMatcher2(root, options.extraIgnore ?? []);
+  async function* recurse(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = join7(dir, entry.name);
+      const rel = relative2(root, abs);
+      if (!rel) continue;
+      const relPosix = toPosix2(rel);
+      const matchPath = entry.isDirectory() ? `${relPosix}/` : relPosix;
+      if (ig.ignores(matchPath)) continue;
+      if (entry.isDirectory()) {
+        yield* recurse(abs);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase();
+        if (BINARY_EXTS.has(ext)) continue;
+        let size;
+        try {
+          const s = await stat(abs);
+          size = s.size;
+        } catch {
+          continue;
+        }
+        if (size > maxFileSize) continue;
+        yield { absPath: abs, relPath: relPosix, ext, size };
+      }
+    }
+  }
+  yield* recurse(root);
+}
+
+// src/graph/store.ts
+import { mkdir as mkdir4, readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+async function writeJson(path, data, pretty) {
+  await mkdir4(dirname5(path), { recursive: true });
+  const text = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  await writeFile3(path, text + "\n", "utf8");
+}
+async function readJson(path) {
+  const text = await readFile8(path, "utf8");
+  return JSON.parse(text);
+}
+async function writeGraph(path, graph) {
+  await writeJson(path, graph, false);
+}
+async function readGraph(path) {
+  return readJson(path);
+}
+async function writeSymbolIndex(path, index) {
+  await writeJson(path, index, true);
+}
+async function readSymbolIndex(path) {
+  return readJson(path);
+}
+
+// src/cli/bootstrap.ts
+import { mkdir as mkdir5, readFile as readFile10, stat as stat2, writeFile as writeFile5 } from "fs/promises";
+
+// src/hooks/claude-md.ts
+import { readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
+var POLICY_VERSION = 1;
+var POLICY_BEGIN = `<!-- synthra-policy v${POLICY_VERSION} BEGIN -->`;
+var POLICY_END = `<!-- synthra-policy v${POLICY_VERSION} END -->`;
+var ANY_BLOCK_RE = /<!--\s*synthra-policy\s+v\d+\s+BEGIN\s*-->[\s\S]*?<!--\s*synthra-policy\s+v\d+\s+END\s*-->\s*/g;
+function policyBlock() {
+  return [
+    POLICY_BEGIN,
+    "## Synthra context policy",
+    "",
+    "Synthra has pre-loaded a structured context pack into this session and",
+    "exposes the project's code graph through three MCP tools. **Prefer these",
+    "tools over Grep / Glob** \u2014 they are faster, cheaper, and already filtered",
+    "to relevant files.",
+    "",
+    "### Tools",
+    "",
+    "- **`graph_continue(query)`** \u2014 your default first move when you need",
+    "  project context. Returns signatures + top function bodies + linked test",
+    '  files, with a `confidence` label. If `confidence === "high"`, **stop**:',
+    "  do not call Grep/Glob for the same query.",
+    '- **`graph_read(target)`** \u2014 fetch source for a specific `"file/path.ts"`',
+    '  or `"file/path.ts::SymbolName"`. Use this once you know what you want.',
+    "- **`graph_register_edit(files)`** \u2014 after you edit files, call this so",
+    "  Synthra ranks them higher and avoids surfacing stale snapshots.",
+    "",
+    "### Rules",
+    "",
+    "1. Call `graph_continue` **before** Grep / Glob for any question about",
+    "   project code. Grep / Glob calls for the same query may be blocked at",
+    "   the hook layer when the graph already has a confident answer.",
+    '2. When `graph_continue` returns `confidence: "high"`, treat the pack as',
+    "   authoritative \u2014 don't second-guess it with a Grep.",
+    "3. Use `graph_read` instead of `Read` when you only need a specific symbol",
+    "   from a file (you get less noise + line numbers).",
+    "4. After editing files, call `graph_register_edit(files)` so subsequent",
+    "   turns weight your changes correctly.",
+    "",
+    "_This block is managed by Synthra. Edits inside the BEGIN/END markers",
+    "are overwritten on every `syn .` run._",
+    "",
+    POLICY_END
+  ].join("\n");
+}
+async function patchClaudeMd(path) {
+  let existing;
+  try {
+    existing = await readFile9(path, "utf8");
+  } catch {
+    existing = null;
+  }
+  const block = policyBlock();
+  if (existing === null) {
+    await writeFile4(path, block + "\n", "utf8");
+    return { created: true, updated: false, skipped: false };
+  }
+  const stripped = existing.replace(ANY_BLOCK_RE, "");
+  const hadBlock = stripped !== existing;
+  const desired = stripped.endsWith("\n") ? stripped + "\n" + block + "\n" : (stripped.length ? stripped + "\n\n" : "") + block + "\n";
+  if (hadBlock && desired === existing) {
+    return { created: false, updated: false, skipped: true };
+  }
+  await writeFile4(path, desired, "utf8");
+  return { created: false, updated: true, skipped: false };
+}
+
+// src/cli/bootstrap.ts
+var GITIGNORE_MARKER = "# added by synthra";
+var GITIGNORE_ENTRY = ".synthra-graph/";
+async function exists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  const had = await exists(path);
+  await mkdir5(path, { recursive: true });
+  return !had;
+}
+async function patchGitignore(path) {
+  let existing = "";
+  try {
+    existing = await readFile10(path, "utf8");
+  } catch {
+  }
+  const lines = existing.split(/\r?\n/);
+  if (lines.some((l) => l.trim() === GITIGNORE_ENTRY)) return false;
+  const appendix = (existing.length === 0 || existing.endsWith("\n") ? "" : "\n") + (existing.length ? "\n" : "") + `${GITIGNORE_MARKER}
+${GITIGNORE_ENTRY}
+`;
+  await writeFile5(path, existing + appendix, "utf8");
+  return true;
+}
+async function bootstrap(paths) {
+  const graphCreated = await ensureDir(paths.graphDir);
+  const contextCreated = await ensureDir(paths.contextDir);
+  const gitignoreUpdated = await patchGitignore(paths.gitignore);
+  const claudeMdExistedBefore = await exists(paths.claudeMd);
+  const patch = await patchClaudeMd(paths.claudeMd);
+  return {
+    graphCreated,
+    contextCreated,
+    gitignoreUpdated,
+    claudeMdUpdated: patch.updated,
+    claudeMdCreated: patch.created && !claudeMdExistedBefore
+  };
+}
+
+// src/cli/scan-command.ts
+var PARSABLE_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".cts",
+  ".mts",
+  ".js",
+  ".jsx",
+  ".cjs",
+  ".mjs",
+  ".py",
+  ".pyi",
+  ".svelte",
+  ".vue",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".php",
+  ".rb",
+  ".c",
+  ".h",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".dart",
+  ".cs"
+]);
+async function scanProject(projectRootRaw, opts = {}) {
+  const projectRoot = resolve(projectRootRaw);
+  const paths = resolvePaths(projectRoot);
+  const start = Date.now();
+  const verbose = !opts.silent;
+  if (verbose) log.info(`scanning ${projectRoot}`);
+  const boot = await bootstrap(paths);
+  if (verbose) {
+    if (boot.graphCreated) log.info("  created .synthra-graph/");
+    if (boot.contextCreated) log.info("  created .synthra/");
+    if (boot.gitignoreUpdated) log.info("  updated .gitignore");
+    if (boot.claudeMdCreated) log.info("  created CLAUDE.md");
+    else if (boot.claudeMdUpdated) log.info("  updated CLAUDE.md");
+  }
+  const walked = [];
+  for await (const file of walk(projectRoot)) walked.push(file);
+  if (verbose) log.info(`  walked ${walked.length} files`);
+  const parsable = walked.filter((f) => PARSABLE_EXTS.has(f.ext));
+  const parsed = [];
+  let parseErrors = 0;
+  for (const file of parsable) {
+    try {
+      parsed.push(await parseFile(file));
+    } catch (err2) {
+      parseErrors += 1;
+      if (verbose) log.debug(`    parse failed: ${file.relPath} \u2014 ${err2.message}`);
+    }
+  }
+  if (verbose) {
+    log.info(
+      `  parsed ${parsed.length} files (${walked.length - parsable.length} skipped` + (parseErrors ? `, ${parseErrors} errored` : "") + ")"
+    );
+  }
+  const graph = await buildGraph(projectRoot, parsed);
+  const symbolIndex = buildSymbolIndex(graph);
+  await writeGraph(paths.infoGraph, graph);
+  await writeSymbolIndex(paths.symbolIndex, symbolIndex);
+  if (verbose) {
+    log.info(
+      `  wrote ${paths.infoGraph} \u2014 ${graph.symbol_count} symbols, ${graph.edge_count} edges`
+    );
+    log.info(`  wrote ${paths.symbolIndex} \u2014 ${Object.keys(symbolIndex).length} names`);
+  }
+  const durationMs = Date.now() - start;
+  if (verbose) log.info(`done in ${(durationMs / 1e3).toFixed(2)}s`);
+  return {
+    walked: walked.length,
+    parsed: parsed.length,
+    symbolCount: graph.symbol_count,
+    edgeCount: graph.edge_count,
+    durationMs
+  };
+}
+async function scanCommand(rawPath) {
+  return scanProject(rawPath);
+}
+
+// src/graph/rank.ts
+var STOPWORDS2 = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "have",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "was",
+  "we",
+  "with",
+  "what",
+  "where",
+  "when",
+  "why",
+  "how",
+  "do",
+  "does",
+  "i",
+  "me",
+  "my",
+  "you",
+  "your",
+  "code",
+  "file"
+]);
+function tokenizeQuery(query) {
+  const tokens = query.toLowerCase().split(/[^a-z0-9_]+/g).filter((t) => t.length > 1 && !STOPWORDS2.has(t));
+  const expanded = /* @__PURE__ */ new Set();
+  for (const t of tokens) {
+    expanded.add(t);
+    const parts = t.match(/[a-z]+|[0-9]+/g) ?? [];
+    for (const p of parts) if (p.length > 1) expanded.add(p);
+  }
+  return Array.from(expanded);
+}
+function indexSymbolsByFile(graph) {
+  const out = /* @__PURE__ */ new Map();
+  if (!graph) return out;
+  for (const n of graph.nodes) {
+    if (n.kind !== "symbol") continue;
+    const list = out.get(n.file) ?? [];
+    list.push(n);
+    out.set(n.file, list);
+  }
+  return out;
+}
+function indexImportEdges(graph) {
+  const out = /* @__PURE__ */ new Map();
+  if (!graph) return out;
+  const idToPath = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) if (n.kind === "file") idToPath.set(n.id, n.path);
+  for (const e of graph.edges) {
+    if (e.kind !== "imports") continue;
+    const from = idToPath.get(e.from);
+    const to = idToPath.get(e.to);
+    if (!from || !to) continue;
+    const s = out.get(from) ?? /* @__PURE__ */ new Set();
+    s.add(to);
+    out.set(from, s);
+  }
+  return out;
+}
+function scoreFiles(inputs) {
+  const qTokens = new Set(tokenizeQuery(inputs.query));
+  const symbolsByFile = indexSymbolsByFile(inputs.graph);
+  const importsFrom = indexImportEdges(inputs.graph);
+  const seeds = new Set(inputs.sessionKnownPaths ?? []);
+  for (const p of inputs.recentlyEditedPaths ?? []) seeds.add(p);
+  const scored = [];
+  for (const file of inputs.candidates) {
+    const reasons = [];
+    let score2 = 0;
+    let kwHits = 0;
+    for (const kw of file.keywords) if (qTokens.has(kw)) kwHits += 1;
+    if (kwHits) {
+      score2 += kwHits * 2;
+      reasons.push(`kw=${kwHits}`);
+    }
+    const symbols = symbolsByFile.get(file.path) ?? [];
+    let symHits = 0;
+    for (const sym of symbols) {
+      const name = sym.name.toLowerCase();
+      if (qTokens.has(name)) {
+        symHits += 3;
+      } else {
+        for (const t of qTokens) {
+          if (name.includes(t) || t.includes(name)) {
+            symHits += 1;
+            break;
+          }
+        }
+      }
+    }
+    if (symHits) {
+      score2 += symHits;
+      reasons.push(`sym=${symHits}`);
+    }
+    const pathLower = file.path.toLowerCase();
+    let pathHits = 0;
+    for (const t of qTokens) if (pathLower.includes(t)) pathHits += 1;
+    if (pathHits) {
+      score2 += pathHits;
+      reasons.push(`path=${pathHits}`);
+    }
+    if (seeds.has(file.path)) {
+      score2 += 5;
+      reasons.push("seed");
+    }
+    scored.push({ file, score: score2, reasons });
+  }
+  const positivePaths = new Set(scored.filter((s) => s.score > 0).map((s) => s.file.path));
+  if (positivePaths.size > 0) {
+    for (const s of scored) {
+      if (s.score > 0) continue;
+      let importBoost = 0;
+      for (const [from, tos] of importsFrom) {
+        if (!positivePaths.has(from)) continue;
+        if (tos.has(s.file.path)) {
+          importBoost += 1;
+          break;
+        }
+      }
+      if (importBoost) {
+        s.score += importBoost * 0.5;
+        s.reasons.push("imp-adj");
+      }
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored;
+}
+
+// src/graph/retrieve.ts
+async function retrieve(graph, query, options = {}) {
+  const topK = options.topK ?? 12;
+  const qTokens = tokenizeQuery(query);
+  const allFiles = graph.nodes.filter(
+    (n) => n.kind === "file"
+  );
+  if (allFiles.length === 0 || qTokens.length === 0) {
+    return {
+      files: [],
+      confidence: "low",
+      reason: qTokens.length === 0 ? "empty query" : "empty graph"
+    };
+  }
+  const rankInputs = {
+    candidates: allFiles,
+    query,
+    graph,
+    recentlyEditedPaths: options.recentlyEditedPaths,
+    sessionKnownPaths: options.sessionKnownPaths
+  };
+  const scored = scoreFiles(rankInputs);
+  const positive = scored.filter((s) => s.score > 0);
+  if (positive.length === 0) {
+    return {
+      files: [],
+      confidence: "low",
+      reason: `no matches for ${JSON.stringify(qTokens)}`
+    };
+  }
+  const top = positive.slice(0, topK).map((s) => s.file);
+  const topScore = positive[0]?.score ?? 0;
+  const secondScore = positive[1]?.score ?? 0;
+  let confidence;
+  if (positive.length === 1) confidence = "high";
+  else if (topScore >= 6 && topScore >= secondScore * 2) confidence = "high";
+  else if (topScore >= 3) confidence = "medium";
+  else confidence = "low";
+  const reasons = positive.slice(0, Math.min(3, top.length)).map((s) => `${s.file.path} (${s.reasons.join(",")})`).join("; ");
+  return {
+    files: top,
+    confidence,
+    reason: `top: ${reasons}`
+  };
+}
+
+// src/memory/branches.ts
+import { execFile as execFile2 } from "child_process";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join8 } from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function currentBranch(projectRoot) {
+  try {
+    const headPath = join8(projectRoot, ".git", "HEAD");
+    const head = await readFile11(headPath, "utf8");
+    const trimmed = head.trim();
+    const match = trimmed.match(/^ref:\s+refs\/heads\/(.+)$/);
+    if (match?.[1]) return match[1];
+  } catch {
+  }
+  try {
+    const { stdout } = await execFileAsync2("git", ["branch", "--show-current"], {
+      cwd: projectRoot
+    });
+    const name = stdout.trim();
+    if (name) return name;
+  } catch {
+  }
+  return "main";
+}
+async function defaultBranch(projectRoot) {
+  try {
+    const { stdout } = await execFileAsync2(
+      "git",
+      ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"],
+      { cwd: projectRoot }
+    );
+    const trimmed = stdout.trim();
+    const match = trimmed.match(/^origin\/(.+)$/);
+    if (match?.[1]) return match[1];
+  } catch {
+  }
+  return "main";
+}
+function sanitizeBranchName(name) {
+  return name.replaceAll("/", "-").replaceAll("\\", "-");
+}
+function resolveBranchPaths(contextDir, branch, isDefault) {
+  if (isDefault) {
+    return {
+      contextStore: join8(contextDir, "context-store.json"),
+      contextMd: join8(contextDir, "CONTEXT.md"),
+      branchDir: null
+    };
+  }
+  const branchDir = join8(contextDir, "branches", sanitizeBranchName(branch));
+  return {
+    contextStore: join8(branchDir, "context-store.json"),
+    contextMd: join8(branchDir, "CONTEXT.md"),
+    branchDir
+  };
+}
+
+// src/memory/context-md.ts
+import { mkdir as mkdir6, readFile as readFile12, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+var MAX_BULLETS = 3;
+function deriveContextMd(entries, branch) {
+  const tasks = entries.filter((e) => e.type === "task").reverse();
+  const currentTask = tasks[0]?.content ?? "";
+  const keyDecisions = entries.filter((e) => e.type === "decision").slice(-MAX_BULLETS).map((e) => e.content);
+  const nextSteps = entries.filter((e) => e.type === "next").slice(-MAX_BULLETS).map((e) => e.content);
+  return {
+    branch,
+    currentTask,
+    keyDecisions,
+    nextSteps,
+    date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function formatContextMd(ctx) {
+  const lines = [];
+  lines.push(`# Context \u2014 ${ctx.branch}`);
+  lines.push("");
+  lines.push(`_Updated: ${ctx.date}_`);
+  lines.push("");
+  if (ctx.currentTask) {
+    lines.push(`## Current task`);
+    lines.push(ctx.currentTask);
+    lines.push("");
+  }
+  if (ctx.keyDecisions.length) {
+    lines.push(`## Key decisions`);
+    for (const d of ctx.keyDecisions) lines.push(`- ${d}`);
+    lines.push("");
+  }
+  if (ctx.nextSteps.length) {
+    lines.push(`## Next steps`);
+    for (const n of ctx.nextSteps) lines.push(`- ${n}`);
+    lines.push("");
+  }
+  if (!ctx.currentTask && !ctx.keyDecisions.length && !ctx.nextSteps.length) {
+    lines.push("_(no context entries yet \u2014 use `context_remember` to add one)_");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function writeContextMd(path, ctx) {
+  await mkdir6(dirname6(path), { recursive: true });
+  await writeFile6(path, formatContextMd(ctx), "utf8");
+}
+
+// src/memory/context-store.ts
+import { mkdir as mkdir7, readFile as readFile13, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname7 } from "path";
+var SCHEMA_VERSION2 = 1;
+async function readEntries(path) {
+  try {
+    const raw = await readFile13(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.entries) ? parsed.entries : [];
+  } catch {
+    return [];
+  }
+}
+async function writeEntries(path, entries) {
+  await mkdir7(dirname7(path), { recursive: true });
+  const store = { schema_version: SCHEMA_VERSION2, entries };
+  await writeFile7(path, JSON.stringify(store, null, 2) + "\n", "utf8");
+}
+async function appendEntry(path, entry) {
+  const entries = await readEntries(path);
+  entries.push(entry);
+  await writeEntries(path, entries);
+}
+
+// src/memory/index.ts
+async function resolveActiveBranch(paths, override) {
+  const branch = override ?? await currentBranch(paths.projectRoot);
+  const def = await defaultBranch(paths.projectRoot);
+  const isDefault = branch === def;
+  return {
+    branch,
+    isDefault,
+    paths: resolveBranchPaths(paths.contextDir, branch, isDefault)
+  };
+}
+async function rememberEntry(paths, input) {
+  const active = await resolveActiveBranch(paths);
+  const entry = {
+    type: input.kind,
+    content: input.text,
+    tags: input.tags ?? [],
+    files: input.files ?? [],
+    date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await appendEntry(active.paths.contextStore, entry);
+  const entries = await readEntries(active.paths.contextStore);
+  const md = deriveContextMd(entries, active.branch);
+  await writeContextMd(active.paths.contextMd, md);
+  return {
+    entry,
+    branch: active.branch,
+    storePath: active.paths.contextStore,
+    contextMdPath: active.paths.contextMd
+  };
+}
+async function recallEntries(paths, input = {}) {
+  const active = await resolveActiveBranch(paths, input.branch);
+  let entries = await readEntries(active.paths.contextStore);
+  if (input.kind) entries = entries.filter((e) => e.type === input.kind);
+  if (input.limit && input.limit > 0) entries = entries.slice(-input.limit);
+  return {
+    branch: active.branch,
+    entries,
+    storePath: active.paths.contextStore
+  };
+}
+async function refreshContextMd(paths, branchOverride) {
+  const active = await resolveActiveBranch(paths, branchOverride);
+  const entries = await readEntries(active.paths.contextStore);
+  const md = deriveContextMd(entries, active.branch);
+  await writeContextMd(active.paths.contextMd, md);
+  return {
+    branch: active.branch,
+    path: active.paths.contextMd,
+    entriesSeen: entries.length
+  };
+}
+
+// src/packer/format.ts
+function formatPack(inputs) {
+  const parts = [];
+  parts.push(`# Synthra context \u2014 query: ${JSON.stringify(inputs.query)}
+`);
+  if (inputs.files.length === 0) {
+    parts.push("> No matching files found in the graph.\n");
+  }
+  for (const f of inputs.files) {
+    const heading = f.reason ? `## ${f.path}  _(${f.reason})_` : `## ${f.path}`;
+    parts.push(heading);
+    if (f.signatures.length === 0) {
+      parts.push("_(no symbols extracted)_");
+    } else {
+      parts.push("**Signatures:**");
+      for (const s of f.signatures) parts.push(`- ${s}`);
+    }
+    if (f.inlineBodies.trim().length > 0) {
+      parts.push("");
+      parts.push("**Bodies:**");
+      parts.push("```");
+      parts.push(f.inlineBodies.trimEnd());
+      parts.push("```");
+    }
+    if (f.associatedTests?.length) {
+      parts.push("");
+      parts.push(`**Tests:** ${f.associatedTests.join(", ")}`);
+    }
+    parts.push("");
+  }
+  if (inputs.recentActivity?.trim()) {
+    parts.push("---");
+    parts.push("## Recent human activity");
+    parts.push(inputs.recentActivity.trim());
+    parts.push("");
+  }
+  if (inputs.truncated) {
+    parts.push("> _(pack truncated to fit budget)_");
+  }
+  return parts.join("\n");
+}
+
+// src/packer/inline.ts
+var INLINABLE_KINDS = /* @__PURE__ */ new Set(["function", "method", "class"]);
+var MAX_BODY_CHARS = 1500;
+function sliceLines(content, startLine, endLine) {
+  const lines = content.split(/\r?\n/);
+  return lines.slice(Math.max(0, startLine - 1), endLine).join("\n");
+}
+function scoreSymbol(name, qTokens) {
+  const lower = name.toLowerCase();
+  if (qTokens.has(lower)) return 3;
+  for (const t of qTokens) {
+    if (lower.includes(t) || t.includes(lower)) return 1;
+  }
+  return 0;
+}
+function truncate(body) {
+  if (body.length <= MAX_BODY_CHARS) return body;
+  return body.slice(0, MAX_BODY_CHARS).trimEnd() + "\n  // \u2026 truncated";
+}
+function selectInlineBodies(file, symbols, query, budgetChars) {
+  if (budgetChars <= 0) {
+    return { text: "", charsUsed: 0, functionsInlined: [] };
+  }
+  const qTokens = new Set(tokenizeQuery(query));
+  const mine = symbols.filter((s) => s.file === file.path && INLINABLE_KINDS.has(s.symbol_kind));
+  const scored = mine.map((s) => ({ sym: s, score: scoreSymbol(s.name, qTokens) })).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    const aSpan = a.sym.end_line - a.sym.start_line || 1;
+    const bSpan = b.sym.end_line - b.sym.start_line || 1;
+    return aSpan - bSpan;
+  });
+  const parts = [];
+  const inlined = [];
+  let used = 0;
+  for (const { sym, score: score2 } of scored) {
+    if (score2 === 0 && inlined.length > 0) break;
+    const body = truncate(sliceLines(file.content, sym.start_line, sym.end_line));
+    const header = `${file.path}::${sym.name} (L${sym.start_line}-${sym.end_line})`;
+    const block = `${header}
+${body}
+`;
+    if (used + block.length > budgetChars) {
+      if (inlined.length > 0) break;
+      const remaining = Math.max(0, budgetChars - used - header.length - 16);
+      if (remaining <= 0) break;
+      const partial = body.slice(0, remaining).trimEnd() + "\n  // \u2026 truncated";
+      const finalBlock = `${header}
+${partial}
+`;
+      parts.push(finalBlock);
+      inlined.push(sym.name);
+      used += finalBlock.length;
+      break;
+    }
+    parts.push(block);
+    inlined.push(sym.name);
+    used += block.length;
+  }
+  return { text: parts.join("\n"), charsUsed: used, functionsInlined: inlined };
+}
+
+// src/packer/signatures.ts
+function extractSignatures(file, symbols) {
+  const mine = symbols.filter((s) => s.file === file.path).slice().sort((a, b) => a.start_line - b.start_line);
+  return mine.map((s) => `L${s.start_line}: ${s.signature.trim()}`);
+}
+
+// src/packer/tests.ts
+function findTestsForFile(graph, file) {
+  const fileNodesById = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) {
+    if (n.kind === "file") fileNodesById.set(n.id, n);
+  }
+  const out = [];
+  for (const e of graph.edges) {
+    if (e.kind !== "tests" || e.to !== file.id) continue;
+    const testFile = fileNodesById.get(e.from);
+    if (testFile && !out.includes(testFile)) out.push(testFile);
+  }
+  return out;
+}
+
+// src/packer/index.ts
+var STATIC_OVERHEAD_PER_FILE = 200;
+var MAX_INLINE_CHARS_PER_FILE = 2500;
+function indexSymbolsByFile2(graph) {
+  return graph.nodes.filter((n) => n.kind === "symbol");
+}
+async function pack(files, opts) {
+  const budgetTokens = opts.budgetTokens ?? 4e3;
+  const budgetChars = budgetTokens * 4;
+  const inlineRatio = opts.inlineBodyRatio ?? 0.5;
+  const includeTests = opts.includeTests ?? true;
+  const reasons = opts.reasons ?? /* @__PURE__ */ new Map();
+  const symbols = indexSymbolsByFile2(opts.graph);
+  const sections = [];
+  const testsCoRetrieved = [];
+  let used = 0;
+  let truncated = false;
+  for (const file of files) {
+    const sig = extractSignatures(file, symbols);
+    const testFiles = includeTests ? findTestsForFile(opts.graph, file) : [];
+    const testPaths = testFiles.map((t) => t.path);
+    const staticCost = file.path.length + sig.join("\n").length + testPaths.join(",").length + STATIC_OVERHEAD_PER_FILE;
+    if (used + staticCost > budgetChars) {
+      truncated = true;
+      break;
+    }
+    const remaining = budgetChars - used - staticCost;
+    const inlineBudget = Math.min(Math.floor(remaining * inlineRatio), MAX_INLINE_CHARS_PER_FILE);
+    const inline = selectInlineBodies(file, symbols, opts.query, inlineBudget);
+    sections.push({
+      path: file.path,
+      reason: reasons.get(file.path),
+      signatures: sig,
+      inlineBodies: inline.text,
+      associatedTests: testPaths
+    });
+    used += staticCost + inline.charsUsed;
+    for (const t of testPaths) if (!testsCoRetrieved.includes(t)) testsCoRetrieved.push(t);
+    if (used >= budgetChars) {
+      truncated = true;
+      break;
+    }
+  }
+  if (sections.length < files.length) truncated = true;
+  const text = formatPack({
+    query: opts.query,
+    files: sections,
+    truncated
+  });
+  const tokenEstimate = Math.ceil(text.length / 4);
+  return {
+    text,
+    tokenEstimate,
+    filesUsed: sections.map((s) => s.path),
+    testsCoRetrieved,
+    truncated
+  };
+}
+
+// src/server/mcp.ts
+var PROTOCOL_VERSION = "2024-11-05";
+var SERVER_INFO = { name: "synthra", version: "0.0.1" };
+var ERR = {
+  parse: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internal: -32603
+};
+function ok(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function err(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: { code, message, data } };
+}
+function textContent(text) {
+  return { content: [{ type: "text", text }], isError: false };
+}
+function errorContent(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+var TOOLS = [
+  {
+    name: "graph_continue",
+    description: "Returns the project context most relevant to a query \u2014 function signatures, top function bodies, and linked test files. Use this BEFORE Grep/Glob. If `confidence` is 'high', do not call Grep/Glob for the same query.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Natural-language description of what you're looking for." }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "graph_read",
+    description: "Return the source code for a specific file or symbol. Target is either a project-relative file path (e.g. 'src/auth.ts') or 'file::symbol' (e.g. 'src/auth.ts::AuthService').",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "File path or file::symbol notation." }
+      },
+      required: ["target"]
+    }
+  },
+  {
+    name: "graph_register_edit",
+    description: "Tell Synthra that you (the AI) have edited these files. Lets Synthra rank them higher in subsequent retrieval and avoid surfacing stale context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Project-relative file paths that were edited."
+        }
+      },
+      required: ["files"]
+    }
+  },
+  {
+    name: "context_remember",
+    description: "Persist a decision/task/next-step/fact/blocker into the project's branch-aware context store. Use when the user makes a decision worth keeping, identifies a TODO, or surfaces a key fact. Entries land in `.synthra/context-store.json` on the default branch, or `.synthra/branches/<sanitized>/context-store.json` on a feature branch \u2014 git-tracked, so teammates inherit them and they merge naturally.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "The thing to remember (1\u20133 sentences)." },
+        kind: {
+          type: "string",
+          enum: ["decision", "task", "next", "fact", "blocker"],
+          description: "What kind of entry. Required."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional tags for grouping (e.g. 'auth', 'perf')."
+        },
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional project-relative file paths this entry relates to."
+        }
+      },
+      required: ["text", "kind"]
+    }
+  },
+  {
+    name: "context_recall",
+    description: "Read previously-stored decisions/tasks/facts from the project's branch-aware context store. Defaults to the current branch.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: {
+          type: "string",
+          enum: ["decision", "task", "next", "fact", "blocker"],
+          description: "Filter to a single kind."
+        },
+        branch: { type: "string", description: "Override which branch to read from." },
+        limit: { type: "number", description: "Return only the most recent N entries." }
+      }
+    }
+  },
+  {
+    name: "recent_activity",
+    description: "What has the human been doing in the editor recently \u2014 file saves, branch switches, and uncommitted-diff changes. Use this to check whether the static context pack may be stale (e.g. before answering a question about a file that was just edited).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        since_ms: {
+          type: "number",
+          description: "Epoch milliseconds. Only return events newer than this. Defaults to the last 60 minutes."
+        },
+        limit: { type: "number", description: "Cap on returned events." }
+      }
+    }
+  },
+  {
+    name: "count_tokens",
+    description: "Estimate token count for a piece of text using a char/4 approximation. Accurate within ~10% for English + code. Useful for budgeting prompt content before sending.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "The text to estimate tokens for." }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "blast_radius",
+    description: "Given a file (or 'file::symbol' target), return all files that depend on it transitively via imports + tests edges. Use BEFORE editing a widely-used file to see what could break. Symbol-level granularity is approximated at the file level (we don't track call edges in v0.1).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "File path or 'file::symbol' notation." },
+        depth: { type: "number", description: "Max hops to traverse. Default 3." }
+      },
+      required: ["target"]
+    }
+  },
+  {
+    name: "dead_code",
+    description: "Return files in the project that no other file imports and no test file references \u2014 strong candidates for unused/orphaned code. File-level granularity (v0.1 limitation \u2014 symbol-level needs call-graph edges). Common entry-point patterns (main, index, app, CLI, bin/) are excluded heuristically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Cap on returned files. Default 50." }
+      }
+    }
+  }
+];
+async function callTool(name, args, ctx) {
+  switch (name) {
+    case "graph_continue":
+      return graphContinue(args, ctx);
+    case "graph_read":
+      return graphRead(args, ctx);
+    case "graph_register_edit":
+      return graphRegisterEdit(args, ctx);
+    case "context_remember":
+      return contextRemember(args, ctx);
+    case "context_recall":
+      return contextRecall(args, ctx);
+    case "recent_activity":
+      return recentActivity(args, ctx);
+    case "count_tokens":
+      return countTokens(args);
+    case "blast_radius":
+      return blastRadius(args, ctx);
+    case "dead_code":
+      return deadCode(args, ctx);
+    default:
+      return errorContent(`Unknown tool: ${name}`);
+  }
+}
+function countTokens(args) {
+  const text = typeof args?.text === "string" ? args.text : "";
+  if (!text) return errorContent("count_tokens: 'text' (string) is required");
+  const tokens = Math.ceil(text.length / 4);
+  return textContent(JSON.stringify({ tokens, method: "chars/4 estimate", chars: text.length }));
+}
+function blastRadius(args, ctx) {
+  const targetRaw = typeof args?.target === "string" ? args.target.trim() : "";
+  const maxDepth = typeof args?.depth === "number" && args.depth > 0 ? Math.floor(args.depth) : 3;
+  if (!targetRaw) return errorContent("blast_radius: 'target' (string) is required");
+  const filePath = targetRaw.split("::", 1)[0]?.trim() ?? targetRaw;
+  const root = ctx.graph.nodes.find(
+    (n) => n.kind === "file" && n.path === filePath
+  );
+  if (!root) return errorContent(`blast_radius: file not in graph: ${filePath}`);
+  const incoming = /* @__PURE__ */ new Map();
+  for (const e of ctx.graph.edges) {
+    if (e.kind !== "imports" && e.kind !== "tests") continue;
+    const list = incoming.get(e.to) ?? [];
+    list.push({ from: e.from, kind: e.kind });
+    incoming.set(e.to, list);
+  }
+  const visited = /* @__PURE__ */ new Set([root.id]);
+  const hits = [];
+  const pathById = /* @__PURE__ */ new Map();
+  for (const n of ctx.graph.nodes) if (n.kind === "file") pathById.set(n.id, n.path);
+  let frontier = [root.id];
+  for (let d = 1; d <= maxDepth; d++) {
+    const next = [];
+    for (const cur of frontier) {
+      const callers = incoming.get(cur) ?? [];
+      for (const c of callers) {
+        if (visited.has(c.from)) continue;
+        visited.add(c.from);
+        next.push(c.from);
+        const path = pathById.get(c.from) ?? c.from;
+        hits.push({ path, depth: d, via: c.kind });
+      }
+    }
+    frontier = next;
+    if (next.length === 0) break;
+  }
+  if (hits.length === 0) {
+    return textContent(`# Blast radius for ${filePath}
+
+_(no dependents \u2014 file is isolated)_`);
+  }
+  hits.sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path));
+  const lines = [`# Blast radius for ${filePath}  (depth \u2264 ${maxDepth})`, ""];
+  lines.push(`${hits.length} dependent file(s):`);
+  for (const h of hits) {
+    lines.push(`- **depth ${h.depth}** \`${h.path}\` _(via ${h.via})_`);
+  }
+  return textContent(lines.join("\n"));
+}
+var LIKELY_ENTRY_PATTERNS = [
+  /(?:^|\/)main\.[a-z0-9_]+$/i,
+  /(?:^|\/)index\.[a-z0-9_]+$/i,
+  /(?:^|\/)app\.[a-z0-9_]+$/i,
+  /(?:^|\/)entry\.[a-z0-9_]+$/i,
+  /(?:^|\/)cli[\/.]/i,
+  /(?:^|\/)bin[\/.]/i,
+  /(?:^|\/)server\.[a-z0-9_]+$/i,
+  /\.test\.[a-z0-9_]+$/i,
+  /\.spec\.[a-z0-9_]+$/i,
+  /(?:^|\/)tests?\//i,
+  /(?:^|\/)__tests__\//i,
+  /(?:^|\/)__init__\.py$/i
+];
+function isLikelyEntry(path) {
+  return LIKELY_ENTRY_PATTERNS.some((re) => re.test(path));
+}
+function deadCode(args, ctx) {
+  const limit = typeof args?.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 50;
+  const hasIncoming = /* @__PURE__ */ new Set();
+  for (const e of ctx.graph.edges) {
+    if (e.kind === "imports" || e.kind === "tests") hasIncoming.add(e.to);
+  }
+  const candidates = ctx.graph.nodes.filter((n) => n.kind === "file").filter((f) => !hasIncoming.has(f.id)).filter((f) => !isLikelyEntry(f.path));
+  if (candidates.length === 0) {
+    return textContent(
+      `# Dead code
+
+_(no file is unreferenced \u2014 every file is either imported by another, has a linked test, or matches an entry-point pattern)_`
+    );
+  }
+  candidates.sort((a, b) => a.path.localeCompare(b.path));
+  const shown = candidates.slice(0, limit);
+  const lines = [`# Dead code candidates  (file-level, v0.1)`, ""];
+  lines.push(
+    `${shown.length} of ${candidates.length} unreferenced file(s) \u2014 no other file imports them and no test links them:`
+  );
+  lines.push("");
+  for (const f of shown) {
+    lines.push(`- \`${f.path}\``);
+  }
+  lines.push("");
+  lines.push(
+    `_v0.1 caveat:_ this is file-level only. Symbol-level dead code (unused exports) needs call-graph edges, which land in v0.2.`
+  );
+  return textContent(lines.join("\n"));
+}
+async function graphContinue(args, ctx) {
+  const query = typeof args?.query === "string" ? args.query : "";
+  if (!query) return errorContent("graph_continue: 'query' (string) is required");
+  const retrieval = await retrieve(ctx.graph, query);
+  const packed = await pack(retrieval.files, { query, graph: ctx.graph });
+  const header = `Confidence: ${retrieval.confidence}
+Files: ${retrieval.files.map((f) => f.path).join(", ") || "(none)"}
+Reason: ${retrieval.reason}
+`;
+  return textContent(`${header}
+${packed.text}`);
+}
+function graphRead(args, ctx) {
+  const target = typeof args?.target === "string" ? args.target : "";
+  if (!target) return errorContent("graph_read: 'target' (string) is required");
+  const [rawFile, symbolName] = target.includes("::") ? target.split("::", 2) : [target, void 0];
+  const filePath = (rawFile ?? "").trim();
+  const fileNode = ctx.graph.nodes.find(
+    (n) => n.kind === "file" && n.path === filePath
+  );
+  if (!fileNode) return errorContent(`graph_read: file not found in graph: ${filePath}`);
+  if (!symbolName) {
+    return textContent(`# ${fileNode.path}
+
+${fileNode.content}`);
+  }
+  const cleanSym = symbolName.trim();
+  const symbol = ctx.graph.nodes.find(
+    (n) => n.kind === "symbol" && n.file === filePath && n.name === cleanSym
+  );
+  if (!symbol) {
+    return errorContent(`graph_read: symbol '${cleanSym}' not found in ${filePath}`);
+  }
+  const lines = fileNode.content.split(/\r?\n/);
+  const body = lines.slice(symbol.start_line - 1, symbol.end_line).join("\n");
+  return textContent(
+    `# ${fileNode.path}::${symbol.name}  (L${symbol.start_line}-${symbol.end_line})
+
+${body}`
+  );
+}
+var editedFiles = /* @__PURE__ */ new Set();
+function graphRegisterEdit(args, _ctx) {
+  const files = Array.isArray(args?.files) ? args.files.filter((f) => typeof f === "string") : [];
+  for (const f of files) editedFiles.add(f);
+  return textContent(`Registered ${files.length} edited file(s). Total tracked this session: ${editedFiles.size}.`);
+}
+var VALID_KINDS = /* @__PURE__ */ new Set(["decision", "task", "next", "fact", "blocker"]);
+async function contextRemember(args, ctx) {
+  const text = typeof args?.text === "string" ? args.text.trim() : "";
+  const kindRaw = typeof args?.kind === "string" ? args.kind : "";
+  if (!text) return errorContent("context_remember: 'text' (string) is required");
+  if (!VALID_KINDS.has(kindRaw)) {
+    return errorContent(
+      `context_remember: 'kind' must be one of ${Array.from(VALID_KINDS).join(", ")}`
+    );
+  }
+  const tags = Array.isArray(args?.tags) ? args.tags.filter((t) => typeof t === "string") : [];
+  const files = Array.isArray(args?.files) ? args.files.filter((f) => typeof f === "string") : [];
+  const result = await rememberEntry(ctx.paths, {
+    text,
+    kind: kindRaw,
+    tags,
+    files
+  });
+  return textContent(
+    `Remembered ${result.entry.type} on branch '${result.branch}'.
+Stored: ${result.storePath}
+CONTEXT.md refreshed: ${result.contextMdPath}`
+  );
+}
+var DEFAULT_RECENT_WINDOW_MS = 60 * 60 * 1e3;
+function recentActivity(args, ctx) {
+  const sinceMs = typeof args?.since_ms === "number" && Number.isFinite(args.since_ms) ? args.since_ms : Date.now() - DEFAULT_RECENT_WINDOW_MS;
+  const limit = typeof args?.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : void 0;
+  let events = ctx.activity.getEvents(sinceMs);
+  if (limit) events = events.slice(-limit);
+  if (events.length === 0) {
+    return textContent(
+      `No human-activity events since ${new Date(sinceMs).toISOString()}.`
+    );
+  }
+  const lines = [`# Recent human activity (${events.length} events)`, ""];
+  for (const e of events) {
+    if ("path" in e) {
+      lines.push(`- **${e.kind}** ${e.path}  _(${e.ts})_`);
+    } else {
+      const summary = JSON.stringify(e.details);
+      lines.push(`- **${e.kind}** ${summary}  _(${e.ts})_`);
+    }
+  }
+  return textContent(lines.join("\n"));
+}
+async function contextRecall(args, ctx) {
+  const kind = typeof args?.kind === "string" && VALID_KINDS.has(args.kind) ? args.kind : void 0;
+  const branch = typeof args?.branch === "string" ? args.branch : void 0;
+  const limit = typeof args?.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : void 0;
+  const result = await recallEntries(ctx.paths, { kind, branch, limit });
+  if (result.entries.length === 0) {
+    const filter = kind ? ` of kind '${kind}'` : "";
+    return textContent(`No context entries${filter} on branch '${result.branch}'.`);
+  }
+  const lines = [`# Context entries \u2014 branch: ${result.branch}`, ""];
+  for (const e of result.entries) {
+    const tags = e.tags.length ? ` [${e.tags.join(", ")}]` : "";
+    lines.push(`- **${e.type}**${tags} (${e.date}): ${e.content}`);
+    if (e.files.length) lines.push(`  files: ${e.files.join(", ")}`);
+  }
+  return textContent(lines.join("\n"));
+}
+async function handleMcpRequest(body, ctx) {
+  if (!body || typeof body !== "object") {
+    return err(null, ERR.invalidRequest, "Request body must be a JSON-RPC 2.0 object.");
+  }
+  const req = body;
+  if (req.jsonrpc !== "2.0" || typeof req.method !== "string") {
+    return err(req.id ?? null, ERR.invalidRequest, "Invalid JSON-RPC envelope.");
+  }
+  const id = req.id ?? null;
+  try {
+    switch (req.method) {
+      case "initialize":
+        return ok(id, {
+          protocolVersion: typeof req.params?.protocolVersion === "string" ? req.params.protocolVersion : PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo: SERVER_INFO
+        });
+      case "notifications/initialized":
+        return ok(id, {});
+      case "tools/list":
+        return ok(id, { tools: TOOLS });
+      case "tools/call": {
+        const params = req.params ?? {};
+        const toolName = typeof params.name === "string" ? params.name : "";
+        if (!toolName) return err(id, ERR.invalidParams, "'name' is required for tools/call.");
+        const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
+        const result = await callTool(toolName, args, ctx);
+        return ok(id, result);
+      }
+      case "ping":
+        return ok(id, {});
+      default:
+        return err(id, ERR.methodNotFound, `Method not found: ${req.method}`);
+    }
+  } catch (e) {
+    return err(id, ERR.internal, e.message);
+  }
+}
+
+// src/server/routes/activity.ts
+async function handleActivity(sinceMs, ctx) {
+  const events = ctx.activity.getEvents(sinceMs);
+  return {
+    events,
+    since: new Date(sinceMs ?? Date.now()).toISOString(),
+    ring_size: ctx.activity.size()
+  };
+}
+
+// src/server/routes/context-update.ts
+async function handleContextUpdate(req, ctx) {
+  const r = await refreshContextMd(ctx.paths, req?.branch);
+  return {
+    updated: true,
+    branch: r.branch,
+    path: r.path,
+    entries: r.entriesSeen
+  };
+}
+
+// src/server/routes/gate.ts
+import { appendFile as appendFile2, mkdir as mkdir8 } from "fs/promises";
+import { dirname as dirname8 } from "path";
+var BLOCKABLE_TOOLS = /* @__PURE__ */ new Set(["Grep", "Glob"]);
+var RECENT_ACTIVITY_WINDOW_MS = 5 * 60 * 1e3;
+function extractQuery(toolName, input) {
+  if (toolName === "Grep") {
+    const pattern = typeof input.pattern === "string" ? input.pattern : "";
+    const query = typeof input.query === "string" ? input.query : "";
+    return (pattern || query).trim() || null;
+  }
+  if (toolName === "Glob") {
+    const pattern = typeof input.pattern === "string" ? input.pattern : "";
+    return pattern.replace(/[*?/\\.]+/g, " ").trim() || null;
+  }
+  return null;
+}
+function recentlyTouchedMatchesQuery(recentPaths, queryTokens) {
+  const matches = [];
+  for (const path of recentPaths) {
+    const lower = path.toLowerCase();
+    for (const t of queryTokens) {
+      if (lower.includes(t)) {
+        matches.push(path);
+        break;
+      }
+    }
+  }
+  return matches;
+}
+async function logDecision(ctx, toolName, query, decision, reason) {
+  try {
+    await mkdir8(dirname8(ctx.paths.gateLog), { recursive: true });
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      tool: toolName,
+      decision,
+      query,
+      reason
+    };
+    await appendFile2(ctx.paths.gateLog, JSON.stringify(entry) + "\n", "utf8");
+  } catch {
+  }
+}
+async function handleGate(req, ctx) {
+  if (!req?.tool_name || typeof req.tool_name !== "string") {
+    return { decision: "allow", reason: "no tool_name" };
+  }
+  if (!BLOCKABLE_TOOLS.has(req.tool_name)) {
+    return { decision: "allow" };
+  }
+  const input = req.tool_input && typeof req.tool_input === "object" ? req.tool_input : {};
+  const query = extractQuery(req.tool_name, input);
+  if (!query) {
+    const res2 = { decision: "allow", reason: "no extractable query" };
+    await logDecision(ctx, req.tool_name, null, res2.decision, res2.reason);
+    return res2;
+  }
+  const retrieval = await retrieve(ctx.graph, query);
+  if (retrieval.confidence === "low") {
+    const res2 = {
+      decision: "allow",
+      reason: `confidence=low \u2014 no graph context for "${query}", letting ${req.tool_name} through`
+    };
+    await logDecision(ctx, req.tool_name, query, res2.decision, res2.reason);
+    return res2;
+  }
+  const qTokens = new Set(tokenizeQuery(query));
+  const recentPaths = ctx.activity.recentFilePaths(RECENT_ACTIVITY_WINDOW_MS);
+  const overlap = recentlyTouchedMatchesQuery(recentPaths, qTokens);
+  if (overlap.length > 0) {
+    const res2 = {
+      decision: "allow",
+      reason: `confidence=${retrieval.confidence} but human just touched ${overlap.slice(0, 3).join(", ")} \u2014 static context may be stale, letting ${req.tool_name} through.`
+    };
+    await logDecision(ctx, req.tool_name, query, res2.decision, res2.reason);
+    return res2;
+  }
+  const top = retrieval.files.slice(0, 3).map((f) => f.path).join(", ");
+  const res = {
+    decision: "block",
+    reason: `Synthra has ${retrieval.confidence}-confidence context for "${query}" (top files: ${top}). Use the \`graph_continue\` MCP tool with this query instead of ${req.tool_name}, or read a specific file/symbol with \`graph_read\`.`
+  };
+  await logDecision(ctx, req.tool_name, query, res.decision, res.reason);
+  return res;
+}
+
+// src/server/routes/log.ts
+import { appendFile as appendFile3, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname9 } from "path";
+async function handleLog(entry, ctx) {
+  if (!entry || typeof entry.input_tokens !== "number" || typeof entry.output_tokens !== "number") {
+    throw new Error("log: input_tokens and output_tokens (number) are required");
+  }
+  const written_at = (/* @__PURE__ */ new Date()).toISOString();
+  const record = { ...entry, written_at };
+  await mkdir9(dirname9(ctx.paths.tokenLog), { recursive: true });
+  await appendFile3(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
+  return { ok: true, written_at };
+}
+
+// src/server/routes/pack.ts
+async function handlePack(req, ctx) {
+  if (!req?.query || typeof req.query !== "string") {
+    throw new Error("pack: 'query' (string) is required");
+  }
+  const recentlyEditedPaths = ctx.activity.recentFilePaths(15 * 60 * 1e3);
+  const retrieval = await retrieve(ctx.graph, req.query, { recentlyEditedPaths });
+  const allFiles = ctx.graph.nodes.filter((n) => n.kind === "file");
+  const scored = scoreFiles({
+    candidates: allFiles,
+    query: req.query,
+    graph: ctx.graph,
+    recentlyEditedPaths
+  });
+  const reasons = /* @__PURE__ */ new Map();
+  for (const s of scored) {
+    if (s.reasons.length) reasons.set(s.file.path, s.reasons.join(","));
+  }
+  const result = await pack(retrieval.files, {
+    query: req.query,
+    graph: ctx.graph,
+    budgetTokens: req.maxTokens,
+    includeTests: req.includeTests,
+    reasons
+  });
+  return {
+    ...result,
+    query: req.query,
+    confidence: retrieval.confidence,
+    retrievalReason: retrieval.reason
+  };
+}
+
+// src/server/routes/prime.ts
+async function handlePrime(ctx, port) {
+  const g = ctx.graph;
+  const fileCount = g.file_count;
+  const symbolCount = g.symbol_count;
+  const primer = `Synthra context loaded for ${g.root}.
+${fileCount} files indexed, ${symbolCount} symbols. Prefer the graph_* MCP tools over Grep/Glob for navigation.
+(Full primer wired in M3.)`;
+  return { primer, port };
+}
+
+// src/server/http.ts
+async function loadContext(paths) {
+  try {
+    const [graph, symbolIndex] = await Promise.all([
+      readGraph(paths.infoGraph),
+      readSymbolIndex(paths.symbolIndex)
+    ]);
+    const activity = new ActivityStore(paths.activityLog);
+    return { paths, graph, symbolIndex, activity };
+  } catch (err2) {
+    throw new Error(
+      `failed to load graph from ${paths.infoGraph}: ${err2.message}. Run \`syn scan\` first.`
+    );
+  }
+}
+function buildApp(ctx, port) {
+  const app = new Hono2();
+  app.get(
+    "/",
+    (c) => c.json({
+      service: "synthra",
+      version: "0.0.1",
+      port,
+      file_count: ctx.graph.file_count,
+      symbol_count: ctx.graph.symbol_count,
+      generated_at: ctx.graph.generated_at
+    })
+  );
+  app.get("/health", (c) => c.json({ ok: true }));
+  app.get("/prime", async (c) => c.json(await handlePrime(ctx, port)));
+  app.post("/pack", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    return c.json(await handlePack(body, ctx));
+  });
+  app.post("/log", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    return c.json(await handleLog(body, ctx));
+  });
+  app.post("/gate", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    return c.json(await handleGate(body, ctx));
+  });
+  app.get("/activity", async (c) => {
+    const sinceParam = c.req.query("since");
+    const sinceMs = sinceParam ? Number(sinceParam) : void 0;
+    return c.json(
+      await handleActivity(Number.isFinite(sinceMs) ? sinceMs : void 0, ctx)
+    );
+  });
+  app.post("/context-update", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    return c.json(await handleContextUpdate(body, ctx));
+  });
+  app.post("/mcp", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    return c.json(await handleMcpRequest(body, ctx));
+  });
+  app.onError((err2, c) => {
+    log.error("route error:", err2.message);
+    return c.json({ error: err2.message }, 400);
+  });
+  return app;
+}
+async function startServer(paths, options = {}) {
+  const ctx = await loadContext(paths);
+  const port = options.port ?? await findFreePort();
+  const app = buildApp(ctx, port);
+  const nodeServer = serve2({ fetch: app.fetch, port, hostname: "127.0.0.1" });
+  await writeFile8(paths.mcpPort, String(port), "utf8");
+  const fileWatcher = createFileWatcher(
+    paths.projectRoot,
+    (e) => ctx.activity.add(e)
+  );
+  const gitWatcher = createGitWatcher(paths.projectRoot, async (e) => {
+    await ctx.activity.add(e);
+    if (e.kind === "branch-switch") {
+      try {
+        const to = e.details?.to ?? "unknown";
+        log.info(`branch switched to '${to}' \u2014 rebuilding graph\u2026`);
+        await scanProject(paths.projectRoot, { silent: true });
+        const [g, idx] = await Promise.all([
+          readGraph(paths.infoGraph),
+          readSymbolIndex(paths.symbolIndex)
+        ]);
+        ctx.graph = g;
+        ctx.symbolIndex = idx;
+        log.info(`graph rebuilt for '${to}' (${g.symbol_count} symbols).`);
+      } catch (err2) {
+        log.warn(`branch rescan failed: ${err2.message}`);
+      }
+    }
+  });
+  try {
+    await fileWatcher.start();
+  } catch (err2) {
+    log.warn(`file watcher failed to start: ${err2.message}`);
+  }
+  try {
+    await gitWatcher.start();
+  } catch (err2) {
+    log.warn(`git watcher failed to start: ${err2.message}`);
+  }
+  const url = `http://127.0.0.1:${port}`;
+  return {
+    port,
+    url,
+    async stop() {
+      await fileWatcher.stop().catch(() => void 0);
+      await gitWatcher.stop().catch(() => void 0);
+      await new Promise((resolve5, reject) => {
+        nodeServer.close((err2) => err2 ? reject(err2) : resolve5());
+      });
+    }
+  };
+}
+
+// src/shared/config.ts
+function num(name, fallback) {
+  const v = process.env[name];
+  if (!v) return fallback;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+function str(name, fallback) {
+  return process.env[name] ?? fallback;
+}
+function loadConfig() {
+  return {
+    hardMaxReadChars: num("SYN_HARD_MAX_READ_CHARS", 4e3),
+    turnReadBudgetChars: num("SYN_TURN_READ_BUDGET_CHARS", 18e3),
+    fallbackMaxCallsPerTurn: num("SYN_FALLBACK_MAX_CALLS_PER_TURN", 1),
+    retrieveCacheTtlSec: num("SYN_RETRIEVE_CACHE_TTL_SEC", 900),
+    mcpPort: process.env.SYN_MCP_PORT ? num("SYN_MCP_PORT", 0) : null,
+    dashboardPort: num("SYN_DASHBOARD_PORT", 8901),
+    logLevel: str("SYN_LOG_LEVEL", "info"),
+    claudeBin: str("SYN_CLAUDE_BIN", "claude")
+  };
+}
+
+// src/cli/session-discovery.ts
+import { readdir as readdir2, stat as stat3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join9 } from "path";
+function encodeProjectPath(projectRoot) {
+  return projectRoot.replace(/[\\/:]/g, "-");
+}
+async function findLatestSession(projectRoot) {
+  const encoded = encodeProjectPath(projectRoot);
+  const dir = join9(homedir2(), ".claude", "projects", encoded);
+  let entries;
+  try {
+    entries = await readdir2(dir);
+  } catch {
+    return null;
+  }
+  const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
+  if (jsonlFiles.length === 0) return null;
+  let latest = null;
+  for (const file of jsonlFiles) {
+    const path = join9(dir, file);
+    try {
+      const s = await stat3(path);
+      if (!latest || s.mtime > latest.modifiedAt) {
+        latest = {
+          sessionId: file.replace(/\.jsonl$/, ""),
+          transcriptPath: path,
+          modifiedAt: s.mtime
+        };
+      }
+    } catch {
+    }
+  }
+  return latest;
+}
+
+// src/cli/cleanup.ts
+async function cleanup(paths) {
+  const session = await findLatestSession(paths.projectRoot);
+  if (!session) {
+    log.info("(no Claude session transcript found \u2014 nothing to resume)");
+    return;
+  }
+  log.info("");
+  log.info(`To resume this session:  syn --resume ${session.sessionId}`);
+}
+
+// src/cli/dashboard-command.ts
+import { resolve as resolve2 } from "path";
+async function dashboardCommand(rawPath) {
+  const projectRoot = resolve2(rawPath);
+  const paths = resolvePaths(projectRoot);
+  const cfg = loadConfig();
+  const handle = await startDashboard(paths, cfg.dashboardPort);
+  log.info(`Synthra dashboard listening on ${handle.url}`);
+  log.info(`project: ${projectRoot}`);
+  log.info(`reading: ${paths.tokenLog}`);
+  log.info(`         ${paths.gateLog}`);
+  log.info("press Ctrl+C to stop.");
+  await new Promise((res) => {
+    const shutdown = async (signal) => {
+      log.info(`received ${signal} \u2014 shutting down\u2026`);
+      try {
+        await handle.stop();
+      } catch (err2) {
+        log.warn(`dashboard stop error: ${err2.message}`);
+      }
+      res();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+}
+
+// src/cli/self-update.ts
+import { mkdir as mkdir10, readFile as readFile14, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join10 } from "path";
+var PKG_NAME = "@jefuriiij/synthra";
+var CACHE_DIR = join10(homedir3(), ".synthra");
+var CACHE_PATH = join10(CACHE_DIR, "version-check.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PKG_NAME)}/latest`;
+var FETCH_TIMEOUT_MS = 2e3;
+var currentVersionCache = null;
+async function getCurrentVersion() {
+  if (currentVersionCache) return currentVersionCache;
+  try {
+    const pkg = await Promise.resolve().then(() => (init_package(), package_exports));
+    const version = "default" in pkg ? pkg.default.version : pkg.version;
+    currentVersionCache = version;
+    return version;
+  } catch {
+    return "0.0.0";
+  }
+}
+async function readCache() {
+  try {
+    const raw = await readFile14(CACHE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.checked_at || !parsed.latest_version) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cache) {
+  try {
+    await mkdir10(CACHE_DIR, { recursive: true });
+    await writeFile9(CACHE_PATH, JSON.stringify(cache, null, 2), "utf8");
+  } catch {
+  }
+}
+function isNewer(candidate, baseline) {
+  const a = candidate.split(/[.-]/).map((p) => Number(p));
+  const b = baseline.split(/[.-]/).map((p) => Number(p));
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const ai = Number.isFinite(a[i]) ? a[i] : 0;
+    const bi = Number.isFinite(b[i]) ? b[i] : 0;
+    if (ai > bi) return true;
+    if (ai < bi) return false;
+  }
+  return false;
+}
+async function fetchLatestFromRegistry() {
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      headers: { Accept: "application/json" }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate() {
+  const current = await getCurrentVersion();
+  if (process.env.SYN_NO_UPDATE_CHECK === "1") {
+    return { current, latest: null, hasUpdate: false };
+  }
+  const cache = await readCache();
+  const now = Date.now();
+  const cacheAge = cache ? now - Date.parse(cache.checked_at) : Infinity;
+  let latest = null;
+  if (cache && cacheAge < CACHE_TTL_MS) {
+    latest = cache.latest_version;
+  } else {
+    latest = await fetchLatestFromRegistry();
+    if (latest) {
+      await writeCache({ checked_at: (/* @__PURE__ */ new Date()).toISOString(), latest_version: latest });
+    } else if (cache) {
+      latest = cache.latest_version;
+    }
+  }
+  const hasUpdate = latest ? isNewer(latest, current) : false;
+  return { current, latest, hasUpdate };
+}
+async function logUpdateHintIfNeeded() {
+  try {
+    const r = await checkForUpdate();
+    if (r.hasUpdate && r.latest) {
+      log.info(
+        `Synthra ${r.latest} is available (you have ${r.current}) \u2014 run: npm install -g @jefuriiij/synthra@latest`
+      );
+    }
+  } catch {
+  }
+}
+
+// src/cli/serve-command.ts
+import { resolve as resolve3 } from "path";
+import { stat as stat4 } from "fs/promises";
+async function serveCommand(rawPath) {
+  const projectRoot = resolve3(rawPath);
+  const paths = resolvePaths(projectRoot);
+  try {
+    await stat4(paths.infoGraph);
+  } catch {
+    log.error(`no graph found at ${paths.infoGraph}`);
+    log.error("run `syn scan` in this project first.");
+    process.exit(2);
+  }
+  const handle = await startServer(paths);
+  log.info(`MCP server listening on ${handle.url}`);
+  log.info(`port written to ${paths.mcpPort}`);
+  log.info("press Ctrl+C to stop.");
+  const shutdown = async (signal) => {
+    log.info(`received ${signal} \u2014 shutting down\u2026`);
+    try {
+      await handle.stop();
+    } catch (err2) {
+      log.error("shutdown error:", err2.message);
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+// src/cli/start-claude.ts
+import { spawn } from "child_process";
+var MCP_NAME = "synthra";
+function runClaude(bin, args, cwd, stdio = "pipe") {
+  return new Promise((resolve5) => {
+    const proc = spawn(bin, args, {
+      cwd,
+      stdio: stdio === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (c) => stdout += String(c));
+    proc.stderr?.on("data", (c) => stderr += String(c));
+    proc.on("error", () => resolve5({ code: -1, stdout, stderr: stderr || "claude not on PATH" }));
+    proc.on("exit", (code) => resolve5({ code: code ?? 0, stdout, stderr }));
+  });
+}
+async function registerMcp(bin, mcpPort, cwd) {
+  const url = `http://127.0.0.1:${mcpPort}/mcp`;
+  await runClaude(bin, ["mcp", "remove", MCP_NAME, "--scope", "local"], cwd).catch(() => void 0);
+  const reg = await runClaude(
+    bin,
+    ["mcp", "add", MCP_NAME, "--transport", "http", "--scope", "local", url],
+    cwd
+  );
+  if (reg.code !== 0) {
+    log.warn(`claude mcp add failed (code ${reg.code}). stderr: ${reg.stderr.trim()}`);
+    log.warn(`Synthra's MCP tools won't be visible to Claude this session.`);
+    return false;
+  }
+  log.info(`registered MCP with Claude: ${MCP_NAME} \u2192 ${url}`);
+  return true;
+}
+async function unregisterMcp(bin, cwd) {
+  const r = await runClaude(bin, ["mcp", "remove", MCP_NAME, "--scope", "local"], cwd);
+  if (r.code === 0) log.debug("unregistered MCP server");
+}
+async function spawnClaude(bin, opts) {
+  const args = [];
+  if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+  if (opts.initialPrompt) args.push(opts.initialPrompt);
+  log.info(`launching ${bin} ${args.join(" ")}`);
+  const result = await runClaude(bin, args, opts.cwd, "inherit");
+  return result.code;
+}
+
+// src/cli/index.ts
+var VERSION = "0.0.1";
+function printReadyBanner(info) {
+  log.info("");
+  log.info(`  \u2705  scanned   ${info.scan.parsed} files \xB7 ${info.scan.symbolCount} symbols \xB7 ${info.scan.edgeCount} edges`);
+  if (info.mcpRegistered) {
+    log.info(`  \u{1F9E0}  MCP       ${info.mcpUrl}   \u2192  registered as 'synthra'`);
+  } else {
+    log.info(`  \u{1F9E0}  MCP       ${info.mcpUrl}   \u26A0  registration with claude failed`);
+  }
+  if (info.dashboardUrl) {
+    log.info(`  \u{1F4CA}  Dashboard ${info.dashboardUrl}`);
+  } else {
+    log.info(`  \u{1F4CA}  Dashboard (failed to start; data is still logged to .synthra-graph/)`);
+  }
+  log.info(`  \u{1FA9D}  Hooks     installed in .claude/settings.local.json`);
+  log.info("");
+  log.info(`  \u{1F916}  Ready \u2014 open the Claude Code IDE extension (or run \`claude\` in another terminal).`);
+  log.info(`      Synthra's tools and gate will be active for that session.`);
+  log.info("");
+  log.info(`  Press Ctrl+C here when you're done.`);
+  log.info("");
+}
+function waitForSignal() {
+  return new Promise((resolve5) => {
+    const handler = (sig) => {
+      process.off("SIGINT", handler);
+      process.off("SIGTERM", handler);
+      resolve5(sig);
+    };
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+  });
+}
+async function defaultFlow(rawPath, opts) {
+  const launchCli = opts["launch-cli"] === true;
+  const projectRoot = resolve4(rawPath);
+  const paths = resolvePaths(projectRoot);
+  const cfg = loadConfig();
+  void logUpdateHintIfNeeded();
+  await recordProject(projectRoot);
+  const scan = await scanCommand(rawPath);
+  const mcpHandle = await startServer(paths);
+  let dashboardHandle = null;
+  try {
+    dashboardHandle = await startDashboard(paths, cfg.dashboardPort);
+  } catch (err2) {
+    log.warn(`dashboard failed to start on port ${cfg.dashboardPort}: ${err2.message}`);
+  }
+  await installHooks(paths);
+  const mcpRegistered = await registerMcp(cfg.claudeBin, mcpHandle.port, projectRoot);
+  let claudeExitCode = 0;
+  try {
+    if (launchCli) {
+      claudeExitCode = await spawnClaude(cfg.claudeBin, {
+        cwd: projectRoot,
+        resumeSessionId: opts.resume
+      });
+      log.info(`claude exited with code ${claudeExitCode}`);
+    } else {
+      printReadyBanner({
+        projectRoot,
+        scan,
+        mcpUrl: mcpHandle.url,
+        dashboardUrl: dashboardHandle?.url ?? null,
+        mcpRegistered
+      });
+      const sig = await waitForSignal();
+      log.info(`received ${sig} \u2014 shutting down\u2026`);
+    }
+  } finally {
+    await unregisterMcp(cfg.claudeBin, projectRoot).catch(() => void 0);
+    if (dashboardHandle) {
+      await dashboardHandle.stop().catch(
+        (err2) => log.warn(`dashboard stop error: ${err2.message}`)
+      );
+    }
+    await mcpHandle.stop().catch(
+      (err2) => log.warn(`MCP server stop error: ${err2.message}`)
+    );
+    await cleanup(paths).catch(
+      (err2) => log.warn(`cleanup error: ${err2.message}`)
+    );
+  }
+}
+function buildProgram() {
+  const prog = sade("syn");
+  prog.version(VERSION).describe("Local context engine for AI coding assistants.");
+  prog.command(". [path]", "Scan + MCP + dashboard + hooks. Default flow \u2014 use with the Claude Code IDE extension.", {
+    default: true
+  }).option("--resume <id>", "Resume an existing Claude session (only with --launch-cli)").option("--launch-cli", "Also spawn `claude` CLI in this terminal (legacy M3 behavior)", false).action(async (path, opts) => {
+    await defaultFlow(path ?? ".", opts);
+  });
+  prog.command("scan [path]", "Scan only \u2014 walk + parse + write graph.").action(async (path) => {
+    await scanCommand(path ?? ".");
+  });
+  prog.command("serve [path]", "Start the HTTP MCP server against a scanned project.").action(async (path) => {
+    await serveCommand(path ?? ".");
+  });
+  prog.command("dashboard [path]", "Run the token dashboard server (localhost:8901).").action(async (path) => {
+    await dashboardCommand(path ?? ".");
+  });
+  return prog;
+}
+async function main(argv) {
+  const prog = buildProgram();
+  prog.parse(argv);
+}
+export {
+  buildProgram,
+  main
+};
+//# sourceMappingURL=index.js.map