@polycode-projects/the-mechanical-code-talker 2.3.0 → 2.5.0

package/corpus/tier2/manifest.json

@@ -61,7 +61,7 @@
     {
       "id": "human",
       "kind": "domain",
-      "description": "The default human-world persona (PLAN_SEED.md): everyday people, places, objects, nature, time/events, body/food and mind vocabulary, hand-curated from Open English WordNet (CC-BY-4.0) and bridged to Schema.org's (Apache-2.0) top-level classes — replaces the code-domain SEON+ConceptNet default.",
+      "description": "The default human-world persona: everyday people, places, objects, nature, time/events, body/food and mind vocabulary, hand-curated from Open English WordNet (CC-BY-4.0) and bridged to Schema.org's (Apache-2.0) top-level classes — replaces the code-domain SEON+ConceptNet default.",
       "source": {
         "kind": "curated",
         "tool": "corpus/tier2/generate.mjs"
@@ -75,7 +75,7 @@
     {
       "id": "human-medium",
       "kind": "domain",
-      "description": "The Medium tier of the default human-world persona (PLAN_SEED.md): incremental facts beyond Small only — activated alongside \"human\" via --persona-size medium, never active by default.",
+      "description": "The Medium tier of the default human-world persona: incremental facts beyond Small only — activated alongside \"human\" via --persona-size medium, never active by default.",
       "source": {
         "kind": "curated",
         "tool": "corpus/tier2/generate.mjs"
@@ -89,7 +89,7 @@
     {
       "id": "human-large",
       "kind": "domain",
-      "description": "The Large tier of the default human-world persona (PLAN_SEED.md): incremental facts beyond Medium only — activated alongside \"human\" via --persona-size large, never active by default.",
+      "description": "The Large tier of the default human-world persona: incremental facts beyond Medium only — activated alongside \"human\" via --persona-size large, never active by default.",
       "source": {
         "kind": "curated",
         "tool": "corpus/tier2/generate.mjs"

package/data/games/hanoi-3.txt

@@ -5,8 +5,14 @@
 #   the goal is that every disk rests on peg-c. solve it.
 #
 # Variations, each stretching a different direction:
-#   scale      — first teach: "disk-4 is a disk. disk-3 is smaller than disk-4."
-#                start all four on peg-a, same goal. 15 moves (2^4 - 1).
+#   scale      — first teach: "disk-4 is a disk."
+#                then: "disk-1 is smaller than disk-4. disk-2 is smaller than disk-4.
+#                disk-3 is smaller than disk-4."
+#                then: "disk-1 rests on disk-2. disk-2 rests on disk-3. disk-3 rests on
+#                disk-4. disk-4 rests on peg-a." — same goal. 15 moves (2^4 - 1).
+#                Every smaller-than pair is taught: the relation is stored as given and
+#                is not chased transitively, so disk-3 < disk-4 alone leaves disk-1 and
+#                disk-2 with no legal move onto disk-4 and no plan exists.
 #   any start  — disk-1 rests on peg-b. disk-2 rests on peg-c. disk-3 rests on peg-a.
 #                the goal is that every disk rests on peg-c. solve it.
 #   other goal — same start, "the goal is that every disk rests on peg-b. solve it."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",
@@ -51,10 +51,23 @@
   "files": [
     "bin/",
     "src/",
+    "!src/adapters/pii-scan.mjs",
+    "!src/domain/corpus-matrix.mjs",
+    "!src/domain/inflect.mjs",
+    "!src/domain/licences.mjs",
+    "!src/domain/markdown-links.mjs",
+    "!src/domain/pack-manifest.mjs",
+    "!src/domain/persona/codegen.mjs",
+    "!src/domain/pii-rules.mjs",
+    "!src/domain/publish-gate.mjs",
+    "!src/domain/schemaorg/turtle.mjs",
+    "!src/domain/version-stamp.mjs",
     "README.md",
     "ROADMAP.md",
     "LICENSE",
     "corpus/",
+    "!corpus/wordnet/generate.mjs",
+    "!corpus/namenet/generate.mjs",
     "data/"
   ],
   "publishConfig": {
@@ -69,7 +82,9 @@
   },
   "scripts": {
     "help": "node bin/tmct.mjs --help",
-    "test": "node --test \"test/**/*.test.mjs\"",
+    "test": "node --test --test-concurrency=8 \"test/**/*.test.mjs\"",
+    "test:smoke": "node --test test/smoke/*.test.mjs",
+    "test:fast": "node --test --test-concurrency=8 test/smoke/*.test.mjs test/fast/*.test.mjs test/tools/ask.test.mjs test/tools/server.test.mjs test/estate/import-layers.test.mjs",
     "test:e2e": "node --test \"e2e/**/*.test.mjs\"",
     "e2e:browsers": "playwright install chromium",
     "check:links": "node scripts/check-links.mjs",
@@ -78,8 +93,9 @@
     "check:licences": "node scripts/check-licences.mjs",
     "check:publint": "npx --no-install publint",
     "check:tool-docs": "node scripts/generate-tool-docs.mjs --check",
+    "check:budgets": "node scripts/check-tier-budgets.mjs",
     "check:publish": "node scripts/check-publish.mjs",
-    "check:all": "npm run check:links && npm run check:pii && npm run check:licences && npm run check:publint && npm run check:tool-docs",
+    "check:all": "npm run check:links && npm run check:pii && npm run check:licences && npm run check:publint && npm run check:tool-docs && npm run check:budgets",
     "smoke:deploy": "node scripts/post-deploy-smoke.mjs",
     "chat": "node bin/tmct.mjs",
     "chat:repo": "node bin/tmct.mjs chat --repo",
@@ -122,13 +138,16 @@
     "build:demo-memory": "node scripts/build-demo-memory.mjs",
     "gen:tool-docs": "node scripts/generate-tool-docs.mjs",
     "gen:collisions": "node scripts/generate-real-word-collisions.mjs",
+    "gen:prose-corpus": "node scripts/fetch-prose-corpus.mjs",
     "gen:variants": "node scripts/generate-template-variants.mjs",
-    "extract:facts": "node scripts/extract-facts-from-text.mjs"
+    "extract": "node bin/tmct.mjs extract",
+    "extract:facts": "node bin/tmct.mjs extract"
   },
   "devDependencies": {
     "esbuild": "^0.28.1",
     "ink-testing-library": "^4.0.0",
     "playwright": "1.61.1",
-    "publint": "0.3.21"
+    "publint": "0.3.21",
+    "yaml": "2.9.0"
   }
 }

package/src/adapters/corpus-lanes.mjs

@@ -0,0 +1,13 @@
+// Discover corpus lanes on disk: every .jsonl under `dir` (recursively),
+// returned as lane names — the path relative to dir, without the .jsonl suffix
+// — sorted. Sharded lane families live one directory down, e.g.
+// games/openers.jsonl -> "games/openers".
+import { readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+
+export function corpusLanes(dir) {
+  return readdirSync(dir, { withFileTypes: true, recursive: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+    .map((entry) => relative(dir, join(entry.parentPath, entry.name)).slice(0, -".jsonl".length))
+    .sort();
+}

package/src/adapters/graph-build.mjs

@@ -15,12 +15,10 @@
 //   mgx:touchesSymbol       Commit -> CodeEntity (commit changed-line-range x symbol span)
 //   mgx:callsSymbol         Function/Method -> Function/Class (symbol-granular, unambiguous)
 //   seon:containsCodeEntity Class  -> Method/Attribute (class membership)
-//   mgx:subclassOf          Class  -> Class    (inheritance)
+//   seon:hasSuperType       Class  -> Class    (inheritance)
 
-import { attachProseTokens, buildProseIndex } from "./prose-tokens.mjs";
-
-const isTestPath = (p) =>
-  p.startsWith("tests/") || /(^|\/)tests?\//.test(p) || /(^|\/)test_[^/]*\.py$/.test(p) || /\.tests(\.|$)/.test(p);
+import { attachProseTokens, buildProseIndex } from "../domain/prose.mjs";
+import { isTestPath } from "../domain/module-paths.mjs";
 
 const lastIdent = (name) => {
   const m = String(name).match(/([A-Za-z_][A-Za-z0-9_]*)\s*$/);
@@ -145,7 +143,7 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
         if (d.raises?.length) attrs.push({ prop: "seon:throwsException", key: "raises", value: list(d.raises) });
         if (d.catches?.length) attrs.push({ prop: "seon:catchesException", key: "catches", value: list(d.catches) });
         if (d.self_fields?.length) attrs.push({ prop: "seon:accessesField", key: "self_fields", value: list(d.self_fields) });
-        if (d.subkind) attrs.push({ prop: "seon:subKind", key: "subkind", value: String(d.subkind) });
+        if (d.subkind) attrs.push({ prop: "mgx:subKind", key: "subkind", value: String(d.subkind) });
         if (d.is_static) attrs.push({ prop: "seon:isStatic", key: "isStatic", value: "true" });
         if (d.is_abstract) attrs.push({ prop: "seon:isAbstract", key: "isAbstract", value: "true" });
         if (d.is_constant) attrs.push({ prop: "seon:isConstant", key: "isConstant", value: "true" });
@@ -392,7 +390,7 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
       { prop: "seon:isStatic", note: "@staticmethod/@classmethod" },
       { prop: "seon:isAbstract", note: "@abstractmethod/@abstractproperty" },
       { prop: "seon:isConstant", note: "ALL_CAPS module global" },
-      { prop: "seon:subKind", note: "type flavour on a Class define when not a plain class (interface/enum/struct/record); kind stays class" },
+      { prop: "mgx:subKind", note: "type flavour on a Class define when not a plain class (interface/enum/struct/record); kind stays class; owned — SEON has no subKind property" },
       { prop: "seon:hasAccessModifier", note: "visibility from leading underscore (private/protected); public omitted" },
       { prop: "seon:hasDoc", note: "first docstring line (capped) — one-line purpose without the body" },
     ],

package/src/adapters/import-closure.mjs

@@ -0,0 +1,28 @@
+// Every file under `root` that `entry`'s relative imports reach, walked from
+// source at read time and returned as paths relative to root, sorted.
+//
+// `seeds` names extra entry points to fold into the same closure — modules that
+// arrive through a computed specifier a static read cannot follow (a lemma/POS
+// tier loaded by a variable), so they and everything they reach still get
+// walked.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+
+import { relativeSpecifiers } from "../domain/relative-specifiers.mjs";
+
+export function importClosure(entry, { root, seeds = [] } = {}) {
+  const reached = new Set();
+  const visit = (file) => {
+    const rel = relative(root, file);
+    if (reached.has(rel) || !existsSync(file)) return;
+    reached.add(rel);
+    if (file.endsWith(".json")) return;
+    const source = readFileSync(file, "utf8");
+    for (const specifier of relativeSpecifiers(source)) {
+      visit(resolve(dirname(file), specifier));
+    }
+  };
+  visit(join(root, entry));
+  for (const file of seeds) visit(join(root, file));
+  return [...reached].sort();
+}

package/src/adapters/memory/blocks.mjs

@@ -6,7 +6,8 @@
 
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { splitIdentifierWords, tokenizeProse } from "../prose-tokens.mjs";
+import { splitIdentifierWords, tokenizeProse } from "../../domain/prose.mjs";
+import { idfWeight } from "../../domain/text-stats.mjs";
 import { SOURCE_PRIOR } from "../../domain/memory/trust.mjs";
 
 // A block inherits its Source's trust (operator 1.0, corpus 0.7); retrieval
@@ -182,12 +183,12 @@ export async function retrieveBlocks(dir, query, k = 3) {
   if (!qTokens.length) return [];
 
   const sets = entries.map(([, b]) => new Set(b.tokens || []));
-  // idf per query token, computed once: log(1 + N/(1+df)) — the codegraph.mjs
-  // locate weighting (~0 for ubiquitous tokens, large for rare ones).
+  // idf per query token, computed once over the block set (~0 for ubiquitous
+  // tokens, large for rare ones) — the same weighting codegraph.mjs locate uses.
   const idf = new Map(qTokens.map((t) => {
     let df = 0;
     for (const s of sets) if (s.has(t)) df += 1;
-    return [t, Math.log(1 + N / (1 + df))];
+    return [t, idfWeight(N, df)];
   }));
   const scored = [];
   for (let i = 0; i < N; i += 1) {

package/src/adapters/memory/core.mjs

@@ -4,10 +4,17 @@
 // appendFact), and Sessions are all typed twice — payload `class` and an
 // `rdf:type` attribute. Every append is crash-safe and idempotent (utterance
 // ids are deterministic, fact ids hash the triple).
+//
+// A Fact is textbook RDF reification: `rdf:type rdf:Statement` plus
+// rdf:subject/predicate/object, which carries the per-triple provenance and
+// polarity stamps a bare triple has no room for. This is the RDF 1.1
+// reification vocabulary, which RDF 1.2 reclassifies as legacy (steering new
+// systems toward triple terms) but does not deprecate. See
+// docs/references/schemas/rdf-reification-and-rdf-star.md.
 
 import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { proseTokensFor, buildProseIndex } from "../prose-tokens.mjs";
+import { proseTokensFor, buildProseIndex } from "../../domain/prose.mjs";
 import { fnv1aHex, normText, normFactTerm, normFactPredicate, factIdFor, factIdForTriple } from "../../domain/hash.mjs";
 
 // Fact identity (normalization + id derivation) lives in hash.mjs — the one
@@ -80,7 +87,7 @@ const MEMORY_VOCABULARY = [
   { prop: "mgx:ruleBaseCase", note: "recursive only: the base-case relation name (hop zero)" },
   { prop: "mgx:ruleRecStep", note: "recursive only: the self-referential recursive-step relation name" },
   { prop: CREATED_AT_PROP, note: "when an individual was FIRST written, ISO-8601 (first-write-wins on upsert); the audit 'when', the recency input to trust, the novelty signal" },
-  { prop: UPDATED_AT_PROP, note: "when an individual's OWN attributes were last mutated in place (upsertSession, recomputeFactTrust, recomputeSourceReliability) — most individuals never carry this and instead derive 'updated' from codegraph.mjs's derivedUpdatedAt (max createdAt over their edges)" },
+  { prop: UPDATED_AT_PROP, note: "an audit / last-modified stamp: when an individual's OWN attributes were last mutated in place (upsertSession, recomputeFactTrust, recomputeSourceReliability) — most individuals never carry it at all. NOT transaction time: a mutable stamp cannot record when the previous version stopped being current, so tmct is not bitemporal" },
   { prop: DERIVED_FROM_PROP, predicate: "derivedFrom", note: "umbrella: a Fact derived from a Source (or another Fact). ext ref prov:wasDerivedFrom (UNVERIFIED-pending-web-check)" },
   { prop: STATED_BY_PROP, predicate: "statedBy", note: "subPropertyOf derivedFrom: a Source directly asserts this Fact (one edge per independent source — replaces the factProvenance union)" },
   { prop: CANONICALISED_FROM_PROP, predicate: "canonicalisedFrom", note: "subPropertyOf derivedFrom: a canonical Fact cleaned from a raw Block/Source, never replacing it" },
@@ -519,8 +526,8 @@ export async function snapshotMemory(dir, { retentionVersions } = {}) {
  *  append creates the file). The result is a raw entities payload;
  *  parseEntities() loads it. */
 export async function loadMemory(dir) {
-  if (isMemoryHandle(dir)) return dir.payload;
-  if (isSqliteHandle(dir)) return readSqlitePayload(dir);
+  if (isMemoryHandle(dir)) return migrateLegacyFactIds(dir.payload);
+  if (isSqliteHandle(dir)) return migrateLegacyFactIds(readSqlitePayload(dir));
   let text;
   try {
     text = await readFile(memoryGraphFile(dir), "utf8");
@@ -528,7 +535,50 @@ export async function loadMemory(dir) {
     if (e?.code === "ENOENT") return emptyMemory();
     throw e;
   }
-  return JSON.parse(text);
+  return migrateLegacyFactIds(JSON.parse(text));
+}
+
+// A Fact id written before factIdFor widened to 64 bits — `fact:` + exactly 8
+// hex. A current id is 16 hex, so this anchored test never matches one, and a
+// migrated store pays only string checks with no rehash on load.
+const LEGACY_FACT_ID_RE = /^fact:[0-9a-f]{8}$/;
+
+/** Bring a store written under the old 32-bit fact id up to the current
+ *  factIdFor id, in place, on load. Every Fact carries its own (s, p, o) in
+ *  rdf:subject/predicate/object, so the current id recomputes from the payload
+ *  with no external key. Rewrites the Fact ids and everything that points at
+ *  them by id: statedBy/derivedFrom (and every other) edge endpoint, a rule's
+ *  mgx:factJustification premise-id list, and derived_from links. Idempotent —
+ *  a Fact already on a wide id is skipped by LEGACY_FACT_ID_RE, so a
+ *  fully-migrated store makes no change and does no work beyond the shape test.
+ *  This is what lets a pre-widening store keep resolving its facts: a lookup by
+ *  the current id finds the Fact because load moved it onto that id. */
+function migrateLegacyFactIds(payload) {
+  if (!Array.isArray(payload?.individuals)) return payload;
+  const remap = new Map(); // old fact id -> current fact id
+  for (const ind of payload.individuals) {
+    if (ind?.class !== FACT_CLASS || !LEGACY_FACT_ID_RE.test(ind.id || "")) continue;
+    const get = (k) => (ind.attributes || []).find((a) => a?.key === k)?.value || "";
+    const currentId = factIdFor(get("subject"), get("predicate"), get("object"));
+    if (currentId === ind.id) continue;
+    remap.set(ind.id, currentId);
+    ind.id = currentId;
+  }
+  if (!remap.size) return payload;
+  const remapId = (id) => remap.get(id) || id;
+  for (const group of payload.objectProperties || []) {
+    for (const e of group.examples || []) {
+      if (!e) continue;
+      if (remap.has(e.subject)) e.subject = remap.get(e.subject);
+      if (remap.has(e.object)) e.object = remap.get(e.object);
+    }
+  }
+  for (const ind of payload.individuals) {
+    if (Array.isArray(ind?.derived_from) && ind.derived_from.length) ind.derived_from = ind.derived_from.map(remapId);
+    const just = (ind?.attributes || []).find((a) => a?.prop === "mgx:factJustification");
+    if (just?.value) just.value = just.value.split(" ").filter(Boolean).map(remapId).join(" ");
+  }
+  return payload;
 }
 
 /** Persist a mutated payload back to `dir`: an atomic file write (Backend A),
@@ -627,6 +677,29 @@ function sourceIdFor(desc) {
 
 const sourceLabel = (id) => String(id).replace(/^src:/, "");
 
+// The read-side of the Source split ontology/tmct-core.ttl declares. tmct:Source
+// is one flat class over a sourceType key whose values fall into all three of
+// PROV's disjoint top classes; this maps each stored sourceType to its read-side
+// subclass and PROV top class. Nothing on disk changes — sourceType is already
+// stored on every Source — so this is derivation, not migration.
+const PROV_CLASS_BY_SOURCE_TYPE = Object.freeze({
+  operator: { subClass: "tmct:AgentSource", prov: "prov:Agent" },
+  teach: { subClass: "tmct:AgentSource", prov: "prov:Agent" },
+  provider: { subClass: "tmct:AgentSource", prov: "prov:Agent" },
+  corpus: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
+  corpusWeak: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
+  web: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
+  extracted: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
+  entailed: { subClass: "tmct:ActivitySource", prov: "prov:Activity" },
+});
+
+/** The read-side PROV subclass and top class a Source's mgx:sourceType maps to,
+ *  or null for an unrecognised type (never force-fit). Mirrors the Source-split
+ *  subclasses of tmct:Source in ontology/tmct-core.ttl. */
+export function provSourceClassFor(sourceType) {
+  return PROV_CLASS_BY_SOURCE_TYPE[sourceType] || null;
+}
+
 /** Upsert a Source individual (deterministic id → idempotent, edges never
  *  dangle). createdAt is first-write-wins; a recovered @<ts> (desc.createdAt)
  *  seeds it when present. Returns the Source id, or null for an unknown kind. */

package/src/adapters/memory/shacl.mjs

@@ -31,6 +31,12 @@ const RULE_SLOT_PROPS = {
   ],
 };
 
+// A term that runs past a sentence terminator into the next sentence
+// ("disk-2. disk-2 rests on disk-3") is a whole un-split line captured as one
+// term, not a term. Requires the word character after the terminator, so an
+// abbreviation or a version ("v1.2", "core.mjs") stays a legal term.
+const SPANS_A_SENTENCE_BOUNDARY_RE = /[.!?]\s+\w/;
+
 function attrValue(ind, prop) {
   const a = (ind?.attributes || []).find((x) => x?.prop === prop);
   return a ? String(a.value ?? "") : undefined;
@@ -54,6 +60,12 @@ function checkFact(ind, violations) {
   for (const prop of ["rdf:subject", "rdf:predicate", "rdf:object"]) {
     if (!nonEmpty(attrValue(ind, prop))) violations.push(`a Fact needs a non-empty ${prop}`);
   }
+  for (const prop of ["rdf:subject", "rdf:object"]) {
+    const term = attrValue(ind, prop);
+    if (term !== undefined && SPANS_A_SENTENCE_BOUNDARY_RE.test(term)) {
+      violations.push(`a Fact's ${prop} must be a single term, not text spanning a sentence boundary (got ${JSON.stringify(term)})`);
+    }
+  }
   const prov = attrValue(ind, "mgx:factProvenance");
   if (prov !== undefined && !nonEmpty(prov)) violations.push("mgx:factProvenance, when present, must be non-empty");
 }

package/src/adapters/providers/graph-service.mjs

@@ -20,6 +20,7 @@ import {
   impactClosure,
   scoreSymbolsRanked,
   searchModulesRanked,
+  compileNameFilter,
   SEARCH_LIMIT,
   contextPlan,
   sizeBundle,
@@ -383,14 +384,20 @@ export function createGraphService(graph, { sourceAccess = false, repoRoot = nul
       const k = String(kind || "").trim().toLowerCase();
       const nm = String(name || "").trim();
       const dec = String(decorator || "").trim().toLowerCase();
-      let nameRe = null;
-      if (nm) {
-        try { nameRe = new RegExp(nm, "i"); } catch { nameRe = null; }
-      }
       let rankedInds; // Individual[], highest-ranked first
       if (k && k !== "module") {
+        let nameRe = null;
+        if (nm) {
+          const compiled = compileNameFilter(nm);
+          if (compiled.error) return miss(MISS_REASONS.UNRESOLVED_TERM, { term: nm, detail: compiled.error });
+          nameRe = compiled;
+        }
         const tokens = rawQuery.toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean);
-        rankedInds = scoreSymbolsRanked(graph, tokens, { kind: k, decFilter: dec, nameRe }).map((s) => s.ind);
+        try {
+          rankedInds = scoreSymbolsRanked(graph, tokens, { kind: k, decFilter: dec, nameRe }).map((s) => s.ind);
+        } catch (e) {
+          return miss(MISS_REASONS.UNRESOLVED_TERM, { term: nm, detail: String(e?.message || e) });
+        }
       } else {
         // label -> individual, scoped to this call: maps searchModulesRanked's path labels
         // back to real Individuals.

package/src/adapters/tracked-files.mjs

@@ -0,0 +1,17 @@
+// Enumerate the repo's git-tracked files, optionally filtered by a git
+// pathspec, via `git ls-files -z`. Node builtins + git only, no bare specifier:
+// the pii and links CI jobs import this and run without npm ci.
+
+import { execFileSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+export function trackedFiles(pattern) {
+  const args = ["ls-files", "-z"];
+  if (pattern) args.push(pattern);
+  return execFileSync("git", args, { cwd: REPO_ROOT, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 })
+    .split("\0")
+    .filter(Boolean);
+}

package/src/domain/ask-vocab.mjs

@@ -593,6 +593,8 @@ export const CASCADE_NOISE = Object.freeze([
   "the", "a", "an", "some", "other", "about",
   "please", "pls", "plz", "kindly", "just", "simply", "maybe", "perhaps",
   "thanks", "thank", "ta", "cheers",
+  "too", "also", "well", "either",
+  "sorry", "oops", "actually", "mean", "meant", "rather",
   "hi", "hello", "hey", "yo", "hiya", "howdy", "ok", "okay",
   "matey", "mate", "buddy", "pal", "dude", "man", "bro", "bru", "fam",
   "friend", "sir", "maam", "folks", "guys", "everyone", "dear",