@polycode-projects/seonix 0.7.3 → 0.9.0

package/src/server.mjs

@@ -12,7 +12,7 @@
 //
 // seonix_ask (PLAN_MECHANICAL_CHAT.md, hot tool): a mechanical, zero-model-call NL query
 // over the graph — collapses the search+describe+traversal composition loop an agent would
-// otherwise hand-compose into one deterministic round-trip. See ask.mjs.
+// otherwise hand-compose into one deterministic round-trip (now tmct's ask engine).
 
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -51,7 +51,7 @@ import {
   renderMethodHistory,
   renderClassHistory,
 } from "./codegraph.mjs";
-import { ask } from "./ask.mjs";
+import { makeSeonixProvider } from "./tmct-provider.mjs";
 
 const SNIPPET_MAX_LINES = 200;
 
@@ -97,6 +97,7 @@ export const TOOLS = [
       required: ["query"],
       properties: {
         query: { type: "string", description: "A free-text question, e.g. \"which functions explicitly couple to logging\"." },
+        strict: { type: "boolean", description: "Fail fast on an ambiguous query (error naming the candidates) instead of returning multiple interpretations, so you can re-ask tighter. Default false." },
       },
     },
   },
@@ -260,7 +261,41 @@ export async function buildContextBundle(args, { config, source = defaultSource,
   return { text: out.join("\n"), tier, topup };
 }
 
+// C3 (copilot-UX): per-tool accepted argument keys, so a typo'd/unknown key gets a clear error
+// instead of the silent "X is required" the estate session hit. Deliberately generous (a superset of
+// each tool's read keys) so a valid call is never rejected; unlisted tools skip the check.
+const KNOWN_ARGS = {
+  seonix_context: ["symbol", "module", "depth", "min", "untuned", "max"],
+  seonix_context_more: ["symbol"],
+  seonix_describe: ["symbol"],
+  seonix_snippet: ["symbol"],
+  seonix_signature: ["symbol"],
+  seonix_impact: ["module", "depth"],
+  seonix_search: ["query", "kind", "decorator", "name", "page", "limit"],
+  seonix_members: ["class"],
+  seonix_subclasses: ["class"],
+  seonix_architecture: ["package"],
+  seonix_exports: ["module"],
+  seonix_untested: [],
+  seonix_ask: ["query", "strict"],
+  seonix_tests_for: ["symbol"], seonix_history: ["symbol"], seonix_callers: ["symbol"],
+  seonix_callees: ["symbol"], seonix_cochanges: ["symbol"], seonix_calls: ["symbol"],
+  seonix_file_history: ["symbol"], seonix_method_history: ["symbol"], seonix_class_history: ["symbol"],
+};
+// CLI/routing keys the cli.mjs entry always injects into `args` but no tool reads — never flagged.
+const BENIGN_ARGS = new Set(["repo_path", "repo_paths", "out_root", "multi_root", "modules", "config", "ignores", "sync", "history_depth"]);
+
 export async function dispatchTool(name, args, { config, source = defaultSource } = {}) {
+  const allowed = KNOWN_ARGS[name];
+  if (allowed && args && typeof args === "object" && !Array.isArray(args)) {
+    const unknown = Object.keys(args).filter((k) => !allowed.includes(k) && !BENIGN_ARGS.has(k));
+    if (unknown.length) {
+      throw new ToolError(
+        `unknown argument(s) for ${name}: ${unknown.join(", ")}` +
+          (allowed.length ? `. Valid: ${allowed.join(", ")}.` : " (this tool takes no arguments)."),
+      );
+    }
+  }
   if (name === "seonix_context") {
     return (await buildContextBundle(args, { config, source })).text;
   }
@@ -319,19 +354,28 @@ export async function dispatchTool(name, args, { config, source = defaultSource
   if (name === "seonix_impact") {
     const module = String(args?.module || "").trim();
     if (!module) throw new ToolError("module is required");
+    // C1 (copilot-UX): optional `depth` bounds the reverse closure. Absent → renderImpact's default
+    // (full closure, maxDepth 8) → byte-unchanged. `depth:1` = direct dependents/importers only —
+    // the "who imports this, one hop" the copilot estate session asked for.
+    const depth = Number.isInteger(args?.depth) && args.depth > 0 ? args.depth : undefined;
     const graph = await loadGraph(config, source);
     const { match } = resolveOrThrow(graph, module, "module");
-    return renderImpact(graph, match);
+    return renderImpact(graph, match, depth ? { maxDepth: depth } : undefined);
   }
   if (name === "seonix_search") {
     const query = String(args?.query || "").trim();
     const kind = String(args?.kind || "").trim();
     if (!query && !kind) throw new ToolError("query is required");
     const graph = await loadGraph(config, source);
+    // C3 (copilot-UX): opt-in paging for large result sets. Absent → today's "top N" output.
+    const page = Number.isInteger(args?.page) && args.page > 0 ? args.page : 0;
+    const limit = Number.isInteger(args?.limit) && args.limit > 0 ? args.limit : undefined;
     return renderSearch(graph, query, {
       kind,
       decorator: String(args?.decorator || "").trim(),
       name: String(args?.name || "").trim(),
+      ...(page ? { page } : {}),
+      ...(limit ? { limit } : {}),
     });
   }
   if (name === "seonix_members") {
@@ -367,11 +411,21 @@ export async function dispatchTool(name, args, { config, source = defaultSource
     const query = String(args?.query || "").trim();
     if (!query) throw new ToolError("query is required");
     const graph = await loadGraph(config, source);
-    const { content, seonix_ask } = ask(graph, query);
-    // Every dispatchTool caller (this MCP handler, the CLI fallback) expects a plain string —
-    // append the structured envelope as a delimited, machine-parseable block rather than
-    // changing that shared contract for one tool. PLAN_MECHANICAL_CHAT.md §6.2.
-    return `${content}\n\n---seonix_ask---\n${JSON.stringify(seonix_ask, null, 2)}`;
+    // The NL engine is tmct's now (PLAN_CHAT_EXTRACTION.md, the inversion): resolve through tmct's
+    // Repository Interface over seonix's graph. The `---seonix_ask---` delimited envelope is preserved
+    // so every dispatchTool caller (this MCP handler, the CLI fallback) is unchanged.
+    const { content, tmct_ask } = makeSeonixProvider(graph, { sourceAccess: false }).ask(query).value;
+    // C2 (copilot-UX): `strict:true` fails fast on an ambiguous query — return an error naming the
+    // candidate interpretations so the agent re-asks tighter, instead of paging a multi-interpretation
+    // body. Default (strict absent/false) → today's envelope, byte-unchanged.
+    if (args?.strict === true && tmct_ask?.ambiguous === true) {
+      const cands = (tmct_ask.matches || []).map((m) => `${m.label}${m.module ? ` (${m.module})` : ""}`).join(", ");
+      throw new ToolError(
+        `ambiguous query "${query}" — ${(tmct_ask.matches || []).length} candidate interpretation(s)` +
+          `${cands ? `: ${cands}` : ""}. Re-ask with a more specific query.`,
+      );
+    }
+    return `${content}\n\n---seonix_ask---\n${JSON.stringify(tmct_ask, null, 2)}`;
   }
   if (
     name === "seonix_tests_for" || name === "seonix_history" || name === "seonix_callers" ||

package/src/sessions.mjs

@@ -1,14 +1,14 @@
 // sessions.mjs — chat sessions as first-class temporal graph data, like commits.
 //
 // A `seonix chat` session leaves two artifacts under the target repo:
-//   .seonix/session-<uuidv7>.log            — the human-readable transcript (chat.mjs)
+//   .seonix/session-<uuidv7>.log            — the human-readable transcript (the chat shim)
 //   .seonix/sessions/session-<uuidv7>.jsonl — the STRUCTURED sidecar this module owns:
 //     {"type":"session", id, started, repo, seonixVersion}        (header line)
 //     {"type":"turn", ts, query, resolvedIds, answeredIds, miss}  (one per turn, flushed)
 //     {"type":"end", ts}                                          (clean close marker)
 //
 // From the sidecar the session enters the typed graph twice:
-//   - READ TIME (chat.mjs, per turn): appendSessionToGraph() upserts one `Session`
+//   - READ TIME (the chat shim, per turn): appendSessionToGraph() upserts one `Session`
 //     individual (`session:<uuidv7>`) + `mgx:asksAbout` edges into graph.json —
 //     atomically (temp + rename), re-reading the file first so a re-index that
 //     happened mid-session is tolerated: edges whose targets vanished are dropped,
@@ -141,7 +141,7 @@ export function upsertSession(entities, record) {
   return { kept: targets.length, dropped };
 }
 
-/** Read-time append (chat.mjs, once per turn): re-read graph.json FRESH (a re-index
+/** Read-time append (the chat shim, once per turn): re-read graph.json FRESH (a re-index
  *  may have replaced it mid-session), upsert, write back atomically. Throws on a
  *  missing/invalid artifact — the caller treats the append as best-effort. */
 export async function appendSessionToGraph(graphFile, record) {

package/src/source.mjs

@@ -19,12 +19,25 @@ export function clearCache() {
  *  source JSON can't be stat'd. node:sqlite is imported LAZILY here, so a gate-off load
  *  never touches sqlite (no ExperimentalWarning, no store.mjs sqlite import). */
 async function fetchFromStore(config) {
+  const { readPayload, storeFileFor } = await import("./store.mjs");
+  const dbPath = config.storeFile || storeFileFor(config.graphFile);
   let expectStat;
   try { expectStat = await stat(config.graphFile); }
-  catch { return null; } // no source JSON to verify against → let the JSON path emit its own error
+  catch {
+    // graph.json is gone. If a built store IS on disk, the freshness check has nothing to verify
+    // against and the JSON path below would ENOENT with a generic "no graph artifact" message —
+    // confusing when a usable graph.db sits right there. Give the real diagnosis instead. (A1)
+    let hasStore = false;
+    try { await stat(dbPath); hasStore = true; } catch { /* no store either */ }
+    if (hasStore)
+      throw new ToolError(
+        `graph.db present but graph.json is gone (${config.graphFile}) — the store's freshness ` +
+          `check needs graph.json, so re-index this repo: ` +
+          `\`seonix cli index_repository '{"repo_path":"<abs>"}'\`.`,
+      );
+    return null; // no store either → let the JSON path emit its own "run index_repository" error
+  }
   try {
-    const { readPayload, storeFileFor } = await import("./store.mjs");
-    const dbPath = config.storeFile || storeFileFor(config.graphFile);
     return await readPayload(dbPath, { expectStat });
   } catch (e) {
     process.stderr.write(`seonix: sqlite store unavailable (${e?.name || e?.code || e?.message || e}); using graph.json\n`);

package/src/summary.mjs

@@ -15,6 +15,7 @@
 
 import { writeFile, rename, mkdir } from "node:fs/promises";
 import { join } from "node:path";
+import { hubDemote } from "./paths.mjs";
 
 // V8's hard maximum string length (chars). A graph.json larger than this can't be
 // JSON.parse'd back into one string — the failure mode the wh estate hit at 80%.
@@ -69,10 +70,13 @@ export function hubModules(entities, { prefix = "", top = 5 } = {}) {
   const rows = [];
   for (const [id, deg] of degree) {
     if (!id.startsWith(want)) continue;
-    rows.push({ id, label: labelById.get(id) ?? id.slice(4), degree: deg });
+    const label = labelById.get(id) ?? id.slice(4);
+    // Sort weight down-weights test/non-prod hubs (0.8.1) so a shared test harness can't dominate
+    // SUMMARY.md's hub list (the wh estate symptom); the reported `degree` stays the raw value.
+    rows.push({ id, label, degree: deg, weight: deg * hubDemote(label) });
   }
-  rows.sort((a, b) => (b.degree - a.degree) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-  return rows.slice(0, top);
+  rows.sort((a, b) => (b.weight - a.weight) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  return rows.slice(0, top).map(({ id, label, degree }) => ({ id, label, degree }));
 }
 
 /**

package/src/tmct-provider.mjs

@@ -0,0 +1,37 @@
+// tmct-provider.mjs — seonix as a tmct Repository-Interface provider.
+//
+// The inversion (PLAN_CHAT_EXTRACTION.md; tmct's PLAN_REPOSITORY_INTERFACE.md):
+// tmct owns the natural-language interpreter, and seonix hands it graph truth
+// through tmct's typed Repository Interface. seonix's parseEntities() result is
+// byte-identical in shape to tmct's, so tmct's createGraphService consumes it
+// directly. The only seonix-specific step is expanding the interned v2 on-disk
+// graph — which parseEntities already does (via graph-format's expandGraphPayload),
+// and tmct cannot read raw.
+//
+// Graph-only by default: sourceAccess=false, so snippet/context honestly answer
+// miss(NO_SOURCE). A caller with a working tree passes sourceAccess (and, later,
+// a source layer) to serve real bodies.
+import { createGraphService } from "@polycode-projects/the-mechanical-code-talker/graph-service";
+import { parseEntities } from "./codegraph.mjs";
+import { fetchEntities } from "./source.mjs";
+
+/**
+ * Wrap an already-parsed seonix graph (a parseEntities() result) as a tmct
+ * Repository-Interface service object.
+ * @param {object} graph  a parseEntities() result ({ individuals, byId, relations, … })
+ * @param {{sourceAccess?: boolean}} [opts]
+ */
+export function makeSeonixProvider(graph, { sourceAccess = false } = {}) {
+  return createGraphService(graph, { sourceAccess });
+}
+
+/**
+ * Load a seonix graph from a config ({ graphFile } or a registered provider) and
+ * wrap it as a tmct service. parseEntities expands the interned v2 payload.
+ * @param {object} config  a seonix config ({ graphFile })
+ * @param {{sourceAccess?: boolean}} [opts]
+ */
+export async function loadSeonixProvider(config, { sourceAccess = false } = {}) {
+  const graph = parseEntities(await fetchEntities(config));
+  return makeSeonixProvider(graph, { sourceAccess });
+}

package/src/toml-config.mjs

@@ -123,6 +123,19 @@ export async function normalizeConfig(raw, { configDir } = {}) {
   const tel = src.telemetry || {};
   if (tel.enabled !== undefined) cfg.telemetry = { enabled: tel.enabled };
 
+  // [interfaces] — un-typed interface (route↔handler) indexing (PLAN_UNTYPED_INTERFACES.md).
+  // OFF by default; enabled emits gated `serves` edges + Route individuals. The matcher knobs
+  // (frameworks/verbs/combine_controller_prefix/prefix_strip/match_threshold) are tunable.
+  const ifc = src.interfaces || {};
+  const interfaces = {};
+  if (ifc.enabled !== undefined) interfaces.enabled = ifc.enabled;
+  if (ifc.frameworks !== undefined) interfaces.frameworks = ifc.frameworks;
+  if (ifc.verbs !== undefined) interfaces.verbs = ifc.verbs;
+  if (ifc.combine_controller_prefix !== undefined) interfaces.combineControllerPrefix = ifc.combine_controller_prefix;
+  if (ifc.prefix_strip !== undefined) interfaces.prefixStrip = ifc.prefix_strip;
+  if (ifc.match_threshold !== undefined) interfaces.matchThreshold = ifc.match_threshold;
+  if (Object.keys(interfaces).length) cfg.interfaces = interfaces;
+
   const unwired = [];
   for (const [a, b] of UNWIRED_KEYS) {
     if (src[a] && src[a][b] !== undefined) unwired.push(`${a}.${b}`);

package/src/uuid.mjs

@@ -1,5 +1,5 @@
 // uuid.mjs — RFC 9562 UUIDv7 (node:crypto ships v4 only). Lifted verbatim from
-// chat.mjs so the chat session id, the telemetry invocation id, and the bench
+// the chat session id, the telemetry invocation id, and the bench
 // per-run stamp all share ONE time-sortable implementation (no second copy, no dep).
 
 import { randomBytes } from "node:crypto";

package/src/viz.mjs

@@ -26,7 +26,8 @@ import { loadConfig } from "./config.mjs";
 import * as source from "./source.mjs";
 import { buildTemporalGraph, buildBrowserData, gitCommitOrder, gitCommitParents, renderBrowserHtml } from "./browser.mjs";
 import { extractTimeline, renderTimelineHtml } from "./timeline.mjs";
-import { winkBrowserBundle } from "./nlp-bundle.mjs";
+// The ask panel runs tmct's engine bundled for the browser (see askSource() below), adapter-less —
+// there is no wink lemma tier or ~4 MB browser model.
 
 // Portable single-file gate: above this serialized graph size, embedding the
 // full raw graph inline yields an unopenable multi-hundred-MB HTML, so the
@@ -189,17 +190,11 @@ export async function cytoscapeSource() {
  *  render logic. `export`/`import` lines stripped so the three files run as one
  *  plain <script> block; nothing here diverges from the node-tested source. */
 async function askSource() {
-  const [codegraph, vocab, ask] = await Promise.all(
-    ["codegraph.mjs", "ask-vocab.mjs", "ask.mjs"].map((f) => readFile(join(here, f), "utf8")),
-  );
-  // Non-greedy up to the closing `";` (not `$`-anchored): ask.mjs's own import spans
-  // multiple lines (a multi-name destructure), which a single-line `^...$` pattern
-  // silently leaves in place — and unlike a stray declaration, a surviving `import`
-  // is a hard SyntaxError in a classic (non-module) inlined <script>, not a quiet bug.
-  const strip = (src) => src
-    .replace(/^import\s[\s\S]*?from\s+"[^"]+";\s*$/gm, "")
-    .replace(/^export (?=(function|const|async function))/gm, "");
-  return [strip(codegraph), strip(vocab), strip(ask)].join("\n");
+  // The panel's mechanical NL engine is tmct's, prebuilt by scripts/build-ask-bundle.mjs into an
+  // IIFE (src/ask-browser.bundle.js) that registers globalThis.ask / parseEntities. We inline it
+  // verbatim into the viewer page (PLAN_CHAT_EXTRACTION.md, the tmct inversion). It runs adapter-less
+  // in the browser, so the old ~4 MB wink lemma bundle is gone. Regenerate: `npm run build:ask-bundle`.
+  return readFile(join(here, "ask-browser.bundle.js"), "utf8");
 }
 
 /** JSON safe to sit inside a <script> block (no </script> or comment-open breakouts). */
@@ -218,24 +213,12 @@ const inlineJson = (v) => JSON.stringify(v).replace(/</g, "\\u003c");
  * silently produce incomplete answers, which this project's honesty contract
  * doesn't allow (see the file-level comment's "ONE viewer, three data channels" —
  * this is a fourth, for the same one-viewer-many-modes reason).
- *
- * The OPTIONAL wink-nlp lemma tier (ask-nlp.mjs's browser twin, from nlp-bundle.mjs)
- * reaches the chat two ways: `nlpInline` inlines the ~4 MB bundle as its own <script>
- * so it registers `window.__seonixNlp` at page load (portable `viz --nlp`); `nlpPath`
- * points the page at a same-origin sibling asset the chat LAZY-loads on first ask
- * (the SITE build). Neither is present in the default local single-file — that viewer
- * stays lemma-off and fetches nothing, exactly as before, preserving its
- * no-external-fetch guarantee. ask() picks up whatever `window.__seonixNlp` is set,
- * or degrades to the adapter-less tiers when it's absent.
  */
-export function renderViewerHtml({ cytoscape, askEngine = "", embedData = null, dataPath = null, askData = null, askDataPath = null, nlpInline = null, nlpPath = null } = {}) {
+export function renderViewerHtml({ cytoscape, askEngine = "", embedData = null, dataPath = null, askData = null, askDataPath = null } = {}) {
   const embedded = embedData ? `<script type="application/json" id="seonix-data">${inlineJson(embedData)}</script>\n` : "";
   const askEmbedded = askData ? `<script type="application/json" id="seonix-ask-data">${inlineJson(askData)}</script>\n` : "";
-  const cfgObj = { ...(dataPath ? { data: dataPath } : {}), ...(askDataPath ? { ask: askDataPath } : {}), ...(nlpPath ? { nlp: nlpPath } : {}) };
+  const cfgObj = { ...(dataPath ? { data: dataPath } : {}), ...(askDataPath ? { ask: askDataPath } : {}) };
   const cfg = Object.keys(cfgObj).length ? `<script type="application/json" id="seonix-cfg">${inlineJson(cfgObj)}</script>\n` : "";
-  // Inline bundle: escape any literal </script inside the wink model data so the
-  // block can't be closed early (harmless inside JS strings, impossible outside them).
-  const nlpEmbedded = nlpInline ? `<script>${String(nlpInline).replace(/<\/script/gi, "<\\/script")}</script>\n` : "";
   return `<!doctype html><html><head><meta charset="utf-8"><title>seon code-map</title>
 <!-- generated by: seonix viz (see packages/seonix/src/viz.mjs) — one viewer, data loaded at runtime -->
 <style>
@@ -313,7 +296,7 @@ export function renderViewerHtml({ cytoscape, askEngine = "", embedData = null,
 </div>
 ${embedded}${askEmbedded}${cfg}<script>${cytoscape}</script>
 <script>${askEngine}</script>
-${nlpEmbedded}<script>
+<script>
 // Type palette (see the CVD note in viz.mjs) — viewer styling, identical for every repo.
 const COLORS={Module:'#3987e5',Class:'#c98500',Function:'#008300',Method:'#d55181',Attribute:'#9085e9',GlobalVariable:'#d95926',Commit:'#199e70'};
 const $=id=>document.getElementById(id);
@@ -356,29 +339,6 @@ function loadAskData(){
   })();
   return _askGraphPromise;
 }
-// The OPTIONAL wink-nlp lemma adapter (window.__seonixNlp — see nlp-bundle.mjs).
-// An inlined bundle registers it at page load; the site build ships it as a
-// same-origin sibling this injects LAZILY on the first ask (never at boot), so the
-// ~4 MB model is only paid for when the chat is actually used. With neither present
-// (the default local single-file) this resolves to undefined and the chat runs
-// adapter-less — ask() then falls back to its curated + fuzzy tiers, exactly as
-// before, and NOTHING is fetched, keeping the no-external-fetch guarantee intact.
-let _nlpPromise=null;
-function loadNlp(){
-  if(window.__seonixNlp) return Promise.resolve(window.__seonixNlp);
-  if(_nlpPromise) return _nlpPromise;
-  const cfgEl=document.getElementById('seonix-cfg');
-  const url=cfgEl?JSON.parse(cfgEl.textContent).nlp:null;
-  if(!url) return Promise.resolve(undefined);
-  _nlpPromise=new Promise(res=>{
-    const s=document.createElement('script');
-    s.src=url;
-    s.onload=()=>res(window.__seonixNlp);
-    s.onerror=()=>res(undefined); // a failed asset degrades to lemma-off, never a broken chat
-    document.head.appendChild(s);
-  });
-  return _nlpPromise;
-}
 function init(G){
   document.title='seon code-map — '+G.focusLabel;
   $('focuslabel').textContent=G.focusLabel;
@@ -621,10 +581,9 @@ function init(G){
       return;
     }
     out.textContent='thinking…';
-    // Load the graph and (if configured) the wink lemma adapter together, then run
-    // the mechanical ask. An undefined nlp makes ask() degrade to its adapter-less tiers.
-    Promise.all([loadAskData(),loadNlp()]).then(([askGraph,nlp])=>{
-      const {content,seonix_ask}=ask(askGraph,query,{contextId:selId,nlp});
+    // Lazy-load the graph, then run the mechanical ask over it.
+    loadAskData().then((askGraph)=>{
+      const {content,seonix_ask}=ask(askGraph,query,{contextId:selId});
       const total=(seonix_ask.matches||[]).length;
       const shown=total?highlightAsk(seonix_ask.matches.map(m=>m.id)):0;
       out.classList.toggle('miss',!!seonix_ask.miss);
@@ -714,12 +673,10 @@ function resolveFocus(graph, focusArg) {
  * code browser rides along at `/code-browser.html` (alias `/browser`) with a live
  * temporal payload — the local equivalent of the site's browser section.
  */
-export async function startVizServer({ values, cytoscape, askEngine = "", nlpBundle = null, log = () => {} }) {
+export async function startVizServer({ values, cytoscape, askEngine = "", log = () => {} }) {
   const port = Math.max(0, parseInt(values.port, 10) || 0);
   const repoUrl = values["repo-url"] || (await repoUrlFromGit(process.cwd()));
-  // With --nlp the local live view gets the same lemma tier as the site: the bundle
-  // is served in-process at /seonix-nlp.js and the viewer lazy-loads it on first ask.
-  const viewer = renderViewerHtml({ cytoscape, askEngine, nlpPath: nlpBundle ? "/seonix-nlp.js" : null });
+  const viewer = renderViewerHtml({ cytoscape, askEngine });
   const browserPage = await renderBrowserHtml({ cytoscape });
   // nav = the routes this server itself serves; injected into every payload/page
   const nav = { home: "/", graph: "/seonix-graph.html", browser: "/code-browser.html", timeline: "/timeline.html" };
@@ -820,9 +777,6 @@ export async function startVizServer({ values, cytoscape, askEngine = "", nlpBun
         res.writeHead(500, { "content-type": "application/json" });
         res.end(JSON.stringify({ error: String(err.message || err) }));
       }
-    } else if (path === "/seonix-nlp.js" && nlpBundle) {
-      res.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
-      res.end(nlpBundle);
     } else {
       res.writeHead(404, { "content-type": "text/plain" });
       res.end("not found");
@@ -861,11 +815,6 @@ export async function runVizCli(argv) {
       // truncation ("newest N of M commits"). See src/timeline.mjs.
       limit: { type: "string", default: "100" },
       scope: { type: "string", default: "product" },
-      // Include the OPTIONAL wink-nlp lemma tier in the chat (see nlp-bundle.mjs).
-      // Site mode (--data-out): written as a same-origin sibling the page lazy-loads.
-      // Portable/serve mode: inlined (single-file) / served in-process. Off by default,
-      // so the local single-file stays lean and lemma-off exactly as before.
-      nlp: { type: "boolean", default: false },
       // Portable branch only: embed the full graph inline even past the size gate
       // (INLINE_ASKDATA_MAX_BYTES). Off by default — over-threshold graphs write
       // sidecars instead of an unopenable multi-hundred-MB single file.
@@ -875,11 +824,8 @@ export async function runVizCli(argv) {
   });
   const cytoscape = await cytoscapeSource();
   const askEngine = await askSource();
-  // Build the wink lemma bundle once, only when --nlp asked for it (~4 MB; skip the
-  // work entirely otherwise). Wired below as a sibling asset (site) or inline (portable).
-  const nlpBundle = values.nlp ? await winkBrowserBundle() : null;
   if (values.serve) {
-    await startVizServer({ values, cytoscape, askEngine, nlpBundle, log: (s) => process.stderr.write(s) });
+    await startVizServer({ values, cytoscape, askEngine, log: (s) => process.stderr.write(s) });
     return; // keeps serving until Ctrl-C
   }
   const { config, graph, raw, graphBytes } = await loadGraph(values);
@@ -931,32 +877,22 @@ export async function runVizCli(argv) {
     const rel = relative(dirname(out), dataOut) || "seonix-graph-data.json";
     const askDataOut = resolve(dirname(out), "seonix-ask-data.json");
     const askRel = relative(dirname(out), askDataOut) || "seonix-ask-data.json";
-    // The wink lemma bundle rides the same sibling-asset convention as the data
-    // files — a same-origin ./seonix-nlp.js the page lazy-loads on first ask.
-    let nlpPath = null;
-    if (nlpBundle) {
-      const nlpOut = resolve(dirname(out), "seonix-nlp.js");
-      await writeFile(nlpOut, nlpBundle);
-      nlpPath = "./seonix-nlp.js";
-    }
     await Promise.all([writeFile(dataOut, JSON.stringify(data)), writeFile(askDataOut, JSON.stringify(raw))]);
     await writeFile(out, renderViewerHtml({
       cytoscape, askEngine,
       dataPath: rel === "seonix-graph-data.json" ? null : rel,
       askDataPath: askRel === "seonix-ask-data.json" ? null : askRel,
-      nlpPath,
     }));
-    return { dataOut, askDataOut, nlpPath };
+    return { dataOut, askDataOut };
   };
   if (values["data-out"]) {
     // site mode: viewer page + sibling data file (data updates don't touch the page).
     // The chat panel's full-graph channel rides the same sibling-file convention,
     // written next to the display data file rather than embedded in the page.
-    const { dataOut, askDataOut, nlpPath } = await writeSplitViewer(resolve(values["data-out"]));
+    const { dataOut, askDataOut } = await writeSplitViewer(resolve(values["data-out"]));
     process.stderr.write(
       `seonix viz: ${subgraph.nodes.length} nodes, ${subgraph.edges.length} edges around "${focus.label}" ` +
-        `(depth ${values.depth})${subgraph.truncated ? " [capped]" : ""} → ${out} + ${dataOut} + ${askDataOut}` +
-        `${nlpPath ? ` + ${resolve(dirname(out), "seonix-nlp.js")} (wink lemma tier)` : ""}\n`,
+        `(depth ${values.depth})${subgraph.truncated ? " [capped]" : ""} → ${out} + ${dataOut} + ${askDataOut}\n`,
     );
   } else if (graphBytes > inlineAskDataMaxBytes() && !values["force-inline"]) {
     // portable mode, but the graph is too big to embed: an estate-scale full-graph
@@ -975,9 +911,8 @@ export async function runVizCli(argv) {
         `(depth ${values.depth})${subgraph.truncated ? " [capped]" : ""} → ${out} + ${dataOut} + ${askDataOut}\n`,
     );
   } else {
-    // portable mode: one self-contained file, both channels embedded (+ inline wink
-    // bundle when --nlp; otherwise lemma-off, no external fetch, exactly as before)
-    await writeFile(out, renderViewerHtml({ cytoscape, askEngine, embedData: data, askData: raw, nlpInline: nlpBundle }));
+    // portable mode: one self-contained file, both data channels embedded, no external fetch.
+    await writeFile(out, renderViewerHtml({ cytoscape, askEngine, embedData: data, askData: raw }));
     process.stderr.write(
       `seonix viz: ${subgraph.nodes.length} nodes, ${subgraph.edges.length} edges around "${focus.label}" ` +
         `(depth ${values.depth})${subgraph.truncated ? " [capped]" : ""} → ${out}\n`,

package/src/ask-nlp.mjs

@@ -1,73 +0,0 @@
-// ask-nlp.mjs — the OPTIONAL wink-nlp adapter behind ask.mjs's lemma/POS tier.
-//
-// BOUNDARY (hard, do not move): this file is Node-only and is NEVER inlined into
-// the viewer bundle. viz.mjs's askSource() inlines codegraph.mjs + ask-vocab.mjs +
-// ask.mjs ONLY and strips their import lines, so the portable single-file HTML has
-// no wink, no model, and no `nlpAdapter` binding at all — ask.mjs reaches this
-// module exclusively through a `typeof nlpAdapter === "function"` guard and
-// degrades to adapter-less parsing (lemma/POS tiers off; the curated tables and
-// the bounded edit-distance tier still work, browser and Node alike). Keeping the
-// ~1MB CJS model out of the page is the point of the split.
-//
-// wink-nlp and wink-eng-lite-web-model are CJS — loaded via createRequire, the
-// same Node-module-resolution approach viz.mjs uses to locate cytoscape (resolve
-// through the module system, never a guessed path). The require happens lazily on
-// first use and failure is cached as null: a checkout without the optional deps
-// installed answers exactly like the browser bundle, it never throws.
-
-import { createRequire } from "node:module";
-
-let cached; // undefined = not tried yet; null = unavailable (tried once, honestly off)
-
-/** Lazily build the {lemma, posTags} adapter, or null when wink isn't loadable.
- *  Deterministic: wink-nlp's tagger/lemmatiser is a fixed model with no sampling,
- *  so the same input always yields the same tags/lemmas across processes. */
-export function nlpAdapter() {
-  if (cached !== undefined) return cached;
-  try {
-    const require = createRequire(import.meta.url);
-    const winkNLP = require("wink-nlp");
-    const model = require("wink-eng-lite-web-model");
-    const nlp = winkNLP(model);
-    const its = nlp.its;
-    cached = {
-      /** Lowercase lemma of a single token ("imported" -> "import"); the word
-       *  itself when wink has nothing better (unknown words come back as-is). */
-      lemma(word) {
-        const w = String(word || "");
-        try {
-          const out = nlp.readDoc(w).tokens().out(its.lemma);
-          return String(out[0] || w).toLowerCase();
-        } catch {
-          return w.toLowerCase();
-        }
-      },
-      /** UPOS tags aligned to the CALLER's word array. wink re-tokenizes (it
-       *  splits "walk.mjs" into three tokens), so each input word is greedily
-       *  matched to the run of wink tokens that spell it and takes its FIRST
-       *  sub-token's tag; null per word on any surprise, never a throw. */
-      posTags(words) {
-        try {
-          const toks = nlp.readDoc(words.join(" ")).tokens();
-          const texts = toks.out();
-          const tags = toks.out(its.pos);
-          const out = [];
-          let k = 0;
-          for (const w of words) {
-            if (k >= texts.length) { out.push(null); continue; }
-            out.push(tags[k]);
-            let acc = texts[k];
-            k += 1;
-            while (acc.length < w.length && k < texts.length) { acc += texts[k]; k += 1; }
-          }
-          return out;
-        } catch {
-          return words.map(() => null);
-        }
-      },
-    };
-  } catch {
-    cached = null;
-  }
-  return cached;
-}