@polycode-projects/seonix 0.9.1 → 0.10.0

package/README.md

@@ -46,13 +46,13 @@ network calls, **$0**.
 
 ```bash
 # 1. index your repo (deterministic, offline) — writes a machine-local .seonix/
-seonix cli index_repository '{"repo_path":"/abs/path/to/repo"}'
+cd /path/to/repo && seonix cli index_repository
 
 # 2. self-locate the touched modules from the task text (no human-chosen target)
-seonix cli seonix_search '{"repo_path":"/abs/path/to/repo","query":"<your task>"}'
+seonix cli seonix_search '{"query":"<your task>"}'
 
 # 3. render the bounded edit digest for those modules
-seonix cli digest '{"repo_path":"/abs/path/to/repo","modules":["<top hits>"]}' > digest.txt
+seonix cli digest '{"modules":["<top hits>"]}' > digest.txt
 
 # 4. inject digest.txt once at session start, then run your coding agent
 claude --prompt "Use the seonix digest below to localise and make the change. $(cat digest.txt)"
@@ -60,6 +60,13 @@ claude --prompt "Use the seonix digest below to localise and make the change. $(
 
 Add `.seonix/` to your `.gitignore`; it is machine-local and rebuilt from source.
 
+The JSON argument is optional on every `cli` command: an omitted `repo_path`
+resolves to the nearest ancestor of the current directory (current directory
+first) containing a `.seonix/`, so query commands work from any subdirectory of
+an indexed repo. `index_repository` falls back to the current directory when
+nothing is indexed yet; query commands print a one-line error instead. An
+explicit `repo_path` always wins.
+
 ## Indexing multiple repositories
 
 `index_repository` takes one of three argument forms:
@@ -117,14 +124,17 @@ should start it with cwd = the indexed worktree.
 ### `cli index_repository` — build the graph
 
 ```bash
+seonix cli index_repository                       # no arg: index the repo you are in
 seonix cli index_repository '{"repo_path":"/abs/repo"}'
 seonix cli index_repository '{"repo_paths":["/abs/repo1","/abs/repo2"],"out_root":"/abs/dir"}'
 seonix cli index_repository '{"multi_root":"/abs/estate"}'
 ```
 
 `repo_path` / `repo_paths`+`out_root` / `multi_root` are mutually exclusive — pass
-exactly one (or let `seonix.toml`'s `repositories` supply the set when none is
-given explicitly). Shared JSON options:
+at most one. When none is given, `seonix.toml`'s `repositories` supplies the set
+if present; otherwise the target defaults to the nearest ancestor of the current
+directory carrying a `.seonix/` (re-index), else the current directory itself
+(first index). Shared JSON options:
 
 - `ignores` (bool, default `true`) — honour the repo's `.seonixignore`. Pass
   `"ignores":false` to index everything regardless (the bench harness always
@@ -235,7 +245,9 @@ seonix cli seonix_context '{"symbol":"buildContextBundle","repo_path":"/abs/repo
 Any sub-command name that isn't one of the above routes straight to the MCP tool
 dispatcher, so any tool in the server's surface — cold or hot — is invokable from
 Bash with no MCP connection. `repo_path` in the JSON arg selects the target
-graph; every other key is passed through as the tool's own arguments.
+graph; omitted, it defaults to the nearest ancestor of the current directory
+containing a `.seonix/` (a clean one-line error when there is none). Every other
+key is passed through as the tool's own arguments.
 
 ### `hook-augment` — PreToolUse Grep/Glob augmenter
 
@@ -316,7 +328,11 @@ seonix supplies the graph through tmct's provider seam.
 Two opt-in/opt-out environment knobs, orthogonal to everything above:
 `SEONIX_STORE=sqlite` turns on the resident `node:sqlite` store as a derived,
 rebuildable companion to `graph.json` (rebuild it explicitly with `cli
-store_rebuild`; unset, nothing sqlite loads). `SEONIX_GRAPH_FORMAT` controls the
+store_rebuild`; unset, nothing sqlite loads). The variable must be **exported**
+(`export SEONIX_STORE=sqlite`) — a plain shell assignment is invisible to the
+`seonix` child process, and the JSON path runs instead. The index summary's
+`store:` line states which mode actually ran (`store: sqlite (graph.db +
+graph.json)` only when `graph.db` was built). `SEONIX_GRAPH_FORMAT` controls the
 graph's on-disk wire format — the interned v2 form is the shipped default;
 set `SEONIX_GRAPH_FORMAT=1` to opt back out to the legacy v1 form.
 

