@jefuriiij/synthra 0.1.25 → 0.2.0

package/dist/server/index.js

@@ -1,7 +1,7 @@
 // src/server/http.ts
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
-import { writeFile as writeFile6 } from "fs/promises";
+import { writeFile as writeFile8 } from "fs/promises";
 
 // src/activity/activity-log.ts
 import { appendFile, mkdir } from "fs/promises";
@@ -488,7 +488,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}`;
@@ -1597,6 +1610,8 @@ function resolvePaths(projectRoot) {
     tokenLog: join5(graphDir, "token_log.jsonl"),
     gateLog: join5(graphDir, "gate_log.jsonl"),
     toolLog: join5(graphDir, "tool_log.jsonl"),
+    accessLog: join5(graphDir, "access_log.jsonl"),
+    learnStore: join5(graphDir, "learn_store.json"),
     mcpPort: join5(graphDir, "mcp_port"),
     mcpServerLog: join5(graphDir, "mcp_server.log"),
     mcpServerErrLog: join5(graphDir, "mcp_server.err.log"),
@@ -1618,7 +1633,7 @@ import { basename as basename2 } from "path";
 // src/hooks/claude-md.ts
 import { readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
 import { basename, dirname as dirname4 } 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;
@@ -1709,6 +1724,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"),`,
@@ -1887,7 +1913,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");
     }
@@ -1932,11 +1960,191 @@ async function scanProject(projectRootRaw, opts = {}) {
   };
 }
 
