@jefuriiij/synthra 0.14.1 → 0.16.0

package/dist/server/index.js

@@ -1560,16 +1560,16 @@ async function readParseCache(path) {
     return emptyParseCache();
   }
 }
-async function writeParseCache(path, cache) {
+async function writeParseCache(path, cache2) {
   try {
     await mkdir2(dirname3(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(cache)}
+    await writeFile(path, `${JSON.stringify(cache2)}
 `, "utf8");
   } catch {
   }
 }
 async function incrementalParse(parsable, prev, opts = {}) {
-  const cache = emptyParseCache();
+  const cache2 = emptyParseCache();
   const parsed = [];
   let reused = 0;
   let reparsed = 0;
@@ -1591,20 +1591,20 @@ async function incrementalParse(parsable, prev, opts = {}) {
         imports: cached.imports,
         calls: cached.calls
       });
-      cache.files[f.relPath] = cached;
+      cache2.files[f.relPath] = cached;
       reused += 1;
       continue;
     }
     try {
       const p = await parseSource(f, source);
       parsed.push(p);
-      cache.files[f.relPath] = { hash, symbols: p.symbols, imports: p.imports, calls: p.calls };
+      cache2.files[f.relPath] = { hash, symbols: p.symbols, imports: p.imports, calls: p.calls };
       reparsed += 1;
     } catch {
       parseErrors += 1;
     }
   }
-  return { parsed, cache, reused, reparsed, parseErrors };
+  return { parsed, cache: cache2, reused, reparsed, parseErrors };
 }
 
 // src/scanner/walker.ts