package/bin/cli.mjs

@@ -6,6 +6,12 @@
 //   seonix cli index_repository '{"repo_path":"<abs>"}' → deterministic index
 //     (honours <repo>/.seonixignore — gitignore-subset patterns; pass
 //      `"ignores":false` in the JSON arg to index everything regardless)
+//     The JSON arg is OPTIONAL for every `cli` command: an omitted repo_path defaults
+//     to the nearest ancestor of cwd (cwd first) containing a .seonix/ directory —
+//     so a bare `seonix cli index_repository` indexes the repo you are in, and query
+//     commands run from any subdirectory of an indexed repo. index_repository falls
+//     back to cwd when nothing is indexed yet (it creates the index); query commands
+//     error cleanly instead. An explicit repo_path always wins, unchanged.
 //   seonix cli index_repository '{"repo_paths":["<abs1>","<abs2>",…],"out_root":"<abs-dir>"}' → index
 //     n repos into ONE merged graph at <out_root>/.seonix/ (module ids prefixed with each repo's
 //     directory basename; out_root defaults to the paths' deepest common ancestor directory).
@@ -39,7 +45,7 @@
 // graph artifact to <repo_path>/.seonix/graph.json; the server (started with
 // cwd = that repo) loads it by default. No flags, no config files.
 
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
@@ -52,7 +58,7 @@ import * as source from "../src/source.mjs";
 import { parseEntities, renderSearch, rankModulesByProximity, searchModulesRanked, selectRankedModules, DEFAULT_SCORE_GAP } from "../src/codegraph.mjs";
 import { loadTomlConfig, normalizeConfig, mergeEffective, CONFIG_FILE } from "../src/toml-config.mjs";
 import { compileGlobs } from "../src/walk.mjs";
-import { createTelemetry } from "../src/telemetry.mjs";
+import { createTelemetry, truncateStr, looksLikeMiss } from "../src/telemetry.mjs";
 
 /** Build a config pointed at a specific repo's artifact (for `cli` sub-commands that
  *  take a repo_path), or fall back to the cwd-derived default. */
@@ -67,6 +73,39 @@ function parsePayload(payload) {
   catch { return null; }
 }
 