+// src/learn/store.ts
+import { appendFile as appendFile2, mkdir as mkdir4, readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname5 } 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, stat3] of Object.entries(store.files)) {
+    const eff = stat3.decayed * decayFactor(stat3.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 readFile8(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 mkdir4(dirname5(path), { recursive: true });
+    await writeFile4(path, JSON.stringify(store, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+async function readAccessLog(path) {
+  try {
+    const raw = await readFile8(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 mkdir4(dirname5(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 mkdir6 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { appendFile as appendFile3, mkdir as mkdir7 } from "fs/promises";
+import { dirname as dirname8 } 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",
@@ -2083,6 +2291,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;
 }
@@ -2091,9 +2314,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: [],
@@ -2107,7 +2328,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);
@@ -2140,14 +2362,14 @@ async function retrieve(graph, query, options = {}) {
 
 // src/memory/branches.ts
 import { execFile as execFile2 } from "child_process";
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } 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 head = await readFile9(headPath, "utf8");
     const trimmed = head.trim();
     const match = trimmed.match(/^ref:\s+refs\/heads\/(.+)$/);
     if (match?.[1]) return match[1];
@@ -2197,8 +2419,8 @@ function resolveBranchPaths(contextDir, branch, isDefault) {
 }
 
 // src/memory/context-md.ts
-import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname6 } from "path";
 var MAX_BULLETS = 3;
 function deriveContextMd(entries, branch) {
   const tasks = entries.filter((e) => e.type === "task").reverse();
@@ -2241,17 +2463,17 @@ function formatContextMd(ctx) {
   return lines.join("\n");
 }
 async function writeContextMd(path, ctx) {
-  await mkdir4(dirname5(path), { recursive: true });
-  await writeFile4(path, formatContextMd(ctx), "utf8");
+  await mkdir5(dirname6(path), { recursive: true });
+  await writeFile5(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 dirname6 } from "path";
+import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname7 } from "path";
 var SCHEMA_VERSION2 = 1;
 async function readEntries(path) {
   try {
-    const raw = await readFile10(path, "utf8");
+    const raw = await readFile11(path, "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.entries) ? parsed.entries : [];
   } catch {
@@ -2259,9 +2481,9 @@ async function readEntries(path) {
   }
 }
 async function writeEntries(path, entries) {
-  await mkdir5(dirname6(path), { recursive: true });
+  await mkdir6(dirname7(path), { recursive: true });
   const store = { schema_version: SCHEMA_VERSION2, entries };
-  await writeFile5(path, JSON.stringify(store, null, 2) + "\n", "utf8");
+  await writeFile6(path, JSON.stringify(store, null, 2) + "\n", "utf8");
 }
 async function appendEntry(path, entry) {
   const entries = await readEntries(path);
@@ -2535,7 +2757,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"]
     }
@@ -2691,9 +2916,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) {
@@ -2740,8 +2963,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,
@@ -2787,9 +3010,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}
@@ -2807,7 +3032,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];
@@ -2824,6 +3049,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}
 
@@ -2845,10 +3071,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);
@@ -2884,9 +3121,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) {
@@ -2918,8 +3153,8 @@ async function contextRecall(args, ctx) {
 }
 async function logToolCall(ctx, tool) {
   try {
-    await mkdir6(dirname7(ctx.paths.toolLog), { recursive: true });
-    await appendFile2(
+    await mkdir7(dirname8(ctx.paths.toolLog), { recursive: true });
+    await appendFile3(
       ctx.paths.toolLog,
       JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool }) + "\n",
       "utf8"
@@ -2927,6 +3162,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.");
@@ -2996,9 +3241,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 mkdir8, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname9 } from "path";
+var SESSION_SCHEMA_VERSION = 1;
+async function readSession(path) {
+  try {
+    const raw = await readFile12(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 mkdir8(dirname9(path), { recursive: true });
+  await writeFile7(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,
@@ -3008,8 +3331,8 @@ async function handleContextUpdate(req, ctx) {
 }
 
 // src/server/routes/gate.ts
-import { appendFile as appendFile3, mkdir as mkdir7 } from "fs/promises";
-import { dirname as dirname8 } from "path";
+import { appendFile as appendFile4, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname10 } from "path";
 var BLOCKABLE_TOOLS = /* @__PURE__ */ new Set(["Grep", "Glob"]);
 var RECENT_ACTIVITY_WINDOW_MS = 5 * 60 * 1e3;
 function extractQuery(toolName, input) {
@@ -3065,7 +3388,7 @@ function recentlyTouchedMatchesQuery(recentPaths, queryTokens, graph) {
 }
 async function logDecision(ctx, toolName, query, decision, reason) {
   try {
-    await mkdir7(dirname8(ctx.paths.gateLog), { recursive: true });
+    await mkdir9(dirname10(ctx.paths.gateLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
@@ -3073,7 +3396,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 {
   }
 }
@@ -3137,16 +3460,16 @@ async function handleGate(req, ctx) {
 }
 
 // src/server/routes/log.ts
-import { appendFile as appendFile4, mkdir as mkdir8 } from "fs/promises";
-import { dirname as dirname9 } from "path";
+import { appendFile as appendFile5, mkdir as mkdir10 } from "fs/promises";
+import { dirname as dirname11 } 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 mkdir8(dirname9(ctx.paths.tokenLog), { recursive: true });
-  await appendFile4(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
+  await mkdir10(dirname11(ctx.paths.tokenLog), { recursive: true });
+  await appendFile5(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
   return { ok: true, written_at };
 }
 
@@ -3156,13 +3479,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) {
@@ -3184,14 +3509,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
@@ -3202,9 +3587,7 @@ async function loadContext(paths) {
       readSymbolIndex(paths.symbolIndex)
     ]);
     if (graph.schema_version !== SCHEMA_VERSION) {
-      log.info(
-        `graph schema v${graph.schema_version} \u2260 current v${SCHEMA_VERSION} \u2014 rescanning\u2026`
-      );
+      log.info(`graph schema v${graph.schema_version} \u2260 current v${SCHEMA_VERSION} \u2014 rescanning\u2026`);
       await scanProject(paths.projectRoot, { silent: true });
       [graph, symbolIndex] = await Promise.all([
         readGraph(paths.infoGraph),
@@ -3212,7 +3595,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.`
@@ -3249,9 +3633,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(() => ({}));
@@ -3272,11 +3654,8 @@ async function startServer(paths, options = {}) {
   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)
-  );
+  await writeFile8(paths.mcpPort, String(port), "utf8");
+  const fileWatcher = createFileWatcher(paths.projectRoot, (e) => ctx.activity.add(e));
   const gitWatcher = createGitWatcher(paths.projectRoot, async (e) => {
     await ctx.activity.add(e);
     if (e.kind === "branch-switch") {
@@ -3313,6 +3692,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((resolve2, reject) => {
         nodeServer.close((err2) => err2 ? reject(err2) : resolve2());
       });