@@ -1796,6 +1796,7 @@ function resolvePaths(projectRoot) {
     tokenLog: join5(graphDir, "token_log.jsonl"),
     gateLog: join5(graphDir, "gate_log.jsonl"),
     bashLog: join5(graphDir, "bash_log.jsonl"),
+    routeLog: join5(graphDir, "route_log.jsonl"),
     toolLog: join5(graphDir, "tool_log.jsonl"),
     accessLog: join5(graphDir, "access_log.jsonl"),
     learnStore: join5(graphDir, "learn_store.json"),
@@ -1821,7 +1822,7 @@ import { basename as basename2 } from "path";
 // src/hooks/claude-md.ts
 import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
 import { basename, dirname as dirname5 } 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;
@@ -1840,7 +1841,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.",
     "",
@@ -1858,6 +1859,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",
     "",
@@ -2126,7 +2132,7 @@ async function scanProject(projectRootRaw, opts = {}) {
   if (verbose) log.info(`  walked ${walked.length} files`);
   const parsable = walked.filter((f) => PARSABLE_EXTS.has(f.ext));
   const prevCache = await readParseCache(paths.parseCache);
-  const { parsed, cache, reused, reparsed, parseErrors } = await incrementalParse(
+  const { parsed, cache: cache2, reused, reparsed, parseErrors } = await incrementalParse(
     parsable,
     prevCache,
     { full: opts.full }
@@ -2140,7 +2146,7 @@ async function scanProject(projectRootRaw, opts = {}) {
   const symbolIndex = buildSymbolIndex(graph);
   await writeGraph(paths.infoGraph, graph);
   await writeSymbolIndex(paths.symbolIndex, symbolIndex);
-  await writeParseCache(paths.parseCache, cache);
+  await writeParseCache(paths.parseCache, cache2);
   if (verbose) {
     log.info(
       `  wrote ${paths.infoGraph} \u2014 ${graph.symbol_count} symbols, ${graph.edge_count} edges`
@@ -2360,6 +2366,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"),
@@ -2368,8 +2378,8 @@ function loadConfig() {
 }
 
 // src/server/mcp.ts
-import { appendFile as appendFile3, mkdir as mkdir8 } from "fs/promises";
-import { dirname as dirname9 } from "path";
+import { appendFile as appendFile4, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname11 } from "path";
 
 // src/graph/rank.ts
 var KW_BASE_WEIGHT = 2;
@@ -2769,7 +2779,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);
@@ -2988,6 +2999,378 @@ async function pack(files, opts) {
   };
 }
 
+// src/dashboard/arsenal.ts
+import { readFile as readFile13, readdir as readdir2 } from "fs/promises";
+import { homedir } from "os";
+import { basename as basename3, dirname as dirname9, join as join7 } from "path";
+var DESC_MAX = 300;
+var TOOLS_MAX = 200;
+async function readText(path) {
+  try {
+    return await readFile13(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function readJson2(path) {
+  const text = await readText(path);
+  if (text === null) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function listNames(dir) {
+  try {
+    return await readdir2(dir);
+  } catch {
+    return [];
+  }
+}
+function clip(s, max) {
+  const t = s.trim();
+  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
+}
+function parseFrontmatter(md) {
+  const m = md.match(/^?\s*---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return {};
+  const lines = (m[1] ?? "").split(/\r?\n/);
+  const out = {};
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const kv = line.match(/^([A-Za-z][\w-]*):\s?(.*)$/);
+    if (!kv) continue;
+    const key = kv[1] ?? "";
+    if (!key) continue;
+    let val = kv[2] ?? "";
+    if (val.startsWith('"') && !/[^\\]"\s*$/.test(val.slice(1)) || val === '"') {
+      const buf = [val];
+      while (i + 1 < lines.length && !/"\s*$/.test(buf[buf.length - 1] ?? "")) {
+        i += 1;
+        buf.push(lines[i] ?? "");
+      }
+      val = buf.join(" ");
+    }
+    val = val.trim().replace(/^["']|["']$/g, "").trim();
+    out[key] = val;
+  }
+  return out;
+}
+function skillItem(fm, fallbackName, scope, source) {
+  const meta = {};
+  if (fm["argument-hint"]) meta.argument_hint = fm["argument-hint"];
+  if (fm["user-invocable"]) meta.user_invocable = fm["user-invocable"];
+  return {
+    name: fm.name || fallbackName,
+    description: clip(fm.description || "", DESC_MAX),
+    scope,
+    ...source ? { source } : {},
+    ...Object.keys(meta).length ? { meta } : {}
+  };
+}
+function agentItem(fm, fallbackName, scope, source) {
+  const meta = {};
+  if (fm.tools) meta.tools = clip(fm.tools, TOOLS_MAX);
+  if (fm.model) meta.model = fm.model;
+  return {
+    name: fm.name || fallbackName,
+    description: clip(fm.description || "", DESC_MAX),
+    scope,
+    ...source ? { source } : {},
+    ...Object.keys(meta).length ? { meta } : {}
+  };
+}
+async function scanSkillsDir(dir, scope, source, out) {
+  for (const name of await listNames(dir)) {
+    const md = await readText(join7(dir, name, "SKILL.md"));
+    if (md === null) continue;
+    out.push(skillItem(parseFrontmatter(md), name, scope, source));
+  }
+}
+async function scanAgentsDir(dir, scope, source, out) {
+  for (const file of await listNames(dir)) {
+    if (!file.endsWith(".md")) continue;
+    const md = await readText(join7(dir, file));
+    if (md === null) continue;
+    out.push(agentItem(parseFrontmatter(md), basename3(file, ".md"), scope, source));
+  }
+}
+function mcpItemsFrom(json, scope, source) {
+  if (!json || typeof json !== "object") return [];
+  const record = json;
+  const servers = record.mcpServers && typeof record.mcpServers === "object" ? record.mcpServers : record;
+  const items = [];
+  for (const [name, raw] of Object.entries(servers)) {
+    if (!raw || typeof raw !== "object") continue;
+    const cfg = raw;
+    const type = typeof cfg.type === "string" ? cfg.type : cfg.command ? "stdio" : "http";
+    const url = typeof cfg.url === "string" ? cfg.url.split("?")[0] : typeof cfg.command === "string" ? cfg.command : "";
+    const meta = { type };
+    if (url) meta.url = url;
+    items.push({ name, description: "", scope, ...source ? { source } : {}, meta });
+  }
+  return items;
+}
+var SCOPE_ORDER = { project: 0, personal: 1, plugin: 2 };
+function sortItems(items) {
+  return items.sort((a, b) => {
+    if (a.scope !== b.scope) return SCOPE_ORDER[a.scope] - SCOPE_ORDER[b.scope];
+    const sa = a.source ?? "";
+    const sb = b.source ?? "";
+    if (sa !== sb) return sa < sb ? -1 : 1;
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+  });
+}
+var cache = null;
+var CACHE_TTL_MS = 15e3;
+async function computeArsenal(projectRoot, homeDir = homedir()) {
+  const key = `${projectRoot}\0${homeDir}`;
+  const now = Date.now();
+  if (cache && cache.key === key && now - cache.at < CACHE_TTL_MS) return cache.data;
+  const homeClaude = join7(homeDir, ".claude");
+  const projClaude = join7(projectRoot, ".claude");
+  const skills = [];
+  const agents = [];
+  const mcp = [];
+  await scanSkillsDir(join7(projClaude, "skills"), "project", void 0, skills);
+  await scanSkillsDir(join7(homeClaude, "skills"), "personal", void 0, skills);
+  await scanAgentsDir(join7(projClaude, "agents"), "project", void 0, agents);
+  await scanAgentsDir(join7(homeClaude, "agents"), "personal", void 0, agents);
+  mcp.push(...mcpItemsFrom(await readJson2(join7(projectRoot, ".mcp.json")), "project", void 0));
+  mcp.push(
+    ...mcpItemsFrom(
+      (await readJson2(join7(homeDir, ".claude.json")))?.mcpServers,
+      "personal",
+      void 0
+    )
+  );
+  const installedRaw = await readJson2(
+    join7(homeClaude, "plugins", "installed_plugins.json")
+  );
+  const pluginsMap = installedRaw?.plugins ?? installedRaw ?? {};
+  const settings = await readJson2(
+    join7(homeClaude, "settings.json")
+  );
+  const enabledMap = settings?.enabledPlugins ?? {};
+  let pluginCount = 0;
+  for (const [pluginKey, entries] of Object.entries(pluginsMap)) {
+    const entry = Array.isArray(entries) ? entries[0] : void 0;
+    if (!entry?.installPath) continue;
+    pluginCount += 1;
+    const pluginName = pluginKey.split("@")[0];
+    const enabled = enabledMap[pluginKey] !== false;
+    const root = entry.installPath;
+    const manifest = await readJson2(
+      join7(root, ".claude-plugin", "plugin.json")
+    );
+    const agentFiles = /* @__PURE__ */ new Set();
+    for (const f of await listNames(join7(root, "agents"))) {
+      if (f.endsWith(".md")) agentFiles.add(join7(root, "agents", f));
+    }
+    for (const rel of manifest?.agents ?? []) agentFiles.add(join7(root, rel));
+    const pAgents = [];
+    for (const file of agentFiles) {
+      const md = await readText(file);
+      if (md !== null)
+        pAgents.push(agentItem(parseFrontmatter(md), basename3(file, ".md"), "plugin", pluginName));
+    }
+    const skillMds = /* @__PURE__ */ new Set();
+    for (const name of await listNames(join7(root, "skills"))) {
+      skillMds.add(join7(root, "skills", name, "SKILL.md"));
+    }
+    for (const rel of manifest?.skills ?? []) {
+      skillMds.add(rel.endsWith(".md") ? join7(root, rel) : join7(root, rel, "SKILL.md"));
+    }
+    const pSkills = [];
+    for (const md of skillMds) {
+      const text = await readText(md);
+      if (text !== null)
+        pSkills.push(
+          skillItem(parseFrontmatter(text), basename3(dirname9(md)), "plugin", pluginName)
+        );
+    }
+    const pMcp = mcpItemsFrom(await readJson2(join7(root, ".mcp.json")), "plugin", pluginName);
+    for (const it of [...pSkills, ...pAgents, ...pMcp]) it.enabled = enabled;
+    skills.push(...pSkills);
+    agents.push(...pAgents);
+    mcp.push(...pMcp);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const dedupedSkills = skills.filter((s) => {
+    const k = `${s.scope}:${s.source ?? ""}:${s.name}`;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+  const data = {
+    skills: sortItems(dedupedSkills),
+    agents: sortItems(agents),
+    mcp: sortItems(mcp),
+    counts: {
+      skills: dedupedSkills.length,
+      agents: agents.length,
+      mcp: mcp.length,
+      plugins: pluginCount
+    },
+    scanned_at: new Date(now).toISOString()
+  };
+  cache = { key, at: now, data };
+  return data;
+}
+
+// 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 mkdir8 } from "fs/promises";
+import { dirname as dirname10 } 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 mkdir8(dirname10(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" };
@@ -3071,7 +3454,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"]
@@ -3176,6 +3559,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) {
@@ -3204,6 +3598,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}`);
   }
@@ -3360,6 +3756,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("::")) {
@@ -3613,9 +4020,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);
@@ -3678,10 +4104,10 @@ function buildDepsFooter(symbol, graph, maxChars = loadConfig().readDepsMaxChars
     let cUsed = used + sep3 + head.length;
     for (const c of callers.slice(0, DEPS_MAX_CALLERS)) {
       const part = `${c.name} \u2192 ${c.file}`;
-      const join7 = shown.length > 0 ? 3 : 0;
-      if (cUsed + join7 + part.length > maxChars) break;
+      const join8 = shown.length > 0 ? 3 : 0;
+      if (cUsed + join8 + part.length > maxChars) break;
       shown.push(part);
-      cUsed += join7 + part.length;
+      cUsed += join8 + part.length;
     }
     if (lines.length > 0) lines.push("");
     if (shown.length > 0) {
@@ -3708,6 +4134,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");
@@ -3726,10 +4189,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(
@@ -3759,7 +4227,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();
@@ -3794,16 +4262,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;
@@ -3838,15 +4316,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 mkdir8(dirname9(ctx.paths.toolLog), { recursive: true });
-    await appendFile3(
+    await mkdir9(dirname11(ctx.paths.toolLog), { recursive: true });
+    await appendFile4(
       ctx.paths.toolLog,
       JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool }) + "\n",
       "utf8"
@@ -4058,12 +4538,12 @@ async function getChangedLineRanges(projectRoot, sinceRef) {
 }
 
 // src/memory/session.ts
-import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { mkdir as mkdir10, readFile as readFile14, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname12 } from "path";
 var SESSION_SCHEMA_VERSION = 2;
 async function readSession(path) {
   try {
-    const raw = await readFile13(path, "utf8");
+    const raw = await readFile14(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== SESSION_SCHEMA_VERSION) return null;
     return parsed;
@@ -4072,7 +4552,7 @@ async function readSession(path) {
   }
 }
 async function writeSession(path, state) {
-  await mkdir9(dirname10(path), { recursive: true });
+  await mkdir10(dirname12(path), { recursive: true });
   await writeFile8(path, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 
@@ -4120,12 +4600,12 @@ async function handleContextUpdate(req, ctx) {
 }
 
 // src/server/routes/gate.ts
-import { appendFile as appendFile5, mkdir as mkdir11 } from "fs/promises";
-import { dirname as dirname12 } from "path";
+import { appendFile as appendFile6, mkdir as mkdir12 } from "fs/promises";
+import { dirname as dirname14 } from "path";
 
 // src/server/routes/bash-observe.ts
-import { appendFile as appendFile4, mkdir as mkdir10 } from "fs/promises";
-import { dirname as dirname11 } from "path";
+import { appendFile as appendFile5, mkdir as mkdir11 } from "fs/promises";
+import { dirname as dirname13 } from "path";
 
 // src/server/routes/query-heuristics.ts
 function looksLikeNonSymbolQuery(pattern) {
@@ -4284,7 +4764,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 mkdir10(dirname11(ctx.paths.bashLog), { recursive: true });
+    await mkdir11(dirname13(ctx.paths.bashLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       kind: exp.kind,
@@ -4294,7 +4774,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 {
   }
 }
@@ -4364,7 +4844,7 @@ function recentlyTouchedMatchesQuery(recentPaths, queryTokens, graph) {
 var LOG_REASON_MAX_CHARS = 240;
 async function logDecision(ctx, toolName, query, decision, reason, hintChars) {
   try {
-    await mkdir11(dirname12(ctx.paths.gateLog), { recursive: true });
+    await mkdir12(dirname14(ctx.paths.gateLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
@@ -4373,7 +4853,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 {
   }
 }
@@ -4496,16 +4976,16 @@ async function handleGate(req, ctx) {
 }
 
 // src/server/routes/log.ts
-import { appendFile as appendFile6, mkdir as mkdir12 } from "fs/promises";
-import { dirname as dirname13 } from "path";
+import { appendFile as appendFile7, mkdir as mkdir13 } from "fs/promises";
+import { dirname as dirname15 } 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 mkdir12(dirname13(ctx.paths.tokenLog), { recursive: true });
-  await appendFile6(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
+  await mkdir13(dirname15(ctx.paths.tokenLog), { recursive: true });
+  await appendFile7(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
   return { ok: true, written_at };
 }
 
@@ -4699,6 +5179,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;