+/** Nearest ancestor of `startDir` (itself first) containing a .seonix/ directory, or null. */
+function findIndexRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  for (;;) {
+    if (existsSync(join(dir, ".seonix"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/** Default an omitted repo_path for a `cli` command. Precedence:
+ *    1. explicit repo_path — always wins, args returned untouched (byte-identical to today);
+ *    2. SEONIX_GRAPH_FILE — also untouched (configFor's loadConfig fallback consumes it);
+ *    3. the nearest ancestor of cwd (cwd first) carrying a .seonix/ → written into args.repo_path;
+ *    4. nothing found: commands that READ an index (`mustExist`) get a one-line error + exit 2;
+ *       index_repository falls back to cwd (it CREATES the index there).
+ *  Mutating args means downstream configFor/tomlFor/telemetry all see the resolved repo. */
+function defaultRepoPath(args, { mustExist = true } = {}) {
+  if (args.repo_path !== undefined) return args;
+  // The env override only steers commands that READ a graph (query commands); index_repository
+  // writes to <repo>/.seonix and never consumes SEONIX_GRAPH_FILE, so it still defaults.
+  if (mustExist && process.env.SEONIX_GRAPH_FILE && process.env.SEONIX_GRAPH_FILE.trim()) return args;
+  const root = findIndexRoot();
+  if (root) { args.repo_path = root; return args; }
+  if (mustExist) {
+    process.stderr.write("seonix: no .seonix index found here or above — run `seonix cli index_repository` first or pass repo_path\n");
+    process.exit(2);
+  }
+  args.repo_path = process.cwd();
+  return args;
+}
+
 /** Load a repo's seonix.toml as a normalized config, or null. Returns null IMMEDIATELY when
  *  `args.config === false` (the BENCH-IMMUNITY flag — an arm's index/locate/digest must NEVER read a
  *  subject repo's seonix.toml) OR when no seonix.toml exists. So on the bench path, and with no
@@ -163,6 +202,7 @@ async function runDigest(args) {
   // stdout is the digest injected into the no-MCP arm, so telemetry must never touch it. The
   // seonix.toml [telemetry] toggle rides in via `toml`; SEONIX_TELEMETRY still wins both ways.
   const tel = createTelemetry({ env: process.env, config: configFor(repoPath), toml, surface: "cli" });
+  const t0 = Date.now();
   const tune = resolveDigestTune(args, toml);
   let modules = Array.isArray(args.modules) ? args.modules.slice(0, DIGEST_MODULE_CAP) : [];
   let autoSelected = null; // for the header, when `query` drove selection
@@ -236,10 +276,14 @@ async function runDigest(args) {
   process.stdout.write(out);
   // One telemetry line for the digest surface: the selected modules + the effective tier/topup the
   // header already carries, plus the injected body size. `tier` here MUST equal the header's tier=.
+  // (wh dogfood backlog #6): duration + a miss flag — a query-mode digest that selected zero
+  // modules is an unambiguous miss (autoSelected is only set in query mode).
   tel?.record({
     surface: "digest",
-    query: args.query ? { raw: args.query } : undefined,
+    query: args.query ? { raw: truncateStr(args.query) } : undefined,
     response: { count: emitted, node_ids: modules, tier: effTier, topup },
+    perf: { ms_total: Date.now() - t0 },
+    quality: { miss: autoSelected ? autoSelected.length === 0 : emitted === 0 },
     cost: { returned_chars: out.length, returned_tokens_est: Math.ceil(out.length / 4) },
   });
 }
@@ -320,15 +364,21 @@ async function main() {
       }
       // seonix.toml: config dir = the explicit repo/estate path, else out_root, else cwd (where the
       // file sits). Skipped entirely on the bench path (config:false → tomlFor null → byte-identical).
-      const toml = await tomlFor(args.repo_path || args.multi_root || args.out_root || process.cwd(), args);
+      let toml = await tomlFor(args.repo_path || args.multi_root || args.out_root || process.cwd(), args);
       warnUnwired(toml);
       // repositories: seonix.toml MAY supply the repo set when NO explicit path arg is given
       // (explicit repo_path/repo_paths/multi_root always win).
       const tomlRepos = (given.length === 0 && toml && Array.isArray(toml.repositories) && toml.repositories.length)
         ? toml.repositories : null;
       if (given.length === 0 && !tomlRepos) {
-        process.stderr.write("seonix: index_repository requires repo_path, repo_paths or multi_root\n");
-        process.exit(2);
+        // No path arg and no seonix.toml repo set: default to the nearest ancestor of cwd
+        // carrying a .seonix/ (re-index it), else cwd itself (first index — it creates .seonix/).
+        defaultRepoPath(args, { mustExist: false });
+        // The resolved root may carry its own seonix.toml (cwd can be a subdirectory) — re-read there.
+        if (args.repo_path && args.repo_path !== process.cwd()) {
+          toml = await tomlFor(args.repo_path, args);
+          warnUnwired(toml);
+        }
       }
       // A5 `history_depth`: unified cap over BOTH git-history passes. 0 = skip history entirely;
       // N>0 = `git log -n N`; absent = today's defaults. Precedence: explicit arg > seonix.toml
@@ -449,7 +499,7 @@ async function main() {
         process.stderr.write("seonix: digest expects a JSON arg, e.g. '{\"repo_path\":\"/abs\",\"modules\":[…]}'\n");
         process.exit(2);
       }
-      await runDigest(args);
+      await runDigest(defaultRepoPath(args));
       return;
     }
 
@@ -463,6 +513,24 @@ async function main() {
         process.stderr.write("seonix: seonix_locate expects a JSON arg, e.g. '{\"query\":\"…\",\"repo_path\":\"/abs\"}'\n");
         process.exit(2);
       }
+      // Tool honesty (wh dogfood T7): seonix_locate used to print NOTHING and exit 0 for
+      // any input without a query ({}, {"symbol":…}, {"bogus":1}) — an empty ranking is
+      // indistinguishable from success in a tool loop. Bad/missing args are now a one-line
+      // error naming the valid keys + a nonzero exit, like the generic dispatchTool route.
+      const LOCATE_KEYS = [
+        "query", "raw_query", "repo_path", "config", "limit", "spiral", "spiral_depth",
+        "demote_nonprod", "call_adjacency", "impl_of_interface", "beam_search", "beam_width", "literal_mention",
+      ];
+      const unknownKeys = Object.keys(args).filter((k) => !LOCATE_KEYS.includes(k));
+      if (unknownKeys.length) {
+        process.stderr.write(`seonix: unknown argument(s) for seonix_locate: ${unknownKeys.join(", ")}. Valid: ${LOCATE_KEYS.join(", ")}.\n`);
+        process.exit(2);
+      }
+      if (!String(args.query || "").trim()) {
+        process.stderr.write("seonix: seonix_locate requires a non-empty \"query\" (free text to rank modules against). For a single symbol use seonix_search or seonix_describe.\n");
+        process.exit(2);
+      }
+      defaultRepoPath(args);
       const config = configFor(args.repo_path);
       // seonix.toml [tune] defaults the locate levers (arg > seonix.toml > default). Skipped on the
       // bench path (config:false → tomlFor null) and when no seonix.toml exists → byte-identical.
@@ -471,6 +539,7 @@ async function main() {
       // Opt-in telemetry (default OFF → null → no-op, no file). stdout is the ranked list the rig
       // parses, so telemetry is LOG FILE ONLY. seonix.toml [telemetry] rides in via `toml`.
       const tel = createTelemetry({ env: process.env, config, toml, surface: "cli" });
+      const t0 = Date.now();
       const tune = resolveLocateTune(args, toml);
       try {
         const graph = parseEntities(await source.fetchEntities(config));
@@ -510,15 +579,18 @@ async function main() {
             : {}),
         });
         process.stdout.write(ranked.map((r) => `${r.path}\t${r.score}`).join("\n") + "\n");
-        // Telemetry for the locate surface: the ranked count + the top few paths/scores.
+        // Telemetry for the locate surface: the ranked count + the top few paths/scores, plus
+        // (wh dogfood backlog #6) duration + a miss flag (an empty ranking is an unambiguous miss).
         tel?.record({
           surface: "locate",
-          query: { raw: String(args.query || "") },
+          query: { raw: truncateStr(String(args.query || "")) },
           response: {
             count: ranked.length,
             node_ids: ranked.slice(0, 3).map((r) => r.path),
             scores: ranked.slice(0, 3).map((r) => r.score),
           },
+          perf: { ms_total: Date.now() - t0 },
+          quality: { miss: ranked.length === 0 },
         });
       } catch (e) {
         process.stderr.write(`seonix: ${e?.message || e}\n`);
@@ -539,6 +611,7 @@ async function main() {
         process.stderr.write("seonix: browser_link expects a JSON arg, e.g. '{\"query\":\"classes that change with render\"}'\n");
         process.exit(2);
       }
+      defaultRepoPath(args);
       const config = configFor(args.repo_path);
       const { buildTemporalGraph, gitCommitOrder } = await import("../src/browser.mjs");
       const { nlToQuery, validateLink, encodeViewState, VIEW_DEFAULTS } = await import("../src/temporal.mjs");
@@ -578,6 +651,7 @@ async function main() {
         process.stderr.write("seonix: store_rebuild expects a JSON arg, e.g. '{\"repo_path\":\"/abs\"}'\n");
         process.exit(2);
       }
+      defaultRepoPath(args);
       const { graphFile } = configFor(args.repo_path);
       const { readFile, stat } = await import("node:fs/promises");
       const { writeStore, storeFileFor, verifyStore } = await import("../src/store.mjs");
@@ -612,17 +686,23 @@ async function main() {
         process.stderr.write(`seonix: ${sub} expects a JSON arg, e.g. '{"symbol":"<name>"}'\n`);
         process.exit(2);
       }
+      defaultRepoPath(args);
       const config = configFor(args.repo_path);
       // seonix.toml [telemetry] toggle for the generic tool surface (byte-identical with no toml:
       // tomlFor short-circuits to null on the bench path and when no seonix.toml exists).
       const toml = await tomlFor(args.repo_path, args);
       const tel = createTelemetry({ env: process.env, config, toml, surface: "cli" });
+      const t0 = Date.now();
       try {
         const text = await dispatchTool(sub, args, { config });
         process.stdout.write(text + "\n");
-        // Telemetry for the generic tool surface: which tool + how many chars it returned.
+        // Telemetry for the generic tool surface: which tool + how many chars it returned, plus
+        // (wh dogfood backlog #6) the args text/duration/hit-miss the log previously omitted.
         tel?.record({
           tool: sub,
+          query: { raw: truncateStr(JSON.stringify(args)) },
+          perf: { ms_total: Date.now() - t0 },
+          quality: { miss: looksLikeMiss(text) },
           cost: { returned_chars: text.length, returned_tokens_est: Math.ceil(text.length / 4) },
         });
       } catch (e) {
@@ -632,7 +712,8 @@ async function main() {
       return;
     }
 
-    process.stderr.write("seonix: `cli` needs a sub-command (index_repository | digest | <toolName>)\n");
+    process.stderr.write("seonix: `cli` needs a sub-command (index_repository | digest | <toolName>). " +
+      "The JSON arg is optional — an omitted repo_path defaults to the nearest ancestor of cwd with a .seonix/ index.\n");
     process.exit(2);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "private": false,
   "type": "module",
   "description": "SEONIX — a deterministic, offline, $0 code-graph tool that makes a cheap coding agent edit like an expensive one. Indexes a repo with Python ast + git (zero model calls) and renders a bounded edit-digest.",
@@ -51,13 +51,6 @@
     "join:telemetry": "node scripts/join-telemetry.mjs",
     "bench:lite": "node bench/run.mjs --suite lite",
     "bench:seonix": "node bench/run.mjs --suite django-lh --arms seonix,seonix-min --runs 5",
-    "bench:b010": "node bench/run.mjs --suite django-lh --arms otb,seonix,seonix-min,seonix-b010 --models claude-opus-4-8,claude-sonnet-4-6 --runs 5 --concurrency 10",
-    "bench:b011": "node bench/run.mjs --suite django-lh --arms seonix,seonix-min --models claude-opus-4-8,claude-sonnet-4-6,claude-haiku-4-5 --runs 5 --concurrency 15",
-    "bench:b011-haiku-refs": "node bench/run.mjs --suite django-lh --arms otb,seonix-b010 --models claude-haiku-4-5 --runs 5 --concurrency 10",
-    "bench:b015": "node scripts/bench-b015.mjs",
-    "bench:b016p1": "node scripts/bench-b016-p1.mjs",
-    "bench:b016h": "node scripts/bench-b016-h.mjs",
-    "bench:b016p2": "node scripts/bench-b016-p2.mjs",
     "bench:baseline": "node scripts/use-baseline.mjs",
     "proof": "node scripts/proof-demo.mjs",
     "smoke": "node bench/smoke.mjs --suite django-lh",
@@ -92,7 +85,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@polycode-projects/the-mechanical-code-talker": "^0.8.1",
+    "@polycode-projects/the-mechanical-code-talker": "^0.8.2",
     "cytoscape": "^3.30.0",
     "smol-toml": "^1.7.0",
     "tree-sitter": "^0.21.1",

package/src/ask-browser.bundle.js

@@ -952,12 +952,62 @@
   );
   var MISSPELLING_RE = correctionRe(MISSPELLINGS);
   var WRONG_WORD_RE = correctionRe(WRONG_WORDS);
+  var RELATION_VERB_RE = new RegExp(
+    "\\b(?:" + Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
+    "i"
+  );
+  var INTERROGATIVE_LEAD_RE = /^(?:which|what|who|whose|where|when|why|how)\b/i;
+  var LISTING_TAIL_KINDS = /* @__PURE__ */ new Set([
+    "modules",
+    "files",
+    "functions",
+    "methods",
+    "classes",
+    "attributes",
+    "fields",
+    "properties",
+    "variables",
+    "globals",
+    "commits",
+    "changes",
+    "tests",
+    "members"
+  ]);
+  var BARE_KIND_RE = /^(?:all\s+|the\s+)?(?:module|file|function|method|class|attribute|field|property|variable|global|commit|change|test|member)\??$/i;
+  var isListingRemainder = (rest) => {
+    if (BARE_KIND_RE.test(rest)) return true;
+    const words = rest.replace(/\?+\s*$/, "").trim().split(/\s+/);
+    return LISTING_TAIL_KINDS.has((words[words.length - 1] || "").toLowerCase());
+  };
+  var GREETING_PREAMBLE_RE = /^(?:hi|hiya|hello|hey|yo|howdy)(?:\s+there)?\s*[,—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
+  var MODAL_WRAPPER_RE = /^(?:can|could|would|will)\s+you\s+(?:please\s+)?(.+?)(?:[,\s]+please)?\??$/i;
+  var SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
+  function applyPreambleFrames(text) {
+    let q = String(text || "");
+    for (let pass = 0; pass < 3; pass++) {
+      const before = q;
+      let m = q.match(GREETING_PREAMBLE_RE);
+      if (m) q = m[1].trim();
+      m = q.match(MODAL_WRAPPER_RE);
+      if (m) q = m[1].trim();
+      m = q.match(SHOW_GIVE_ME_RE);
+      if (m) {
+        const rest = m[1].trim();
+        if (!isListingRemainder(rest)) {
+          q = RELATION_VERB_RE.test(rest) || INTERROGATIVE_LEAD_RE.test(rest) ? rest : `describe ${rest}`;
+        }
+      }
+      if (q === before) break;
+    }
+    return q;
+  }
   function normalizeQuery(text) {
     let q = String(text || "");
     q = q.replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
     q = q.replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
     q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
     q = q.replace(G_DROP, "$1ing");
+    q = applyPreambleFrames(q);
     if (FILLER_WORDS.length) {
       const fillerRe = new RegExp(
         "\\b(" + [...FILLER_WORDS].sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
@@ -1045,8 +1095,24 @@
     // separate authorship edge; "touched" IS the authorship signal (the churn commits
     // carry the author), so these are true synonyms of "who touched X", not a new
     // capability. Anaphora rides through untouched ("who wrote it" → "who touched it").
-    { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
-    { re: /^who\s+is\s+the\s+authors?\s+of\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    // SHA GUARD (0.8.2 feel wave): a COMMIT object is NOT a synonym — "who is the
+    // author of abc1234" rewritten to "who touched abc1234" dumps the commit's
+    // touch-SET instead of naming its author. The negative lookahead refuses the
+    // rewrite when the object is a bare (optionally "commit "-prefixed) 7-40 char
+    // hex sha, leaving the un-rewritten form for the author lane to consume;
+    // file/symbol objects (anything non-sha, e.g. "deadbeef.mjs") keep the rewrite.
+    { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    { re: /^who\s+is\s+the\s+authors?\s+of\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    // HAS-TESTS → the coverage question the RELATIONS table answers. "does X have
+    // tests" parses "have" as a defines-verb (VERB_TO_KIND), producing the garbled
+    // "No — no defines edge found from X to <whatever resolves>" receipt; "is X
+    // tested" traverses tests edges from the WRONG side (subject = X). Both mean
+    // the coverage question "what tests X" — rewrite onto it. Closed to a
+    // tests/coverage object ("does X have methods/members" stays the members
+    // family) and refuses any "not" in the subject span, so the set-complement
+    // negations ("is X not tested") keep their own handler downstream.
+    { re: /^(?:does|do)\s+(?!.*\bnot\b)(.+?)\s+have\s+(?:any\s+)?(?:tests?|test\s+coverage|coverage)\??$/i, to: (m) => `what tests ${m[1]}` },
+    { re: /^(?:is|are)\s+(?!.*\bnot\b)(.+?)\s+tested\??$/i, to: (m) => `what tests ${m[1]}` },
     // NEEDS-TESTS → the untested-module survey. "what needs tests" / "what needs
     // testing" is the plainest way to ask which modules are uncovered, and it hit the
     // grammar wall ("no module matching 'needs'…"). Route it onto the same attributive
@@ -1864,7 +1930,9 @@
 
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/merge.mjs
   var DEFAULT_CONFIDENCE = 0.5;
-  var cmpTerm = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ").replace(/^commit\s+(?=[0-9a-f]{7,40}$)/, "");
+  var cmpTerm = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ").replace(/^(?:the|a|an)\s+/, "").replace(/^commit\s+(?=[0-9a-f]{7,40}$)/, "");
+  var LEADING_DET_RE = /^\s*(?:the|a|an)\s+/i;
+  var detCount = (p) => [p?.subject, p?.object].filter((t) => LEADING_DET_RE.test(String(t || ""))).length;
   function sameParse(p, q) {
     if (p.shape !== q.shape || p.kind !== q.kind) return false;
     if (p.shape === "ask") return cmpTerm(p.subject) === cmpTerm(q.subject) && cmpTerm(p.object) === cmpTerm(q.object);
@@ -1904,6 +1972,7 @@
         if (dup) {
           dup.agreed += 1;
           dup.confidence = Math.max(dup.confidence, c.confidence);
+          if (detCount(c.parsed) < detCount(dup.parsed)) dup.parsed = c.parsed;
           continue;
         }
         distinct.push({ ...c, agreed: 1 });
@@ -2049,11 +2118,15 @@
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/ask.mjs
   function edgesOfKind(graph, kind) {
     const out = [];
-    for (const g of graph.relations) if (relationKind(g) === kind) out.push(...g.edges);
+    for (const g of graph.relations) {
+      if (relationKind(g) !== kind) continue;
+      for (const e of g.edges) out.push(e);
+    }
     return out;
   }
   var SYMBOL_GRAIN_SIBLING = { calls: "callsSymbol", touches: "touchesSymbol" };
   var FINE_ENTITY_TYPES = /* @__PURE__ */ new Set(["Function", "Method", "Class", "Attribute", "GlobalVariable"]);
+  var FINE_CLASS_SIBLING = { Function: "Method", Method: "Function" };
   var KIND_UNIONS = { uses: ["imports", "calls", "callsSymbol"] };
   var kindsFor = (kind) => KIND_UNIONS[kind] || [kind];
   var OVERFLOW_CAP = 12;
@@ -2077,6 +2150,10 @@
   function verbFor(kind) {
     return REVERSE_MISS_VERB[kind] || kind;
   }
+  var LEADING_RELATION_VERB_RE = new RegExp(
+    `^(?:${Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?:s|ing|ed)?\\s+`,
+    "i"
+  );
   function defaultNlp() {
     return typeof nlpAdapter === "function" ? nlpAdapter() : null;
   }
@@ -2981,7 +3058,24 @@
         const token = (i.attributes || []).find((a) => a.key === "token")?.value;
         return token && String(token).toLowerCase() === termLc;
       });
-      if (!match) return { matches: [], objMatch: null, candidates: [], traversal: `schema lookup for "${term}"`, ambiguous: false };
+      if (!match) {
+        const classHits = (graph.individuals || []).filter((i) => i.class === "Class" && String(i.label).toLowerCase() === termLc);
+        if (classHits.length === 1) {
+          const hit2 = classHits[0];
+          const mid = moduleIdOf2(graph, hit2);
+          const modLabel = mid && graph.byId.get(mid)?.label || String((hit2.attributes || []).find((a) => a.key === "site")?.value || "").split(":")[0] || null;
+          return {
+            matches: [hit2],
+            objMatch: hit2,
+            candidates: [],
+            ambiguous: false,
+            metaCodeClass: true,
+            metaModuleLabel: modLabel,
+            traversal: `schema lookup for "${term}" (miss), then unique Class individual by label`
+          };
+        }
+        return { matches: [], objMatch: null, candidates: [], traversal: `schema lookup for "${term}"`, ambiguous: false };
+      }
       return {
         matches: [match],
         objMatch: match,
@@ -3090,9 +3184,13 @@
       return commitTouches(graph, objMatch, entityType, { candidates, ambiguous, matchedVia });
     }
     if (shape === "forward") {
-      const edges2 = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === objMatch.id);
-      const matches2 = edges2.map((e) => graph.byId.get(e.object)).filter(Boolean);
-      return { matches: matches2, objMatch, candidates, traversal: `${kindsFor(kind).join("+")} edges where subject = ${objMatch.label}`, ambiguous, matchedVia };
+      const fwdSibling = SYMBOL_GRAIN_SIBLING[kind];
+      const subjIsFineSymbol = !!(fwdSibling && objMatch.class && FINE_ENTITY_TYPES.has(objMatch.class));
+      const fwdKinds = subjIsFineSymbol ? [.../* @__PURE__ */ new Set([...kindsFor(kind), fwdSibling])] : kindsFor(kind);
+      const edges2 = fwdKinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === objMatch.id);
+      const targets = edges2.map((e) => graph.byId.get(e.object)).filter(Boolean);
+      const matches2 = subjIsFineSymbol ? uniqueById(targets) : targets;
+      return { matches: matches2, objMatch, candidates, traversal: `${fwdKinds.join("+")} edges where subject = ${objMatch.label}`, ambiguous, matchedVia };
     }
     if (parsed.modifier === "transitive") {
       const levels = impactClosure(graph, objMatch, { maxDepth: TRANSITIVE_MAX_DEPTH });
@@ -3111,8 +3209,17 @@
     if (symbolKind && (FINE_ENTITY_TYPES.has(entityType) || objIsFineSymbol)) {
       const edges2 = edgesOfKind(graph, symbolKind).filter((e) => e.object === objMatch.id);
       const subjects2 = uniqueById(edges2.map((e) => graph.byId.get(e.subject)).filter(Boolean));
-      const matches2 = !entityType || entityType === "Change" ? subjects2 : subjects2.filter((i) => i.class === entityType);
-      return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}`, ambiguous, matchedVia };
+      let matches2 = !entityType || entityType === "Change" ? subjects2 : subjects2.filter((i) => i.class === entityType);
+      let widenNote = "";
+      const siblingClass = FINE_CLASS_SIBLING[entityType];
+      if (!matches2.length && siblingClass) {
+        const widened = subjects2.filter((i) => i.class === siblingClass);
+        if (widened.length) {
+          matches2 = widened;
+          widenNote = `, widened to ${siblingClass} subjects (no ${entityType} recorded)`;
+        }
+      }
+      return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}${widenNote}`, ambiguous, matchedVia };
     }
     let edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.object === objMatch.id);
     let extNote = "";
@@ -3214,6 +3321,16 @@
           ambiguous: false
         };
       }
+      if (result.metaCodeClass) {
+        const label = result.objMatch.label;
+        const definedIn = result.metaModuleLabel ? `, defined in ${result.metaModuleLabel}` : "";
+        return {
+          content: `${label} is a class in this codebase${definedIn} \u2014 try "describe ${label}" or "which classes inherit from ${label}".`,
+          miss: false,
+          ambiguous: false,
+          matches: result.matches
+        };
+      }
       const doc = (result.objMatch.attributes || []).find((a) => a.key === "doc")?.value || "";
       const kindWord = result.objMatch.class === "SchemaClass" ? "a class in the graph's schema" : "a predicate (relation) in the graph's schema";
       return { content: `${result.objMatch.label} is ${kindWord}: ${doc}`, miss: false, ambiguous: false, matches: result.matches };
@@ -3221,7 +3338,7 @@
     if (result.mentionsShape) {
       if (!result.matches.length) {
         return {
-          content: `"${parsed.object}" is not mentioned in any indexed identifier or doc-comment prose. (traversal: ${result.traversal})`,
+          content: `"${parsed.object}" is not mentioned in any indexed identifier or doc-comment prose.`,
           miss: true,
           ambiguous: false
         };
@@ -3278,7 +3395,7 @@
     if (result.whenShape) {
       const subject = result.objMatch.label;
       if (!result.matches.length) {
-        return { content: `no recorded commit touches ${subject} in this index. (traversal: ${result.traversal})`, miss: true, ambiguous: false };
+        return { content: `no recorded commit touches ${subject} in this index.`, miss: true, ambiguous: false };
       }
       const newest = result.matches[0];
       const date = (newest.attributes || []).find((a) => a.key === "date")?.value || "";
@@ -3306,7 +3423,7 @@
       const cite = `commit ${result.objMatch.label}`;
       if (!result.matches.length) {
         return {
-          content: `${cite} touched nothing recorded in the index. (traversal: ${result.traversal})`,
+          content: `${cite} touched nothing recorded in the index.`,
           miss: true,
           ambiguous: false
         };
@@ -3326,7 +3443,7 @@
         return { content: `couldn't resolve one of the terms in this question.`, miss: true, ambiguous: false };
       }
       return {
-        content: result.answer ? `Yes. (${result.traversal})` : `No \u2014 no ${parsed.kind} edge found from ${result.subjMatch.label} to ${result.objMatch.label}.`,
+        content: result.answer ? `Yes \u2014 ${result.traversal}.` : `No \u2014 no ${parsed.kind} edge found from ${result.subjMatch.label} to ${result.objMatch.label}.`,
         miss: !result.answer,
         ambiguous: false
       };
@@ -3334,22 +3451,23 @@
     if (!result.matches.length) {
       if (parsed.shape === "forward") {
         return {
-          content: `${result.objMatch.label} has no ${parsed.kind} edges in the index. (traversal: ${result.traversal || "no traversal resolved"})`,
+          content: `${result.objMatch.label} has no ${parsed.kind} edges in the index.`,
           miss: true,
           ambiguous: false
         };
       }
       if (parsed.kind === "tests" && !parsed.entityType) {
-        const obj = String(parsed.object || "").replace(/^cover(?:s|ing)?\s+/i, "").trim();
+        const stripped = String(parsed.object || "").replace(LEADING_RELATION_VERB_RE, "").trim();
+        const obj = stripped || String(parsed.object || "").trim();
         return {
-          content: `No tests cover ${obj}. (traversal: ${result.traversal || "no traversal resolved"})`,
+          content: `No tests cover ${obj}.`,
           miss: true,
           ambiguous: false
         };
       }
       const entityWord = nounFor(parsed.entityType || "Module", 2);
       return {
-        content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}. (traversal: ${result.traversal || "no traversal resolved"})`,
+        content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}.`,
         miss: true,
         ambiguous: false
       };