@jefuriiij/synthra 0.14.1 → 0.16.0

package/CHANGELOG.md

@@ -7,6 +7,49 @@ For older versions, see [GitHub Releases](https://github.com/jefuriiij/synthra/r
 
 ---
 
+## [0.16.0] — 2026-07-02
+
+### Added
+
+- **The Dispatcher — Synthra now routes your tasks.** On every prompt, Synthra
+  scores the request against every installed subagent and skill (plus the
+  project's language fingerprint) and — when it finds a clear fit — injects a
+  one-line hint: *"[Synthra route] This task fits agent 'X' (model: sonnet) +
+  skill 'Y'. Plan here first, then delegate execution."* Works for any domain
+  your arsenal covers: UI work routes to your frontend agents, security audits
+  to your security agents, and so on. Silent when unsure. Disable with
+  `SYN_NO_ROUTE`; tune the confidence bar with `SYN_ROUTE_MIN_SCORE`.
+- **`route_task` tool** — the on-demand version: ask which installed
+  agent/skill fits a task and which model to run it on; returns ranked
+  candidates with match reasons.
+- **Model policy baked in:** plan on the primary model, delegate execution to a
+  subagent on a cheaper one (Sonnet is ~5× cheaper than Opus on every rate).
+  Agents that pin their own `model:` are respected; everything else defaults to
+  a `sonnet` recommendation.
+
+---
+
+## [0.15.0] — 2026-07-02
+
+### Added
+
+- **Your remembered context now talks back.** Synthra's second brain was
+  write-only — decisions and gotchas went in via `context_remember` and never
+  resurfaced. Now they appear exactly where they're relevant:
+  - `graph_read` of a file (or a symbol in it) shows a `📌 Remembered for this
+    file` block with the entries linked to that file.
+  - `graph_continue` packs include `Remembered:` lines for entries matching the
+    query.
+- **Memories know when they might be wrong.** Entries linked to files are now
+  *anchored* to those files' content hashes at capture time. When the code
+  changes afterwards (tracked live by auto-reindex), every surfacing of that
+  entry — graph_read, graph_continue, context_recall — carries
+  `⚠ possibly stale — <file> changed since stored`. Old entries without anchors
+  keep working and are never flagged; the shared context-store format is
+  unchanged (additive optional field).
+
+---
+
 ## [0.14.1] — 2026-07-02
 
 ### Added

package/dist/cli/index.js

@@ -18,7 +18,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jefuriiij/synthra",
-      version: "0.14.1",
+      version: "0.16.0",
       publishConfig: {
         access: "public"
       },
@@ -517,6 +517,7 @@ function resolvePaths(projectRoot) {
     tokenLog: join2(graphDir, "token_log.jsonl"),
     gateLog: join2(graphDir, "gate_log.jsonl"),
     bashLog: join2(graphDir, "bash_log.jsonl"),
+    routeLog: join2(graphDir, "route_log.jsonl"),
     toolLog: join2(graphDir, "tool_log.jsonl"),
     accessLog: join2(graphDir, "access_log.jsonl"),
     learnStore: join2(graphDir, "learn_store.json"),
@@ -1062,6 +1063,44 @@ fi
 exit 0
 `;
 
+// src/hooks/scripts/route.ps1
+var route_default = '# UserPromptSubmit hook \u2014 Windows PowerShell.\n# THE DISPATCHER. Reads the prompt event from stdin (JSON), POSTs it to /route,\n# and prints the routing hint (if any) to stdout \u2014 Claude Code injects\n# UserPromptSubmit stdout into the conversation as added context.\n# Always exits 0; any failure leaves the prompt untouched.\n\n$ErrorActionPreference = "SilentlyContinue"\n\n$raw = [Console]::In.ReadToEnd()\nif (-not $raw) { exit 0 }\n\ntry {\n    $hookInput = $raw | ConvertFrom-Json -ErrorAction Stop\n} catch {\n    exit 0\n}\nif (-not $hookInput.prompt) { exit 0 }\n\n$portFile = Join-Path $PWD ".synthra-graph\\mcp_port"\nif (-not (Test-Path $portFile)) { exit 0 }\n$port = (Get-Content -Path $portFile -Raw).Trim()\nif (-not $port) { exit 0 }\n\n$payload = @{ prompt = $hookInput.prompt } | ConvertTo-Json -Compress\n\ntry {\n    $resp = Invoke-RestMethod -Uri "http://127.0.0.1:$port/route" -Method POST `\n        -Body $payload -ContentType "application/json" -TimeoutSec 3\n    if ($resp.hint) { Write-Output $resp.hint }\n} catch {\n    # silent on failure \u2014 the prompt proceeds without a routing hint\n}\nexit 0\n';
+
+// src/hooks/scripts/route.sh
+var route_default2 = `#!/usr/bin/env bash
+# UserPromptSubmit hook \u2014 bash.
+# THE DISPATCHER. Reads the prompt event from stdin (JSON), POSTs it to /route,
+# and prints the routing hint (if any) to stdout \u2014 Claude Code injects
+# UserPromptSubmit stdout into the conversation as added context.
+# Always exits 0; requires \`jq\` (silently no-ops without it, like the other hooks).
+
+set +e
+
+PORT_FILE="$PWD/.synthra-graph/mcp_port"
+if [ ! -f "$PORT_FILE" ]; then exit 0; fi
+PORT=$(cat "$PORT_FILE" 2>/dev/null | tr -d '[:space:]')
+if [ -z "$PORT" ]; then exit 0; fi
+
+if ! command -v jq >/dev/null 2>&1; then exit 0; fi
+
+INPUT=$(cat 2>/dev/null)
+if [ -z "$INPUT" ]; then exit 0; fi
+
+# Re-emit only the prompt field as the request body (jq handles escaping).
+BODY=$(printf '%s' "$INPUT" | jq -c '{prompt: (.prompt // empty)}' 2>/dev/null)
+if [ -z "$BODY" ] || [ "$BODY" = "{}" ]; then exit 0; fi
+
+HINT=$(curl -sS --max-time 3 -X POST -H "Content-Type: application/json" \\
+  --data "$BODY" "http://127.0.0.1:$PORT/route" 2>/dev/null \\
+  | jq -r '.hint // empty' 2>/dev/null \\
+  | head -c 2000)
+
+if [ -n "$HINT" ]; then
+  printf '%s\\n' "$HINT"
+fi
+exit 0
+`;
+
 // src/hooks/scripts/stop.ps1
 var stop_default = `# Stop hook \u2014 Windows PowerShell.\r
 # Reads Claude's transcript JSONL from $hookInput.transcript_path, sums\r
@@ -1226,7 +1265,9 @@ var SCRIPTS = [
     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 }
+  { event: "Stop", baseName: "synthra-stop", ps1: stop_default, sh: stop_default2 },
+  // The Dispatcher — per-prompt routing hint (best-fit agent/skill/model).
+  { event: "UserPromptSubmit", baseName: "synthra-route", ps1: route_default, sh: route_default2 }
 ];
 function commandFor(scriptPath) {
   if (process.platform === "win32") {
@@ -3046,7 +3087,7 @@ import { basename as basename5 } from "path";
 // src/hooks/claude-md.ts
 import { readFile as readFile12, writeFile as writeFile6 } from "fs/promises";
 import { basename as basename4, dirname as dirname9 } from "path";
-var POLICY_VERSION = 8;
+var POLICY_VERSION = 9;
 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;
@@ -3068,7 +3109,7 @@ function policyBlock() {
     "> `mcp__synthra__graph_register_edit`. **Short names will NOT resolve**",
     "> in ToolSearch or invocation \u2014 always use the full namespaced form.",
     "> If the tools are deferred, load their schemas with ToolSearch:",
-    "> `select:mcp__synthra__graph_continue,mcp__synthra__graph_read,mcp__synthra__graph_register_edit,mcp__synthra__find_symbol`.",
+    "> `select:mcp__synthra__graph_continue,mcp__synthra__graph_read,mcp__synthra__graph_register_edit,mcp__synthra__find_symbol,mcp__synthra__route_task`.",
     "> Below, short names (`graph_continue` etc.) appear in prose for",
     "> readability only.",
     "",
@@ -3086,6 +3127,11 @@ function policyBlock() {
     "  util, or function, call this to check whether one already exists. If it",
     "  returns matches, reuse or extend them instead of re-implementing; only",
     '  "no match \u2014 safe to create" means it is genuinely new.',
+    "- **`route_task(task)`** \u2014 **delegate-first**: before starting a multi-step",
+    "  implementation task, ask which installed subagent/skill fits it. Plan on",
+    "  the primary model, then hand execution to the recommended subagent on a",
+    "  cheaper model (sonnet \u2248 5\xD7 cheaper than opus). Synthra may also inject a",
+    "  `[Synthra route]` hint on your prompt \u2014 treat it the same way.",
     "",
     "### When to call `graph_continue` \u2014 and when to skip",
     "",
@@ -3473,6 +3519,10 @@ function loadConfig() {
     // the terminal bypass of the Moat can be measured. Never blocks. Opt out
     // with SYN_NO_BASH_OBSERVE.
     bashObserve: !process.env.SYN_NO_BASH_OBSERVE,
+    // The Dispatcher: per-prompt routing hints (best-fit agent/skill/model).
+    // Silent unless the top agent clears routeMinScore. SYN_NO_ROUTE disables.
+    route: !process.env.SYN_NO_ROUTE,
+    routeMinScore: num("SYN_ROUTE_MIN_SCORE", 3),
     mcpPort: process.env.SYN_MCP_PORT ? num("SYN_MCP_PORT", 0) : null,
     dashboardPort: num("SYN_DASHBOARD_PORT", 8901),
     logLevel: str("SYN_LOG_LEVEL", "info"),
@@ -3481,8 +3531,8 @@ function loadConfig() {
 }
 
 // src/server/mcp.ts
-import { appendFile as appendFile3, mkdir as mkdir10 } from "fs/promises";
-import { dirname as dirname12 } from "path";
+import { appendFile as appendFile4, mkdir as mkdir11 } from "fs/promises";
+import { dirname as dirname13 } from "path";
 
 // src/graph/rank.ts
 var KW_BASE_WEIGHT = 2;
@@ -3882,7 +3932,8 @@ async function rememberEntry(paths, input) {
     content: input.text,
     tags: input.tags ?? [],
     files: input.files ?? [],
-    date: (/* @__PURE__ */ new Date()).toISOString()
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    ...input.anchors && input.anchors.length > 0 ? { anchors: input.anchors } : {}
   };
   await appendEntry(active.paths.contextStore, entry);
   const entries = await readEntries(active.paths.contextStore);
@@ -4101,6 +4152,158 @@ async function pack(files, opts) {
   };
 }
 
+// src/server/routes/route-match.ts
+var ROUTE_MIN_PROMPT_TOKENS = 3;
+var ROUTE_MAX_AGENTS = 3;
+var ROUTE_MAX_SKILLS = 2;
+var FINGERPRINT_BOOST = 2;
+var NAME_HIT_WEIGHT = 3;
+var EXT_KEYWORDS = {
+  ".svelte": ["svelte"],
+  ".vue": ["vue"],
+  ".tsx": ["react", "typescript"],
+  ".jsx": ["react"],
+  ".ts": ["typescript"],
+  ".py": ["python"],
+  ".cs": ["csharp", "dotnet"],
+  ".dart": ["flutter", "dart"],
+  ".rs": ["rust"],
+  ".go": ["golang", "go"],
+  ".java": ["java"],
+  ".kt": ["kotlin"],
+  ".php": ["php", "laravel"],
+  ".rb": ["ruby", "rails"],
+  ".hubl": ["hubspot", "hubl"],
+  ".html": ["html", "css"]
+};
+function fingerprintKeywords(extCounts) {
+  const total = [...extCounts.values()].reduce((a, b) => a + b, 0);
+  const out = /* @__PURE__ */ new Set();
+  if (total === 0) return out;
+  for (const [ext, count] of extCounts) {
+    if (count / total < 0.2) continue;
+    for (const kw of EXT_KEYWORDS[ext] ?? []) out.add(kw);
+  }
+  return out;
+}
+function scoreItem(item, qTokens, fingerprint) {
+  const nameTokens = new Set(tokenizeQuery(item.name));
+  const descTokens = new Set(tokenizeQuery(item.description));
+  let score2 = 0;
+  const hits = [];
+  for (const t of qTokens) {
+    if (nameTokens.has(t)) {
+      score2 += NAME_HIT_WEIGHT;
+      hits.push(t);
+    } else if (descTokens.has(t)) {
+      score2 += 1;
+      hits.push(t);
+    }
+  }
+  for (const kw of fingerprint) {
+    if (nameTokens.has(kw) || descTokens.has(kw)) {
+      score2 += FINGERPRINT_BOOST;
+      break;
+    }
+  }
+  return { item, score: score2, hits };
+}
+function scoreArsenal(prompt, arsenal, extCounts, minScore) {
+  const qTokens = new Set(tokenizeQuery(prompt));
+  if (qTokens.size < ROUTE_MIN_PROMPT_TOKENS) {
+    return { confident: false, agents: [], skills: [] };
+  }
+  const fingerprint = fingerprintKeywords(extCounts);
+  const rank = (items) => items.filter((i) => i.enabled !== false).map((i) => scoreItem(i, qTokens, fingerprint)).filter((s) => s.score > 0).sort((a, b) => b.score - a.score || a.item.name.localeCompare(b.item.name));
+  const agents = rank(arsenal.agents).slice(0, ROUTE_MAX_AGENTS).map((s) => ({
+    name: s.item.name,
+    score: s.score,
+    reason: s.hits.length ? `matches: ${s.hits.slice(0, 4).join(", ")}` : "language fit",
+    model: s.item.meta?.model?.trim() || "sonnet"
+  }));
+  const skills = rank(arsenal.skills).slice(0, ROUTE_MAX_SKILLS).map((s) => ({
+    name: s.item.name,
+    score: s.score,
+    reason: s.hits.length ? `matches: ${s.hits.slice(0, 4).join(", ")}` : "language fit"
+  }));
+  const confident = agents.length > 0 && (agents[0]?.score ?? 0) >= minScore;
+  return { confident, agents, skills };
+}
+function renderHint(match) {
+  if (!match.confident || match.agents.length === 0) return "";
+  const a = match.agents[0];
+  const skill = match.skills[0] ? ` + skill '${match.skills[0].name}'` : "";
+  return `[Synthra route] This task fits agent '${a.name}' (model: ${a.model})${skill}. Plan here first, then delegate execution to it - execution on cheaper models cuts cost ~5x.`;
+}
+function renderRouteReport(task, match) {
+  const lines = [`# route_task: "${task}"`, ""];
+  if (match.agents.length === 0 && match.skills.length === 0) {
+    lines.push(
+      "No strong match in the installed Arsenal \u2014 proceed yourself (browse the dashboard's Arsenal tab to see what's available)."
+    );
+    return lines.join("\n");
+  }
+  if (match.agents.length > 0) {
+    lines.push(match.confident ? "Recommended agents:" : "Possible agents (low confidence):");
+    for (const a of match.agents) {
+      lines.push(`- \`${a.name}\` (model: ${a.model}) \u2014 score ${a.score}, ${a.reason}`);
+    }
+  }
+  if (match.skills.length > 0) {
+    lines.push("");
+    lines.push("Relevant skills:");
+    for (const s of match.skills) lines.push(`- \`${s.name}\` \u2014 score ${s.score}, ${s.reason}`);
+  }
+  lines.push("");
+  lines.push(
+    "_Model policy: plan on the primary model; delegate execution to a subagent on a cheaper model (sonnet \u2248 5\xD7 cheaper than opus)._"
+  );
+  return lines.join("\n");
+}
+
+// src/server/routes/route.ts
+import { appendFile as appendFile3, mkdir as mkdir10 } from "fs/promises";
+import { dirname as dirname12 } from "path";
+var defaultDeps = { arsenal: (root) => computeArsenal(root) };
+function graphExtCounts(ctx) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const n of ctx.graph.nodes) {
+    if (n.kind !== "file") continue;
+    const ext = n.ext;
+    counts.set(ext, (counts.get(ext) ?? 0) + 1);
+  }
+  return counts;
+}
+var PROMPT_LOG_MAX = 200;
+async function logRoute(ctx, prompt, hint) {
+  try {
+    await mkdir10(dirname12(ctx.paths.routeLog), { recursive: true });
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      prompt: prompt.length > PROMPT_LOG_MAX ? `${prompt.slice(0, PROMPT_LOG_MAX)}\u2026` : prompt,
+      routed: hint.length > 0,
+      hint_chars: hint.length
+    };
+    await appendFile3(ctx.paths.routeLog, JSON.stringify(entry) + "\n", "utf8");
+  } catch {
+  }
+}
+async function handleRoute(req, ctx, deps = defaultDeps) {
+  const cfg = loadConfig();
+  if (!cfg.route) return { hint: "" };
+  const prompt = typeof req?.prompt === "string" ? req.prompt.trim() : "";
+  if (!prompt) return { hint: "" };
+  try {
+    const arsenal = await deps.arsenal(ctx.paths.projectRoot);
+    const match = scoreArsenal(prompt, arsenal, graphExtCounts(ctx), cfg.routeMinScore);
+    const hint = renderHint(match);
+    await logRoute(ctx, prompt, hint);
+    return { hint };
+  } catch {
+    return { hint: "" };
+  }
+}
+
 // src/server/mcp.ts
 var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_INFO = { name: "synthra", version: "0.0.1" };
