@jefuriiij/synthra 0.1.0

package/dist/server/index.js

@@ -0,0 +1,2933 @@
+// src/server/http.ts
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { writeFile as writeFile6 } from "fs/promises";
+
+// src/activity/activity-log.ts
+import { appendFile, mkdir } from "fs/promises";
+import { dirname } 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 mkdir(dirname(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 } from "fs/promises";
+import { join, relative, sep } from "path";
+import ignore from "ignore";
+
+// 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/activity/file-watcher.ts
+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 readFile(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(join(root, ".gitignore")));
+  ig.add(await readIgnoreFile(join(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 readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var POLL_MS = 2e3;
+async function readHeadBranch(projectRoot) {
+  try {
+    const head = await readFile2(join2(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(join2(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 dirname2, join as join3, 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 readFile3 } 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 readFile3(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 readFile4, readdir, stat } from "fs/promises";
+import { extname, join as join4, 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 readFile4(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(join4(root, ".gitignore")));
+  ig.add(await readIgnoreFile2(join4(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 = join4(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 mkdir2, readFile as readFile5, writeFile } from "fs/promises";
+import { dirname as dirname3 } from "path";
+async function writeJson(path, data, pretty) {
+  await mkdir2(dirname3(path), { recursive: true });
+  const text = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  await writeFile(path, text + "\n", "utf8");
+}
+async function readJson(path) {
+  const text = await readFile5(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/shared/paths.ts
+import { join as join5 } from "path";
+function resolvePaths(projectRoot) {
+  const graphDir = join5(projectRoot, ".synthra-graph");
+  const contextDir = join5(projectRoot, ".synthra");
+  const claudeDir = join5(projectRoot, ".claude");
+  return {
+    projectRoot,
+    graphDir,
+    contextDir,
+    infoGraph: join5(graphDir, "info_graph.json"),
+    symbolIndex: join5(graphDir, "symbol_index.json"),
+    sessionState: join5(graphDir, "session.json"),
+    activityLog: join5(graphDir, "activity.jsonl"),
+    tokenLog: join5(graphDir, "token_log.jsonl"),
+    gateLog: join5(graphDir, "gate_log.jsonl"),
+    mcpPort: join5(graphDir, "mcp_port"),
+    mcpServerLog: join5(graphDir, "mcp_server.log"),
+    mcpServerErrLog: join5(graphDir, "mcp_server.err.log"),
+    contextStore: join5(contextDir, "context-store.json"),
+    contextMd: join5(contextDir, "CONTEXT.md"),
+    branchesDir: join5(contextDir, "branches"),
+    claudeDir,
+    claudeSettings: join5(claudeDir, "settings.local.json"),
+    claudeHooksDir: join5(claudeDir, "hooks"),
+    claudeMd: join5(projectRoot, "CLAUDE.md"),
+    gitignore: join5(projectRoot, ".gitignore")
+  };
+}
+
+// src/cli/bootstrap.ts
+import { mkdir as mkdir3, readFile as readFile7, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+
+// src/hooks/claude-md.ts
+import { readFile as readFile6, writeFile as writeFile2 } 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 readFile6(path, "utf8");
+  } catch {
+    existing = null;
+  }
+  const block = policyBlock();
+  if (existing === null) {
+    await writeFile2(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 writeFile2(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 mkdir3(path, { recursive: true });
+  return !had;
+}
+async function patchGitignore(path) {
+  let existing = "";
+  try {
+    existing = await readFile7(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 writeFile3(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
+  };
+}
+
+// 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 readFile8 } from "fs/promises";
+import { join as join6 } from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function currentBranch(projectRoot) {
+  try {
+    const headPath = join6(projectRoot, ".git", "HEAD");
+    const head = await readFile8(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: join6(contextDir, "context-store.json"),
+      contextMd: join6(contextDir, "CONTEXT.md"),
+      branchDir: null
+    };
+  }
+  const branchDir = join6(contextDir, "branches", sanitizeBranchName(branch));
+  return {
+    contextStore: join6(branchDir, "context-store.json"),
+    contextMd: join6(branchDir, "CONTEXT.md"),
+    branchDir
+  };
+}
+
+// src/memory/context-md.ts
+import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } 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 mkdir4(dirname4(path), { recursive: true });
+  await writeFile4(path, formatContextMd(ctx), "utf8");
+}
+
+// src/memory/context-store.ts
+import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+var SCHEMA_VERSION = 1;
+async function readEntries(path) {
+  try {
+    const raw = await readFile10(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.entries) ? parsed.entries : [];
+  } catch {
+    return [];
+  }
+}
+async function writeEntries(path, entries) {
+  await mkdir5(dirname5(path), { recursive: true });
+  const store = { schema_version: SCHEMA_VERSION, entries };
+  await writeFile5(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/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((resolve2) => {
+    const s = createServer();
+    s.once("error", () => resolve2(false));
+    s.once("listening", () => s.close(() => resolve2(true)));
+    s.listen(port, "127.0.0.1");
+  });
+}
+
+// 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 mkdir6 } from "fs/promises";
+import { dirname as dirname6 } 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 mkdir6(dirname6(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 mkdir7 } from "fs/promises";
+import { dirname as dirname7 } 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 mkdir7(dirname7(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 Hono();
+  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 = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" });
+  await writeFile6(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((resolve2, reject) => {
+        nodeServer.close((err2) => err2 ? reject(err2) : resolve2());
+      });
+    }
+  };
+}
+export {
+  startServer
+};
+//# sourceMappingURL=index.js.map