@jefuriiij/synthra 0.1.24 → 0.2.0

package/dist/cli/index.js

@@ -18,7 +18,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jefuriiij/synthra",
-      version: "0.1.24",
+      version: "0.2.0",
       publishConfig: {
         access: "public"
       },
@@ -33,7 +33,12 @@ var init_package = __esm({
         dev: "tsup --watch",
         test: "vitest run",
         "test:watch": "vitest",
-        typecheck: "tsc --noEmit"
+        "test:coverage": "vitest run --coverage",
+        typecheck: "tsc --noEmit",
+        lint: "biome lint .",
+        format: "biome format --write .",
+        check: "biome check .",
+        "check:fix": "biome check --write ."
       },
       files: [
         "dist",
@@ -75,8 +80,10 @@ var init_package = __esm({
         "web-tree-sitter": "^0.25.10"
       },
       devDependencies: {
+        "@biomejs/biome": "^2.4.16",
         "@types/cross-spawn": "^6.0.6",
         "@types/node": "^25.9.1",
+        "@vitest/coverage-v8": "^4.1.8",
         tsup: "^8.5.1",
         typescript: "^6.0.3",
         vitest: "^4.1.7"
@@ -158,6 +165,8 @@ function resolvePaths(projectRoot) {
     tokenLog: join(graphDir, "token_log.jsonl"),
     gateLog: join(graphDir, "gate_log.jsonl"),
     toolLog: join(graphDir, "tool_log.jsonl"),
+    accessLog: join(graphDir, "access_log.jsonl"),
+    learnStore: join(graphDir, "learn_store.json"),
     mcpPort: join(graphDir, "mcp_port"),
     mcpServerLog: join(graphDir, "mcp_server.log"),
     mcpServerErrLog: join(graphDir, "mcp_server.err.log"),
@@ -374,7 +383,9 @@ async function computeDashboardData(activePaths, recentN = 500) {
   const loaded = await Promise.all(
     allEntries.map((e) => loadProjectFiles(e.path, e.name, e.last_seen))
   );
-  const projects = loaded.map(summarize).sort((a, b) => b.total_input_tokens + b.total_output_tokens - (a.total_input_tokens + a.total_output_tokens));
+  const projects = loaded.map(summarize).sort(
+    (a, b) => b.total_input_tokens + b.total_output_tokens - (a.total_input_tokens + a.total_output_tokens)
+  );
   const activeFiles = loaded.find((p) => p.path === activePath) ?? {
     path: activePath,
     name: activeName,
@@ -1440,12 +1451,19 @@ if [ ! -f "$PORT_FILE" ]; then exit 0; fi
 PORT=$(cat "$PORT_FILE" 2>/dev/null | tr -d '[:space:]')
 if [ -z "$PORT" ]; then exit 0; fi
 
+# Parse the primer with jq, not sed. The primer now carries a multi-line "Since you
+# were last here" resume digest with quotes and newlines, so the old greedy sed capture
+# (.*") both over-ran into the trailing "port" field and broke on inner quotes. jq -r
+# also decodes JSON escapes, so we print with %s (not %b). No jq \u2192 no primer (matches
+# prime.sh / stop.sh \u2014 completes the jq migration across all bash hooks).
+if ! command -v jq >/dev/null 2>&1; then exit 0; fi
+
 PRIMER=$(curl -sS --max-time 3 "http://127.0.0.1:$PORT/prime" 2>/dev/null \\
-  | sed -n 's/.*"primer"[[:space:]]*:[[:space:]]*"\\(.*\\)".*/\\1/p' \\
+  | jq -r '.primer // empty' 2>/dev/null \\
   | head -c 8000)
 
 if [ -n "$PRIMER" ]; then
-  printf '%b\\n' "$PRIMER"
+  printf '%s\\n' "$PRIMER"
 fi
 exit 0
 `;
@@ -1458,6 +1476,8 @@ var pre_tool_use_default2 = `#!/usr/bin/env bash\r
 # PreToolUse hook \u2014 bash. POSTs the tool call to /gate; if server returns\r
 # "block", emits the deny-decision JSON to stdout for Claude Code to enforce.\r
 # Always exits 0; server failures leave Claude untouched.\r
+# Requires \`jq\` to read the gate response; falls back to silent no-op (no\r
+# enforcement) if absent \u2014 same policy as the Stop/Prime hooks.\r
 \r
 set +e\r
 \r
@@ -1472,14 +1492,20 @@ if [ -z "$INPUT" ]; then exit 0; fi\r
 RESP=$(curl -sS --max-time 3 -X POST -H "Content-Type: application/json" \\\r
   --data "$INPUT" "http://127.0.0.1:$PORT/gate" 2>/dev/null)\r
 \r
-case "$RESP" in\r
-  *'"decision":"block"'*)\r
-    REASON=$(printf '%s' "$RESP" | sed -n 's/.*"reason"[[:space:]]*:[[:space:]]*"\\(.*\\)".*/\\1/p')\r
-    cat <<EOF\r
-{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"\${REASON}"}}\r
-EOF\r
-    ;;\r
-esac\r
+# Parse the gate response with jq, not a greedy sed capture. The block \`reason\`\r
+# legitimately contains double quotes (it quotes the query, e.g. "login"), so the\r
+# old sed capture (\\(.*\\)") both over-ran into the trailing JSON fields and, once\r
+# embedded raw in the heredoc, produced invalid hook output. jq reads each field\r
+# and re-emits the deny object with correct escaping. (matches stop.sh / prime.sh,\r
+# jq fix #1.) No jq \u2192 no enforcement; bail silently like the other hooks.\r
+if ! command -v jq >/dev/null 2>&1; then exit 0; fi\r
+\r
+DECISION=$(printf '%s' "$RESP" | jq -r '.decision // empty' 2>/dev/null)\r
+if [ "$DECISION" = "block" ]; then\r
+  REASON=$(printf '%s' "$RESP" | jq -r '.reason // empty' 2>/dev/null)\r
+  jq -nc --arg r "$REASON" \\\r
+    '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}'\r
+fi\r
 exit 0\r
 `;
 
@@ -1688,7 +1714,13 @@ exit 0\r
 // src/hooks/installer.ts
 var SCRIPTS = [
   { event: "SessionStart", baseName: "synthra-prime", ps1: prime_default, sh: prime_default2 },
-  { event: "PreToolUse", matcher: "Grep|Glob", baseName: "synthra-pre-tool-use", ps1: pre_tool_use_default, sh: pre_tool_use_default2 },
+  {
+    event: "PreToolUse",
+    matcher: "Grep|Glob",
+    baseName: "synthra-pre-tool-use",
+    ps1: pre_tool_use_default,
+    sh: pre_tool_use_default2
+  },
   { event: "PreCompact", baseName: "synthra-pre-compact", ps1: pre_compact_default, sh: pre_compact_default2 },
   { event: "Stop", baseName: "synthra-stop", ps1: stop_default, sh: stop_default2 }
 ];
@@ -1765,7 +1797,7 @@ async function installHooks(paths) {
 // src/server/http.ts
 import { serve as serve2 } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { writeFile as writeFile8 } from "fs/promises";
+import { writeFile as writeFile10 } from "fs/promises";
 
 // src/activity/activity-log.ts
 import { appendFile, mkdir as mkdir3 } from "fs/promises";
@@ -2226,7 +2258,20 @@ function extractKeywords(content, _ext) {
 }
 
 // src/scanner/extract.ts
-var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".svelte", ".vue", ".dart", ".html", ".hubl"];
+var RESOLVE_EXTS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".svelte",
+  ".vue",
+  ".dart",
+  ".html",
+  ".hubl"
+];
 var INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.jsx", "__init__.py"];
 function fileId(relPath) {
   return `file:${relPath}`;
@@ -3325,7 +3370,7 @@ import { basename as basename4 } from "path";
 // src/hooks/claude-md.ts
 import { readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
 import { basename as basename3, dirname as dirname6 } from "path";
-var POLICY_VERSION = 5;
+var POLICY_VERSION = 6;
 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;
@@ -3416,6 +3461,17 @@ function policyBlock() {
     "- Don't call `graph_continue` more than once per turn.",
     "- Don't read whole files when a symbol-level read would suffice.",
     "",
+    "### Resuming a session",
+    "",
+    'At session start the primer may begin with a **"Since you were last here"**',
+    "digest \u2014 recent commits, files touched, open next-steps, and recent",
+    "decisions carried over from the previous session. **Trust it.** It is the",
+    "cheapest possible orientation: do NOT re-run `graph_continue` or Grep just",
+    'to rediscover "what were we doing / what changed" \u2014 that work is already',
+    'done. For the concrete next steps, `context_recall({kind:"next"})` returns',
+    "them verbatim. Only reach for fresh retrieval when the task moves beyond",
+    "what the digest covers.",
+    "",
     "### Session-end resume note",
     "",
     `When the user signals they're done (e.g. "bye", "wrap up", "done"),`,
@@ -3594,7 +3650,9 @@ async function scanProject(projectRootRaw, opts = {}) {
     if (boot.gitignoreUpdated) log.info("  updated .gitignore");
     if (boot.claudeMdCreated) {
       log.info("  created CLAUDE.md \u2014 onboarding skeleton for the agent");
-      log.info("    \u21B3 fill in Build / Conventions / Decisions (or run /init in Claude to auto-draft)");
+      log.info(
+        "    \u21B3 fill in Build / Conventions / Decisions (or run /init in Claude to auto-draft)"
+      );
     } else if (boot.claudeMdUpdated) {
       log.info("  updated CLAUDE.md");
     }
@@ -3642,11 +3700,191 @@ async function scanCommand(rawPath) {
   return scanProject(rawPath);
 }
 
+// src/learn/store.ts
+import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname7 } from "path";
+
+// src/learn/usage.ts
+var LEARN_SCHEMA_VERSION = 1;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function halfLifeMs() {
+  const env = Number(process.env.SYN_LEARN_HALFLIFE_DAYS);
+  const days = Number.isFinite(env) && env > 0 ? env : 7;
+  return days * DAY_MS;
+}
+function weightFor(source) {
+  switch (source) {
+    case "register_edit":
+      return 2;
+    case "read":
+      return 1;
+    default:
+      return 0;
+  }
+}
+function emptyStore() {
+  return {
+    schema_version: LEARN_SCHEMA_VERSION,
+    asOf: (/* @__PURE__ */ new Date(0)).toISOString(),
+    files: {}
+  };
+}
+function decayFactor(fromTs, toMs, hl) {
+  const fromMs = Date.parse(fromTs);
+  if (!Number.isFinite(fromMs)) return 1;
+  const dt = toMs - fromMs;
+  if (dt <= 0) return 1;
+  return Math.exp(-(Math.LN2 / hl) * dt);
+}
+function foldEvent(store, ev) {
+  const w = weightFor(ev.source);
+  if (w <= 0 || !ev.path) return store;
+  const tMs = Date.parse(ev.ts);
+  if (!Number.isFinite(tMs)) return store;
+  const hl = halfLifeMs();
+  const prev = store.files[ev.path];
+  if (prev) {
+    const decayed = prev.decayed * decayFactor(prev.lastTs, tMs, hl) + w;
+    store.files[ev.path] = { count: prev.count + 1, decayed, lastTs: ev.ts };
+  } else {
+    store.files[ev.path] = { count: 1, decayed: w, lastTs: ev.ts };
+  }
+  return store;
+}
+function effectiveScores(store, nowMs) {
+  const hl = halfLifeMs();
+  const out = /* @__PURE__ */ new Map();
+  for (const [path, stat6] of Object.entries(store.files)) {
+    const eff = stat6.decayed * decayFactor(stat6.lastTs, nowMs, hl);
+    if (eff > 0.01) out.set(path, eff);
+  }
+  return out;
+}
+function recomputeFromLog(events) {
+  const store = emptyStore();
+  for (const ev of events) foldEvent(store, ev);
+  return store;
+}
+
+// src/learn/store.ts
+async function readLearnStore(path) {
+  try {
+    const raw = await readFile11(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schema_version !== LEARN_SCHEMA_VERSION || typeof parsed.files !== "object" || parsed.files === null) {
+      return emptyStore();
+    }
+    return {
+      schema_version: LEARN_SCHEMA_VERSION,
+      asOf: typeof parsed.asOf === "string" ? parsed.asOf : emptyStore().asOf,
+      files: parsed.files
+    };
+  } catch {
+    return emptyStore();
+  }
+}
+async function writeLearnStore(path, store) {
+  try {
+    await mkdir6(dirname7(path), { recursive: true });
+    await writeFile6(path, JSON.stringify(store, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+async function readAccessLog(path) {
+  try {
+    const raw = await readFile11(path, "utf8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+      const t = line.trim();
+      if (!t) continue;
+      try {
+        const ev = JSON.parse(t);
+        if (ev && typeof ev.ts === "string" && typeof ev.path === "string" && typeof ev.source === "string") {
+          out.push(ev);
+        }
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function appendAccess(path, ev) {
+  try {
+    await mkdir6(dirname7(path), { recursive: true });
+    await appendFile2(path, JSON.stringify(ev) + "\n", "utf8");
+  } catch {
+  }
+}
+
+// src/learn/runtime.ts
+var PERSIST_DEBOUNCE_MS = 2e3;
+var LearnRuntime = class _LearnRuntime {
+  constructor(accessLogPath, storePath, store) {
+    this.accessLogPath = accessLogPath;
+    this.storePath = storePath;
+    this.store = store;
+  }
+  accessLogPath;
+  storePath;
+  store;
+  dirty = false;
+  timer = null;
+  /** Load the aggregate from disk; if it's empty but a raw log exists, replay it
+   *  (the log is the source of truth). Always succeeds — falls back to empty. */
+  static async load(accessLogPath, storePath) {
+    let store = await readLearnStore(storePath);
+    if (Object.keys(store.files).length === 0) {
+      const events = await readAccessLog(accessLogPath);
+      if (events.length > 0) store = recomputeFromLog(events);
+    }
+    return new _LearnRuntime(accessLogPath, storePath, store);
+  }
+  /** Record an access: append to the durable log + fold into the in-memory
+   *  aggregate. Best-effort — never throws into a tool call. */
+  async record(ev) {
+    await appendAccess(this.accessLogPath, ev);
+    foldEvent(this.store, ev);
+    this.schedulePersist();
+  }
+  /** Decayed path→weight map for the ranker, as of now. */
+  effectiveScores(nowMs = Date.now()) {
+    return effectiveScores(this.store, nowMs);
+  }
+  schedulePersist() {
+    this.dirty = true;
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, PERSIST_DEBOUNCE_MS);
+    this.timer.unref?.();
+  }
+  /** Persist the aggregate if it changed since the last write. Called on the
+   *  debounce and on server shutdown. */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (!this.dirty) return;
+    this.dirty = false;
+    this.store.asOf = (/* @__PURE__ */ new Date()).toISOString();
+    await writeLearnStore(this.storePath, this.store);
+  }
+};
+
 // src/server/mcp.ts
-import { appendFile as appendFile2, mkdir as mkdir8 } from "fs/promises";
-import { dirname as dirname9 } from "path";
+import { appendFile as appendFile3, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname10 } from "path";
 
 // src/graph/rank.ts
+var USAGE_BOOST_CAP_DEFAULT = 4;
+function usageBoostCap() {
+  const env = Number(process.env.SYN_LEARN_BOOST_CAP);
+  return Number.isFinite(env) && env >= 0 ? env : USAGE_BOOST_CAP_DEFAULT;
+}
 var STOPWORDS2 = /* @__PURE__ */ new Set([
   "a",
   "an",
@@ -3793,6 +4031,21 @@ function scoreFiles(inputs) {
       }
     }
   }
+  const usage = inputs.usageScores;
+  if (usage && usage.size > 0) {
+    let maxU = 0;
+    for (const v of usage.values()) if (v > maxU) maxU = v;
+    if (maxU > 0) {
+      const cap = usageBoostCap();
+      for (const s of scored) {
+        if (s.score <= 0) continue;
+        const u = usage.get(s.file.path) ?? 0;
+        if (u <= 0) continue;
+        s.score += cap * (u / maxU);
+        s.reasons.push(`used\xD7${Math.round(u)}`);
+      }
+    }
+  }
   scored.sort((a, b) => b.score - a.score);
   return scored;
 }
@@ -3801,9 +4054,7 @@ function scoreFiles(inputs) {
 async function retrieve(graph, query, options = {}) {
   const topK = options.topK ?? 12;
   const qTokens = tokenizeQuery(query);
-  const allFiles = graph.nodes.filter(
-    (n) => n.kind === "file"
-  );
+  const allFiles = graph.nodes.filter((n) => n.kind === "file");
   if (allFiles.length === 0 || qTokens.length === 0) {
     return {
       files: [],
@@ -3817,7 +4068,8 @@ async function retrieve(graph, query, options = {}) {
     query,
     graph,
     recentlyEditedPaths: options.recentlyEditedPaths,
-    sessionKnownPaths: options.sessionKnownPaths
+    sessionKnownPaths: options.sessionKnownPaths,
+    usageScores: options.usageScores
   };
   const scored = scoreFiles(rankInputs);
   const positive = scored.filter((s) => s.score > 0);
@@ -3850,14 +4102,14 @@ async function retrieve(graph, query, options = {}) {
 
 // src/memory/branches.ts
 import { execFile as execFile2 } from "child_process";
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { join as join8 } from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 async function currentBranch(projectRoot) {
   try {
     const headPath = join8(projectRoot, ".git", "HEAD");
-    const head = await readFile11(headPath, "utf8");
+    const head = await readFile12(headPath, "utf8");
     const trimmed = head.trim();
     const match = trimmed.match(/^ref:\s+refs\/heads\/(.+)$/);
     if (match?.[1]) return match[1];
@@ -3907,8 +4159,8 @@ function resolveBranchPaths(contextDir, branch, isDefault) {
 }
 
 // src/memory/context-md.ts
-import { mkdir as mkdir6, readFile as readFile12, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { mkdir as mkdir7, readFile as readFile13, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname8 } from "path";
 var MAX_BULLETS = 3;
 function deriveContextMd(entries, branch) {
   const tasks = entries.filter((e) => e.type === "task").reverse();
@@ -3951,17 +4203,17 @@ function formatContextMd(ctx) {
   return lines.join("\n");
 }
 async function writeContextMd(path, ctx) {
-  await mkdir6(dirname7(path), { recursive: true });
-  await writeFile6(path, formatContextMd(ctx), "utf8");
+  await mkdir7(dirname8(path), { recursive: true });
+  await writeFile7(path, formatContextMd(ctx), "utf8");
 }
 
 // src/memory/context-store.ts
-import { mkdir as mkdir7, readFile as readFile13, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname8 } from "path";
+import { mkdir as mkdir8, readFile as readFile14, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname9 } from "path";
 var SCHEMA_VERSION3 = 1;
 async function readEntries(path) {
   try {
-    const raw = await readFile13(path, "utf8");
+    const raw = await readFile14(path, "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.entries) ? parsed.entries : [];
   } catch {
@@ -3969,9 +4221,9 @@ async function readEntries(path) {
   }
 }
 async function writeEntries(path, entries) {
-  await mkdir7(dirname8(path), { recursive: true });
+  await mkdir8(dirname9(path), { recursive: true });
   const store = { schema_version: SCHEMA_VERSION3, entries };
-  await writeFile7(path, JSON.stringify(store, null, 2) + "\n", "utf8");
+  await writeFile8(path, JSON.stringify(store, null, 2) + "\n", "utf8");
 }
 async function appendEntry(path, entry) {
   const entries = await readEntries(path);
@@ -4245,7 +4497,10 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Natural-language description of what you're looking for." }
+        query: {
+          type: "string",
+          description: "Natural-language description of what you're looking for."
+        }
       },
       required: ["query"]
     }
@@ -4401,9 +4656,7 @@ function blastRadius(args, ctx) {
   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
-  );
+  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) {
@@ -4450,8 +4703,8 @@ var LIKELY_ENTRY_PATTERNS = [
   /(?:^|\/)index\.[a-z0-9_]+$/i,
   /(?:^|\/)app\.[a-z0-9_]+$/i,
   /(?:^|\/)entry\.[a-z0-9_]+$/i,
-  /(?:^|\/)cli[\/.]/i,
-  /(?:^|\/)bin[\/.]/i,
+  /(?:^|\/)cli[/.]/i,
+  /(?:^|\/)bin[/.]/i,
   /(?:^|\/)server\.[a-z0-9_]+$/i,
   /\.test\.[a-z0-9_]+$/i,
   /\.spec\.[a-z0-9_]+$/i,
@@ -4497,9 +4750,11 @@ async function graphContinue(args, ctx) {
   if (!query) return errorContent("graph_continue: 'query' (string) is required");
   const retrieval = await retrieve(ctx.graph, query, {
     recentlyEditedPaths: ctx.activity.recentFilePaths(15 * 60 * 1e3),
-    sessionKnownPaths: getRegisteredEdits()
+    sessionKnownPaths: getRegisteredEdits(),
+    usageScores: ctx.learn?.effectiveScores()
   });
   const packed = await pack(retrieval.files, { query, graph: ctx.graph });
+  await logAccess(ctx, { ts: nowIso(), path: "", source: "continue", query });
   const header = `Confidence: ${retrieval.confidence}
 Files: ${retrieval.files.map((f) => f.path).join(", ") || "(none)"}
 Reason: ${retrieval.reason}
@@ -4517,7 +4772,7 @@ function resolveFileTarget(graph, filePath) {
   if (matches.length > 1) return { ambiguous: matches.map((n) => n.path) };
   return { none: true };
 }
-function graphRead(args, ctx) {
+async 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];
@@ -4534,6 +4789,7 @@ function graphRead(args, ctx) {
     return errorContent(`graph_read: file not found in graph: ${filePath}`);
   }
   const fileNode = resolved.node;
+  await logAccess(ctx, { ts: nowIso(), path: fileNode.path, source: "read" });
   if (!symbolName) {
     return textContent(`# ${fileNode.path}
 
@@ -4555,10 +4811,21 @@ ${body}`
   );
 }
 var editedFiles = /* @__PURE__ */ new Set();
-function graphRegisterEdit(args, _ctx) {
+async 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}.`);
+  for (const f of files) {
+    const file = f;
+    editedFiles.add(file);
+    const resolved = resolveFileTarget(ctx.graph, file);
+    await logAccess(ctx, {
+      ts: nowIso(),
+      path: "node" in resolved ? resolved.node.path : file,
+      source: "register_edit"
+    });
+  }
+  return textContent(
+    `Registered ${files.length} edited file(s). Total tracked this session: ${editedFiles.size}.`
+  );
 }
 function getRegisteredEdits() {
   return Array.from(editedFiles);
@@ -4594,9 +4861,7 @@ function recentActivity(args, ctx) {
   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()}.`
-    );
+    return textContent(`No human-activity events since ${new Date(sinceMs).toISOString()}.`);
   }
   const lines = [`# Recent human activity (${events.length} events)`, ""];
   for (const e of events) {
@@ -4628,8 +4893,8 @@ async function contextRecall(args, ctx) {
 }
 async function logToolCall(ctx, tool) {
   try {
-    await mkdir8(dirname9(ctx.paths.toolLog), { recursive: true });
-    await appendFile2(
+    await mkdir9(dirname10(ctx.paths.toolLog), { recursive: true });
+    await appendFile3(
       ctx.paths.toolLog,
       JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool }) + "\n",
       "utf8"
@@ -4637,6 +4902,16 @@ async function logToolCall(ctx, tool) {
   } catch {
   }
 }
+async function logAccess(ctx, ev) {
+  try {
+    if (ctx.learn) await ctx.learn.record(ev);
+    else await appendAccess(ctx.paths.accessLog, ev);
+  } catch {
+  }
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
 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.");
@@ -4687,9 +4962,87 @@ async function handleActivity(sinceMs, ctx) {
   };
 }
 
+// src/memory/git-snapshot.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+var MAX_COMMITS = 5;
+var FIELD = "";
+async function getCommitsSince(projectRoot, sinceIso) {
+  const args = [
+    "log",
+    `--max-count=${MAX_COMMITS}`,
+    "--no-merges",
+    `--pretty=format:%h${FIELD}%s${FIELD}%aI`
+  ];
+  if (Number.isFinite(Date.parse(sinceIso))) args.push(`--since=${sinceIso}`);
+  try {
+    const { stdout } = await execFileAsync3("git", args, { cwd: projectRoot });
+    const out = [];
+    for (const line of stdout.split("\n")) {
+      const t = line.trim();
+      if (!t) continue;
+      const [hash, message, date] = t.split(FIELD);
+      if (hash && message) out.push({ hash, message, date: date ?? "" });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+// src/memory/session.ts
+import { mkdir as mkdir10, readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname11 } from "path";
+var SESSION_SCHEMA_VERSION = 1;
+async function readSession(path) {
+  try {
+    const raw = await readFile15(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schema_version !== SESSION_SCHEMA_VERSION) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeSession(path, state) {
+  await mkdir10(dirname11(path), { recursive: true });
+  await writeFile9(path, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+
 // src/server/routes/context-update.ts
+var TOUCHED_WINDOW_MS = 24 * 60 * 60 * 1e3;
+async function captureSnapshot(ctx, branchOverride) {
+  const active = await resolveActiveBranch(ctx.paths, branchOverride);
+  const [tasks, decisions, next] = await Promise.all([
+    recallEntries(ctx.paths, { kind: "task", branch: active.branch, limit: 1 }),
+    recallEntries(ctx.paths, { kind: "decision", branch: active.branch, limit: 3 }),
+    recallEntries(ctx.paths, { kind: "next", branch: active.branch, limit: 3 })
+  ]);
+  const touched = new Set(getRegisteredEdits());
+  for (const p of ctx.activity.recentFilePaths(TOUCHED_WINDOW_MS)) touched.add(p);
+  const prev = await readSession(ctx.paths.sessionState);
+  const recentCommits = await getCommitsSince(ctx.paths.projectRoot, prev?.endedAt ?? "");
+  const snapshot = {
+    schema_version: SESSION_SCHEMA_VERSION,
+    endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    branch: active.branch,
+    filesTouched: Array.from(touched),
+    recentCommits,
+    summary: {
+      tasks: tasks.entries.map((e) => e.content),
+      decisions: decisions.entries.map((e) => e.content),
+      next: next.entries.map((e) => e.content)
+    }
+  };
+  await writeSession(ctx.paths.sessionState, snapshot);
+}
 async function handleContextUpdate(req, ctx) {
   const r = await refreshContextMd(ctx.paths, req?.branch);
+  try {
+    await captureSnapshot(ctx, req?.branch);
+  } catch {
+  }
   return {
     updated: true,
     branch: r.branch,
@@ -4699,8 +5052,8 @@ async function handleContextUpdate(req, ctx) {
 }
 
 // src/server/routes/gate.ts
-import { appendFile as appendFile3, mkdir as mkdir9 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { appendFile as appendFile4, mkdir as mkdir11 } from "fs/promises";
+import { dirname as dirname12 } from "path";
 var BLOCKABLE_TOOLS = /* @__PURE__ */ new Set(["Grep", "Glob"]);
 var RECENT_ACTIVITY_WINDOW_MS = 5 * 60 * 1e3;
 function extractQuery(toolName, input) {
@@ -4756,7 +5109,7 @@ function recentlyTouchedMatchesQuery(recentPaths, queryTokens, graph) {
 }
 async function logDecision(ctx, toolName, query, decision, reason) {
   try {
-    await mkdir9(dirname10(ctx.paths.gateLog), { recursive: true });
+    await mkdir11(dirname12(ctx.paths.gateLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
@@ -4764,7 +5117,7 @@ async function logDecision(ctx, toolName, query, decision, reason) {
       query,
       reason
     };
-    await appendFile3(ctx.paths.gateLog, JSON.stringify(entry) + "\n", "utf8");
+    await appendFile4(ctx.paths.gateLog, JSON.stringify(entry) + "\n", "utf8");
   } catch {
   }
 }
@@ -4828,16 +5181,16 @@ async function handleGate(req, ctx) {
 }
 
 // src/server/routes/log.ts
-import { appendFile as appendFile4, mkdir as mkdir10 } from "fs/promises";
-import { dirname as dirname11 } from "path";
+import { appendFile as appendFile5, mkdir as mkdir12 } from "fs/promises";
+import { dirname as dirname13 } 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 mkdir10(dirname11(ctx.paths.tokenLog), { recursive: true });
-  await appendFile4(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
+  await mkdir12(dirname13(ctx.paths.tokenLog), { recursive: true });
+  await appendFile5(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
   return { ok: true, written_at };
 }
 
@@ -4847,13 +5200,15 @@ async function handlePack(req, ctx) {
     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 usageScores = ctx.learn?.effectiveScores();
+  const retrieval = await retrieve(ctx.graph, req.query, { recentlyEditedPaths, usageScores });
   const allFiles = ctx.graph.nodes.filter((n) => n.kind === "file");
   const scored = scoreFiles({
     candidates: allFiles,
     query: req.query,
     graph: ctx.graph,
-    recentlyEditedPaths
+    recentlyEditedPaths,
+    usageScores
   });
   const reasons = /* @__PURE__ */ new Map();
   for (const s of scored) {
@@ -4875,14 +5230,74 @@ async function handlePack(req, ctx) {
 }
 
 // src/server/routes/prime.ts
-async function handlePrime(ctx, port) {
+var RESUME_PRIMER_MAX_CHARS = 2720;
+var MAX_FILES = 15;
+var MAX_COMMITS2 = 5;
+var MAX_BULLETS2 = 3;
+function legacyPrimer(ctx) {
   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 };
+  return `Synthra context loaded for ${g.root}.
+${g.file_count} files indexed, ${g.symbol_count} symbols. Prefer the graph_* MCP tools over Grep/Glob for navigation.`;
+}
+function hasContent(snap) {
+  return Boolean(
+    snap.recentCommits.length || snap.filesTouched.length || snap.summary.tasks.length || snap.summary.next.length || snap.summary.decisions.length
+  );
+}
+function buildResumeDigest(snap, branchNow) {
+  const plural = (n) => n === 1 ? "" : "s";
+  const head = `## Since you were last here \u2014 ${snap.branch}  (${snap.recentCommits.length} commit${plural(snap.recentCommits.length)}, ${snap.filesTouched.length} file${plural(snap.filesTouched.length)} touched)`;
+  const essential = [head];
+  if (snap.branch !== branchNow) {
+    essential.push("");
+    essential.push(
+      `_(snapshot was for branch '${snap.branch}'; you're now on '${branchNow}' \u2014 may be stale)_`
+    );
+  }
+  if (snap.summary.tasks[0]) {
+    essential.push("", "### In progress", `- ${snap.summary.tasks[0]}`);
+  }
+  if (snap.summary.next.length) {
+    essential.push("", "### Open next steps");
+    for (const n of snap.summary.next.slice(0, MAX_BULLETS2)) essential.push(`- ${n}`);
+  }
+  if (snap.summary.decisions.length) {
+    essential.push("", "### Recent decisions");
+    for (const d of snap.summary.decisions.slice(0, MAX_BULLETS2)) essential.push(`- ${d}`);
+  }
+  const extra = [];
+  if (snap.recentCommits.length) {
+    extra.push("", "### Recent commits");
+    for (const c of snap.recentCommits.slice(0, MAX_COMMITS2)) {
+      const date = c.date ? ` (${c.date.slice(0, 10)})` : "";
+      extra.push(`- \`${c.hash}\` ${c.message}${date}`);
+    }
+  }
+  if (snap.filesTouched.length) {
+    const shown = snap.filesTouched.slice(0, MAX_FILES);
+    const more = snap.filesTouched.length - shown.length;
+    extra.push("", "### Files touched", shown.join(", ") + (more > 0 ? `, +${more} more` : ""));
+  }
+  let out = essential.join("\n");
+  for (const line of extra) {
+    if ((out + "\n" + line).length > RESUME_PRIMER_MAX_CHARS) break;
+    out += "\n" + line;
+  }
+  return (out.length > RESUME_PRIMER_MAX_CHARS ? out.slice(0, RESUME_PRIMER_MAX_CHARS) : out).trimEnd();
+}
+async function handlePrime(ctx, port) {
+  const legacy = legacyPrimer(ctx);
+  const snap = await readSession(ctx.paths.sessionState);
+  if (!snap || !hasContent(snap)) {
+    return { primer: legacy, port };
+  }
+  const branchNow = await currentBranch(ctx.paths.projectRoot);
+  const digest = buildResumeDigest(snap, branchNow);
+  return { primer: `${digest}
+
+---
+
+${legacy}`, port };
 }
 
 // src/server/http.ts
@@ -4893,9 +5308,7 @@ async function loadContext(paths) {
       readSymbolIndex(paths.symbolIndex)
     ]);
     if (graph.schema_version !== SCHEMA_VERSION2) {
-      log.info(
-        `graph schema v${graph.schema_version} \u2260 current v${SCHEMA_VERSION2} \u2014 rescanning\u2026`
-      );
+      log.info(`graph schema v${graph.schema_version} \u2260 current v${SCHEMA_VERSION2} \u2014 rescanning\u2026`);
       await scanProject(paths.projectRoot, { silent: true });
       [graph, symbolIndex] = await Promise.all([
         readGraph(paths.infoGraph),
@@ -4903,7 +5316,8 @@ async function loadContext(paths) {
       ]);
     }
     const activity = new ActivityStore(paths.activityLog);
-    return { paths, graph, symbolIndex, activity };
+    const learn = await LearnRuntime.load(paths.accessLog, paths.learnStore);
+    return { paths, graph, symbolIndex, activity, learn };
   } catch (err2) {
     throw new Error(
       `failed to load graph from ${paths.infoGraph}: ${err2.message}. Run \`syn scan\` first.`
@@ -4940,9 +5354,7 @@ function buildApp(ctx, port) {
   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)
-    );
+    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(() => ({}));
@@ -4963,11 +5375,8 @@ async function startServer(paths, options = {}) {
   const port = options.port ?? await findFreePort();
   const app = buildApp(ctx, port);
   const nodeServer = serve2({ fetch: app.fetch, port, hostname: "127.0.0.1" });
-  await writeFile8(paths.mcpPort, String(port), "utf8");
-  const fileWatcher = createFileWatcher(
-    paths.projectRoot,
-    (e) => ctx.activity.add(e)
-  );
+  await writeFile10(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") {
@@ -5004,6 +5413,7 @@ async function startServer(paths, options = {}) {
     async stop() {
       await fileWatcher.stop().catch(() => void 0);
       await gitWatcher.stop().catch(() => void 0);
+      await ctx.learn?.flush().catch(() => void 0);
       await new Promise((resolve6, reject) => {
         nodeServer.close((err2) => err2 ? reject(err2) : resolve6());
       });
@@ -5109,7 +5519,7 @@ async function dashboardCommand(rawPath) {
 }
 
 // src/cli/doctor-command.ts
-import { readFile as readFile14, stat as stat4 } from "fs/promises";
+import { readFile as readFile16, stat as stat4 } from "fs/promises";
 import { join as join10, resolve as resolve3 } from "path";
 import spawn from "cross-spawn";
 var ICON = { ok: "\u2705", warn: "\u26A0\uFE0F", fail: "\u274C" };
@@ -5140,7 +5550,11 @@ async function runDoctorChecks(projectRoot) {
   const checks = [];
   const nodeMajor = Number(process.versions.node.split(".")[0]);
   checks.push(
-    nodeMajor >= 18 ? { status: "ok", label: "Node", detail: `v${process.versions.node}` } : { status: "fail", label: "Node", detail: `v${process.versions.node} \u2014 Synthra needs Node >= 18` }
+    nodeMajor >= 18 ? { status: "ok", label: "Node", detail: `v${process.versions.node}` } : {
+      status: "fail",
+      label: "Node",
+      detail: `v${process.versions.node} \u2014 Synthra needs Node >= 18`
+    }
   );
   const hasJq = await binWorks("jq", ["--version"]);
   if (process.platform === "win32") {
@@ -5167,14 +5581,19 @@ async function runDoctorChecks(projectRoot) {
     }
   );
   if (!await exists2(paths.infoGraph)) {
-    checks.push({ status: "warn", label: "Graph", detail: "no info_graph.json \u2014 run `syn .` (or `syn scan`) here." });
+    checks.push({
+      status: "warn",
+      label: "Graph",
+      detail: "no info_graph.json \u2014 run `syn .` (or `syn scan`) here."
+    });
   } else {
     try {
-      const graph = JSON.parse(await readFile14(paths.infoGraph, "utf8"));
+      const graph = JSON.parse(await readFile16(paths.infoGraph, "utf8"));
       const parts = [`${graph.symbol_count} symbols`, `${graph.file_count} files`];
       let status = "ok";
       const ageMs = Date.now() - Date.parse(graph.generated_at);
-      if (Number.isFinite(ageMs)) parts.push(`scanned ${Math.max(0, Math.round(ageMs / 6e4))}m ago`);
+      if (Number.isFinite(ageMs))
+        parts.push(`scanned ${Math.max(0, Math.round(ageMs / 6e4))}m ago`);
       if (graph.schema_version !== SCHEMA_VERSION2) {
         status = "warn";
         parts.push(`schema v${graph.schema_version} \u2260 v${SCHEMA_VERSION2} (auto-rescans on serve)`);
@@ -5185,22 +5604,38 @@ async function runDoctorChecks(projectRoot) {
       }
       checks.push({ status, label: "Graph", detail: parts.join(" \xB7 ") });
     } catch {
-      checks.push({ status: "warn", label: "Graph", detail: "info_graph.json unreadable \u2014 re-run `syn scan`." });
+      checks.push({
+        status: "warn",
+        label: "Graph",
+        detail: "info_graph.json unreadable \u2014 re-run `syn scan`."
+      });
     }
   }
   checks.push(
-    await exists2(join10(projectRoot, ".mcp.json")) ? { status: "ok", label: "MCP registration", detail: ".mcp.json present (IDE can see graph_* tools)" } : {
+    await exists2(join10(projectRoot, ".mcp.json")) ? {
+      status: "ok",
+      label: "MCP registration",
+      detail: ".mcp.json present (IDE can see graph_* tools)"
+    } : {
       status: "warn",
       label: "MCP registration",
       detail: "no .mcp.json \u2014 the IDE extension won't see Synthra's tools; run `syn .`."
     }
   );
   if (!await exists2(paths.claudeMd)) {
-    checks.push({ status: "warn", label: "CLAUDE.md policy", detail: "no CLAUDE.md \u2014 run `syn .` to scaffold + inject the policy block." });
+    checks.push({
+      status: "warn",
+      label: "CLAUDE.md policy",
+      detail: "no CLAUDE.md \u2014 run `syn .` to scaffold + inject the policy block."
+    });
   } else {
-    const md = await readFile14(paths.claudeMd, "utf8");
+    const md = await readFile16(paths.claudeMd, "utf8");
     if (md.includes(`synthra-policy v${POLICY_VERSION} BEGIN`)) {
-      checks.push({ status: "ok", label: "CLAUDE.md policy", detail: `policy block v${POLICY_VERSION}` });
+      checks.push({
+        status: "ok",
+        label: "CLAUDE.md policy",
+        detail: `policy block v${POLICY_VERSION}`
+      });
     } else {
       const m = md.match(/synthra-policy v(\d+) BEGIN/);
       checks.push({
@@ -5211,11 +5646,19 @@ async function runDoctorChecks(projectRoot) {
     }
   }
   if (!await exists2(paths.claudeSettings)) {
-    checks.push({ status: "warn", label: "Hooks", detail: "no .claude/settings.local.json \u2014 run `syn .` to install hooks." });
+    checks.push({
+      status: "warn",
+      label: "Hooks",
+      detail: "no .claude/settings.local.json \u2014 run `syn .` to install hooks."
+    });
   } else {
-    const s = await readFile14(paths.claudeSettings, "utf8");
+    const s = await readFile16(paths.claudeSettings, "utf8");
     checks.push(
-      s.includes("synthra-hook=true") ? { status: "ok", label: "Hooks", detail: "registered in .claude/settings.local.json" } : { status: "warn", label: "Hooks", detail: "settings.local.json present but no Synthra hooks \u2014 run `syn .`." }
+      s.includes("synthra-hook=true") ? { status: "ok", label: "Hooks", detail: "registered in .claude/settings.local.json" } : {
+        status: "warn",
+        label: "Hooks",
+        detail: "settings.local.json present but no Synthra hooks \u2014 run `syn .`."
+      }
     );
   }
   return checks;
@@ -5232,12 +5675,14 @@ async function doctorCommand(rawPath) {
   const warn = checks.filter((c) => c.status === "warn").length;
   const fail = checks.filter((c) => c.status === "fail").length;
   log.info("");
-  log.info(fail === 0 && warn === 0 ? "  All checks passed." : `  ${fail} failed \xB7 ${warn} warning(s).`);
+  log.info(
+    fail === 0 && warn === 0 ? "  All checks passed." : `  ${fail} failed \xB7 ${warn} warning(s).`
+  );
   log.info("");
 }
 
 // src/cli/self-update.ts
-import { mkdir as mkdir11, readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir13, readFile as readFile17, writeFile as writeFile11 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { join as join11 } from "path";
 import { createInterface } from "readline/promises";
@@ -5295,7 +5740,7 @@ async function checkForUpdate() {
 }
 async function readLastSeen() {
   try {
-    const raw = await readFile15(LAST_SEEN_PATH, "utf8");
+    const raw = await readFile17(LAST_SEEN_PATH, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? null;
   } catch {
@@ -5304,9 +5749,9 @@ async function readLastSeen() {
 }
 async function writeLastSeen(version) {
   try {
-    await mkdir11(SYNTHRA_DIR, { recursive: true });
+    await mkdir13(SYNTHRA_DIR, { recursive: true });
     const data = { version, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
-    await writeFile9(LAST_SEEN_PATH, JSON.stringify(data, null, 2), "utf8");
+    await writeFile11(LAST_SEEN_PATH, JSON.stringify(data, null, 2), "utf8");
   } catch {
   }
 }
@@ -5338,7 +5783,7 @@ async function readInstalledChangelog() {
   const root = await npmGlobalRoot();
   if (!root) return null;
   try {
-    return await readFile15(join11(root, "@jefuriiij", "synthra", "CHANGELOG.md"), "utf8");
+    return await readFile17(join11(root, "@jefuriiij", "synthra", "CHANGELOG.md"), "utf8");
   } catch {
     return null;
   }
@@ -5470,7 +5915,9 @@ function runClaude(bin, args, cwd, stdio = "pipe") {
 }
 async function registerMcp(bin, mcpPort, cwd) {
   const url = `http://127.0.0.1:${mcpPort}/mcp`;
-  await runClaude(bin, ["mcp", "remove", MCP_NAME, "--scope", "project"], cwd).catch(() => void 0);
+  await runClaude(bin, ["mcp", "remove", MCP_NAME, "--scope", "project"], cwd).catch(
+    () => void 0
+  );
   const reg = await runClaude(
     bin,
     ["mcp", "add", MCP_NAME, "--transport", "http", "--scope", "project", url],
@@ -5501,7 +5948,9 @@ async function spawnClaude(bin, opts) {
 var VERSION2 = package_default.version;
 function printReadyBanner(info) {
   log.info("");
-  log.info(`  \u2705  scanned   ${info.scan.parsed} files \xB7 ${info.scan.symbolCount} symbols \xB7 ${info.scan.edgeCount} edges`);
+  log.info(
+    `  \u2705  scanned   ${info.scan.parsed} files \xB7 ${info.scan.symbolCount} symbols \xB7 ${info.scan.edgeCount} edges`
+  );
   if (info.mcpRegistered) {
     log.info(`  \u{1F9E0}  MCP       ${info.mcpUrl}   \u2192  registered as 'synthra'`);
   } else {
@@ -5514,7 +5963,9 @@ function printReadyBanner(info) {
   }
   log.info(`  \u{1FA9D}  Hooks     installed in .claude/settings.local.json`);
   log.info("");
-  log.info(`  \u{1F916}  Ready \u2014 open the Claude Code IDE extension (or run \`claude\` in another terminal).`);
+  log.info(
+    `  \u{1F916}  Ready \u2014 open the Claude Code IDE extension (or run \`claude\` in another terminal).`
+  );
   log.info(`      Synthra's tools and gate will be active for that session.`);
   log.info("");
   log.info(`  Press Ctrl+C here when you're done.`);
@@ -5571,24 +6022,22 @@ async function defaultFlow(rawPath, opts) {
   } finally {
     await unregisterMcp(cfg.claudeBin, projectRoot).catch(() => void 0);
     if (dashboardHandle) {
-      await dashboardHandle.stop().catch(
-        (err2) => log.warn(`dashboard stop error: ${err2.message}`)
-      );
+      await dashboardHandle.stop().catch((err2) => log.warn(`dashboard stop error: ${err2.message}`));
     }
-    await mcpHandle.stop().catch(
-      (err2) => log.warn(`MCP server stop error: ${err2.message}`)
-    );
-    await cleanup(paths).catch(
-      (err2) => log.warn(`cleanup error: ${err2.message}`)
-    );
+    await mcpHandle.stop().catch((err2) => log.warn(`MCP server stop error: ${err2.message}`));
+    await cleanup(paths).catch((err2) => log.warn(`cleanup error: ${err2.message}`));
   }
 }
 function buildProgram() {
   const prog = sade("syn");
   prog.version(VERSION2).describe("Local context engine for AI coding assistants.");
-  prog.command(". [path]", "Scan + MCP + dashboard + hooks. Default flow \u2014 use with the Claude Code IDE extension.", {
-    default: true
-  }).option("--resume <id>", "Resume an existing Claude session (only with --launch-cli)").option("--launch-cli", "Also spawn `claude` CLI in this terminal (legacy M3 behavior)", false).action(async (path, opts) => {
+  prog.command(
+    ". [path]",
+    "Scan + MCP + dashboard + hooks. Default flow \u2014 use with the Claude Code IDE extension.",
+    {
+      default: true
+    }
+  ).option("--resume <id>", "Resume an existing Claude session (only with --launch-cli)").option("--launch-cli", "Also spawn `claude` CLI in this terminal (legacy M3 behavior)", false).action(async (path, opts) => {
     await defaultFlow(path ?? ".", opts);
   });
   prog.command("scan [path]", "Scan only \u2014 walk + parse + write graph.").action(async (path) => {