@@ -4184,7 +4387,7 @@ var TOOLS = [
         files: {
           type: "array",
           items: { type: "string" },
-          description: "Optional project-relative file paths this entry relates to."
+          description: "Optional project-relative file paths this entry relates to. Linked files also anchor the entry: recall flags it 'possibly stale' if they change, and graph_read of those files surfaces it automatically."
         }
       },
       required: ["text", "kind"]
@@ -4289,6 +4492,17 @@ var TOOLS = [
       },
       required: ["from", "to"]
     }
+  },
+  {
+    name: "route_task",
+    description: "Ask Synthra which installed subagent/skill best fits a task, and which model to run it on. Scores the task against every installed agent and skill (plus the project's language fingerprint). Use BEFORE starting a multi-step implementation task: plan on the primary model, then delegate execution to the recommended agent on a cheaper model (sonnet \u2248 5\xD7 cheaper than opus).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "The task to route, in a sentence." }
+      },
+      required: ["task"]
+    }
   }
 ];
 async function callTool(name, args, ctx) {
@@ -4317,6 +4531,8 @@ async function callTool(name, args, ctx) {
       return duplicateSymbols(args, ctx);
     case "call_path":
       return callPath(args, ctx);
+    case "route_task":
+      return routeTask(args, ctx);
     default:
       return errorContent(`Unknown tool: ${name}`);
   }
@@ -4473,6 +4689,17 @@ function testsCoveringLine(graph, filePaths) {
   const omitted = tests.length - shown.length;
   return `Tests covering the impact: ${shown.join(" \xB7 ")}${omitted > 0 ? ` \u2026+${omitted} more` : ""}`;
 }
+async function routeTask(args, ctx) {
+  const task = typeof args?.task === "string" ? args.task.trim() : "";
+  if (!task) return errorContent("route_task: 'task' (string) is required");
+  try {
+    const arsenal = await computeArsenal(ctx.paths.projectRoot);
+    const match = scoreArsenal(task, arsenal, graphExtCounts(ctx), loadConfig().routeMinScore);
+    return textContent(renderRouteReport(task, match));
+  } catch (err2) {
+    return errorContent(`route_task: arsenal scan failed \u2014 ${err2.message}`);
+  }
+}
 function resolveSymbolArg(ctx, arg) {
   const a = arg.trim();
   if (a.includes("::")) {
@@ -4726,9 +4953,28 @@ async function graphContinue(args, ctx) {
 Files: ${retrieval.files.map((f) => f.path).join(", ") || "(none)"}
 Reason: ${retrieval.reason}
 `;
-  return textContent(`${header}
+  const remembered = matchRememberedFacts(query, retrieval.files, await safeRecallAll(ctx), ctx);
+  return textContent(`${header}${remembered}
 ${packed.text}`);
 }
+function matchRememberedFacts(query, retrievedFiles, entries, ctx) {
+  if (entries.length === 0) return "";
+  const qTokens = new Set(tokenizeQuery(query));
+  const retrievedPaths = new Set(retrievedFiles.map((f) => f.path));
+  const scored = entries.map((e) => {
+    let score2 = 0;
+    for (const t of tokenizeQuery(`${e.content} ${e.tags.join(" ")}`)) {
+      if (qTokens.has(t)) score2 += 1;
+    }
+    if (e.files.some((f) => retrievedPaths.has(f)) || e.anchors?.some((a) => retrievedPaths.has(a.path))) {
+      score2 += 2;
+    }
+    return { e, score: score2 };
+  }).filter((x) => x.score > 0).sort((a, b) => b.score - a.score).slice(0, PACK_FACTS_MAX);
+  if (scored.length === 0) return "";
+  return `${scored.map((x) => `Remembered: ${factLine(x.e, ctx.graph).slice(2)}`).join("\n")}
+`;
+}
 function resolveFileTarget(graph, filePath) {
   const files = graph.nodes.filter((n) => n.kind === "file");
   const exact = files.find((n) => n.path === filePath);
@@ -4821,6 +5067,43 @@ function buildTestsFooter(symbol, graph) {
   if (isLikelyEntry(symbol.file)) return "";
   return "Tests: none linked to this file.";
 }
+var FACTS_MAX = 3;
+var FACTS_CONTENT_MAX = 160;
+var PACK_FACTS_MAX = 2;
+function staleAnchorPaths(entry, graph) {
+  if (!entry.anchors || entry.anchors.length === 0) return [];
+  const hashByPath = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) if (n.kind === "file") hashByPath.set(n.path, n.file_hash);
+  return entry.anchors.filter((a) => hashByPath.get(a.path) !== a.hash).map((a) => a.path);
+}
+function factLine(entry, graph) {
+  const content = entry.content.length > FACTS_CONTENT_MAX ? `${entry.content.slice(0, FACTS_CONTENT_MAX - 1)}\u2026` : entry.content;
+  const date = entry.date ? ` (${entry.date.slice(0, 10)})` : "";
+  const stale = staleAnchorPaths(entry, graph);
+  const staleNote = stale.length ? `  \u26A0 possibly stale \u2014 ${stale[0]} changed since stored` : "";
+  return `- [${entry.type}] ${content}${date}${staleNote}`;
+}
+function entryLinksFile(entry, filePath) {
+  if (entry.anchors?.some((a) => a.path === filePath)) return true;
+  return entry.files.some((f) => f === filePath || filePath.endsWith(`/${f}`));
+}
+function buildFactsFooter(filePath, entries, graph) {
+  const linked = entries.filter((e) => entryLinksFile(e, filePath));
+  if (linked.length === 0) return "";
+  const newestFirst = linked.slice().reverse();
+  const shown = newestFirst.slice(0, FACTS_MAX);
+  const omitted = newestFirst.length - shown.length;
+  const lines = ["\u{1F4CC} Remembered for this file:", ...shown.map((e) => factLine(e, graph))];
+  if (omitted > 0) lines.push(`\u2026+${omitted} more \u2014 mcp__synthra__context_recall()`);
+  return lines.join("\n");
+}
+async function safeRecallAll(ctx) {
+  try {
+    return (await recallEntries(ctx.paths, {})).entries;
+  } catch {
+    return [];
+  }
+}
 async function graphRead(args, ctx) {
   const target = typeof args?.target === "string" ? args.target : "";
   if (!target) return errorContent("graph_read: 'target' (string) is required");
@@ -4839,10 +5122,15 @@ async function graphRead(args, ctx) {
   }
   const fileNode = resolved.node;
   await logAccess(ctx, { ts: nowIso(), path: fileNode.path, source: "read" });
+  const facts = buildFactsFooter(fileNode.path, await safeRecallAll(ctx), ctx.graph);
+  const factsBlock = facts ? `
+
+---
+${facts}` : "";
   if (!symbolName) {
     return textContent(`# ${fileNode.path}
 
-${fileNode.content}`);
+${fileNode.content}${factsBlock}`);
   }
   const cleanSym = symbolName.trim();
   const symbol = ctx.graph.nodes.find(
@@ -4872,7 +5160,7 @@ ${tests}` : "";
   return textContent(
     `# ${fileNode.path}::${symbol.name}  (L${symbol.start_line}-${symbol.end_line})
 
-${body}${depsBlock}${testsBlock}${editHint}`
+${body}${depsBlock}${testsBlock}${factsBlock}${editHint}`
   );
 }
 var editedFiles = /* @__PURE__ */ new Set();
@@ -4907,16 +5195,26 @@ async function contextRemember(args, ctx) {
   }
   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 anchors = [];
+  for (const f of files) {
+    const resolved = resolveFileTarget(ctx.graph, f);
+    if ("node" in resolved) {
+      anchors.push({ path: resolved.node.path, hash: resolved.node.file_hash });
+    }
+  }
   const result = await rememberEntry(ctx.paths, {
     text,
     kind: kindRaw,
     tags,
-    files
+    files,
+    anchors
   });
+  const anchorNote = anchors.length ? `
+Anchored to ${anchors.length} file(s) \u2014 recall will flag this entry if they change.` : "";
   return textContent(
     `Remembered ${result.entry.type} on branch '${result.branch}'.
 Stored: ${result.storePath}
-CONTEXT.md refreshed: ${result.contextMdPath}`
+CONTEXT.md refreshed: ${result.contextMdPath}${anchorNote}`
   );
 }
 var DEFAULT_RECENT_WINDOW_MS = 60 * 60 * 1e3;
@@ -4951,15 +5249,17 @@ async function contextRecall(args, ctx) {
   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}`);
+    const stale = staleAnchorPaths(e, ctx.graph);
+    const staleNote = stale.length ? `  \u26A0 possibly stale \u2014 ${stale.join(", ")} changed since stored` : "";
+    lines.push(`- **${e.type}**${tags} (${e.date}): ${e.content}${staleNote}`);
     if (e.files.length) lines.push(`  files: ${e.files.join(", ")}`);
   }
   return textContent(lines.join("\n"));
 }
 async function logToolCall(ctx, tool) {
   try {
-    await mkdir10(dirname12(ctx.paths.toolLog), { recursive: true });
-    await appendFile3(
+    await mkdir11(dirname13(ctx.paths.toolLog), { recursive: true });
+    await appendFile4(
       ctx.paths.toolLog,
       JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool }) + "\n",
       "utf8"
@@ -5152,8 +5452,8 @@ async function getChangedLineRanges(projectRoot, sinceRef) {
 }
 
 // src/memory/session.ts
-import { mkdir as mkdir11, readFile as readFile17, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname13 } from "path";
+import { mkdir as mkdir12, readFile as readFile17, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname14 } from "path";
 var SESSION_SCHEMA_VERSION = 2;
 async function readSession(path) {
   try {
@@ -5166,7 +5466,7 @@ async function readSession(path) {
   }
 }
 async function writeSession(path, state) {
-  await mkdir11(dirname13(path), { recursive: true });
+  await mkdir12(dirname14(path), { recursive: true });
   await writeFile10(path, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 
@@ -5214,12 +5514,12 @@ async function handleContextUpdate(req, ctx) {
 }
 
 // src/server/routes/gate.ts
-import { appendFile as appendFile5, mkdir as mkdir13 } from "fs/promises";
-import { dirname as dirname15 } from "path";
+import { appendFile as appendFile6, mkdir as mkdir14 } from "fs/promises";
+import { dirname as dirname16 } from "path";
 
 // src/server/routes/bash-observe.ts
-import { appendFile as appendFile4, mkdir as mkdir12 } from "fs/promises";
-import { dirname as dirname14 } from "path";
+import { appendFile as appendFile5, mkdir as mkdir13 } from "fs/promises";
+import { dirname as dirname15 } from "path";
 
 // src/server/routes/query-heuristics.ts
 function looksLikeNonSymbolQuery(pattern) {
@@ -5378,7 +5678,7 @@ var CMD_MAX = 300;
 var trunc = (s, max) => s.length > max ? `${s.slice(0, max)}\u2026` : s;
 async function logObservation(ctx, exp, confidence, avoidable, command) {
   try {
-    await mkdir12(dirname14(ctx.paths.bashLog), { recursive: true });
+    await mkdir13(dirname15(ctx.paths.bashLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       kind: exp.kind,
@@ -5388,7 +5688,7 @@ async function logObservation(ctx, exp, confidence, avoidable, command) {
       avoidable,
       command: trunc(command, CMD_MAX)
     };
-    await appendFile4(ctx.paths.bashLog, JSON.stringify(entry) + "\n", "utf8");
+    await appendFile5(ctx.paths.bashLog, JSON.stringify(entry) + "\n", "utf8");
   } catch {
   }
 }
@@ -5458,7 +5758,7 @@ function recentlyTouchedMatchesQuery(recentPaths, queryTokens, graph) {
 var LOG_REASON_MAX_CHARS = 240;
 async function logDecision(ctx, toolName, query, decision, reason, hintChars) {
   try {
-    await mkdir13(dirname15(ctx.paths.gateLog), { recursive: true });
+    await mkdir14(dirname16(ctx.paths.gateLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
@@ -5467,7 +5767,7 @@ async function logDecision(ctx, toolName, query, decision, reason, hintChars) {
       reason: reason && reason.length > LOG_REASON_MAX_CHARS ? `${reason.slice(0, LOG_REASON_MAX_CHARS)}\u2026` : reason,
       ...hintChars === void 0 ? {} : { hint_chars: hintChars }
     };
-    await appendFile5(ctx.paths.gateLog, JSON.stringify(entry) + "\n", "utf8");
+    await appendFile6(ctx.paths.gateLog, JSON.stringify(entry) + "\n", "utf8");
   } catch {
   }
 }
@@ -5590,16 +5890,16 @@ async function handleGate(req, ctx) {
 }
 
 // src/server/routes/log.ts
-import { appendFile as appendFile6, mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname16 } from "path";
+import { appendFile as appendFile7, mkdir as mkdir15 } from "fs/promises";
+import { dirname as dirname17 } 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 mkdir14(dirname16(ctx.paths.tokenLog), { recursive: true });
-  await appendFile6(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
+  await mkdir15(dirname17(ctx.paths.tokenLog), { recursive: true });
+  await appendFile7(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
   return { ok: true, written_at };
 }
 
@@ -5793,6 +6093,10 @@ function buildApp(ctx, port) {
     const body = await c.req.json().catch(() => ({}));
     return c.json(await handleGate(body, ctx));
   });
+  app.post("/route", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    return c.json(await handleRoute(body, ctx));
+  });
   app.get("/activity", async (c) => {
     const sinceParam = c.req.query("since");
     const sinceMs = sinceParam ? Number(sinceParam) : void 0;
@@ -6099,7 +6403,7 @@ import { readFile as readFile20, readdir as readdir4, rm, rmdir, stat as stat5,
 import { basename as basename6, join as join13, resolve as resolve4 } from "path";
 
 // src/cli/self-update.ts
-import { mkdir as mkdir15, readFile as readFile19, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir16, readFile as readFile19, writeFile as writeFile12 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join12 } from "path";
 import { createInterface } from "readline/promises";
@@ -6166,7 +6470,7 @@ async function readLastSeen() {
 }
 async function writeLastSeen(version) {
   try {
-    await mkdir15(SYNTHRA_DIR, { recursive: true });
+    await mkdir16(SYNTHRA_DIR, { recursive: true });
     const data = { version, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
     await writeFile12(LAST_SEEN_PATH, JSON.stringify(data, null, 2), "utf8");
   } catch {
@@ -6336,7 +6640,8 @@ var HOOK_BASENAMES = [
   "synthra-prime",
   "synthra-pre-tool-use",
   "synthra-pre-compact",
-  "synthra-stop"
+  "synthra-stop",
+  "synthra-route"
 ];
 async function exists3(path) {
   try {