@jefuriiij/synthra 0.15.0 → 0.16.1

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;
@@ -2989,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" };
@@ -3177,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) {
@@ -3205,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}`);
   }
@@ -3361,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("::")) {
@@ -3698,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) {
@@ -3919,8 +4325,8 @@ async function contextRecall(args, ctx) {
 }
 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"
@@ -4132,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;
@@ -4146,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");
 }
 
@@ -4194,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) {
@@ -4358,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,
@@ -4368,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 {
   }
 }
@@ -4438,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,
@@ -4447,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 {
   }
 }
@@ -4570,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 };
 }
 
@@ -4773,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;