@polycode-projects/the-mechanical-code-talker 3.0.6 → 3.0.8

package/src/services/adventure.mjs

@@ -10,6 +10,7 @@
 
 import { worldProvenanceTag } from "../domain/worlds-pack.mjs";
 import { parseImperative, OBJECT_PRONOUNS } from "../domain/grammar/ace.mjs";
+import { register as registerReferent, bind as bindDiscourseForm } from "../domain/discourse.mjs";
 import { createCompletionsGraphAdapter } from "../domain/completions/graph-adapter.mjs";
 import { actionFamilies } from "../domain/router/taught.mjs";
 import { compileDomain, precondHolds, roleBinding } from "../domain/domain.mjs";
@@ -1224,14 +1225,16 @@ function renderedImperativeCommand(cmd) {
   return parts.join(" ");
 }
 
-// ---- pronoun binding: the session focus ---------------------------------------
+// ---- pronoun binding: the session discourse record ----------------------------
 //
 // A world command may name its object with a pronoun ("examine it", "take
 // them", "talk to him") instead of a noun. The antecedent is not in the
-// sentence — it's the last thing the player successfully acted on this
-// session, the FOCUS — so the parser leaves the pronoun bare (ace.mjs's
+// sentence — it's the last adventure object the player successfully acted on
+// this session — so the parser leaves the pronoun bare (ace.mjs's
 // OBJECT_PRONOUNS) and the lane binds it here, through ONE seam that every
-// object-taking verb passes on its way to runWorldCommand. With no focus
+// object-taking verb passes on its way to runWorldCommand. The antecedent lives
+// as one referent among N in the shared discourse record, so an adventure
+// object is bound the same way a code-graph answer's referent is. With nothing
 // standing, a pronoun gets an honest reference nudge, never the vocabulary
 // decline (a pronoun is a reference, not an unknown word).
 
@@ -1264,19 +1267,25 @@ async function noFocusPronounNudge(pronoun, { memoryDir }) {
   );
 }
 
-/** Bind any pronoun object/indirect/instrument slot to the session focus.
- *  Returns `{ cmd }` with the pronouns rewritten to the focus term, or `{
- *  nudge }` (the reference nudge) when a pronoun stands but no focus does. A
- *  command with no pronoun passes straight through untouched. */
-async function bindPronouns(cmd, { focus, memoryDir }) {
+/** Bind any pronoun object/indirect/instrument slot to the last adventure
+ *  object in the discourse record. Returns `{ cmd }` with the pronouns
+ *  rewritten to that object's term, or `{ nudge }` (the reference nudge) when a
+ *  pronoun stands but no adventure object does. A command with no pronoun
+ *  passes straight through untouched. All four surface pronouns
+ *  (it/them/him/her) normalize to the one `it` probe, then bind to the newest
+ *  referent THIS lane registered — the record may also hold code-graph
+ *  referents, so the bind is scoped to `lane: "adventure"`. */
+async function bindPronouns(cmd, { discourseHolder, memoryDir }) {
   if (!commandHasPronoun(cmd)) return { cmd };
-  if (!focus) {
+  const probe = discourseHolder ? bindDiscourseForm(discourseHolder.record, "it") : null;
+  const focusTerm = (probe?.candidates || []).find((r) => r.from?.lane === "adventure")?.label ?? null;
+  if (!focusTerm) {
     const pronoun = PRONOUN_SLOTS.map((s) => cmd[s]).find((v) => v && OBJECT_PRONOUNS.has(v));
     return { nudge: await noFocusPronounNudge(pronoun, { memoryDir }) };
   }
   const bound = { ...cmd };
   for (const s of PRONOUN_SLOTS) {
-    if (bound[s] && OBJECT_PRONOUNS.has(bound[s])) bound[s] = focus;
+    if (bound[s] && OBJECT_PRONOUNS.has(bound[s])) bound[s] = focusTerm;
   }
   return { cmd: bound };
 }
@@ -1292,7 +1301,7 @@ async function bindPronouns(cmd, { focus, memoryDir }) {
  * recognizer, injected so the two lanes can never disagree about what a plan
  * frame is.
  */
-export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "", env, lexicon = null, graph = null, cache = null, isPlanFrameLine = () => false }) {
+export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "", env, lexicon = null, graph = null, cache = null, isPlanFrameLine = () => false, discourseHolder = null }) {
   const slot = planHolder?.state ?? null;
   const adventure = slot?.adventure ?? null;
   const opening = matchAdventureOpening(line);
@@ -1351,16 +1360,22 @@ export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "
   if (INVENTORY_RE.test(line)) return inventoryAnswer({ memoryDir, graph });
   const parsed = parseImperative(line, lexicon ?? undefined);
   if (parsed) {
-    const bound = await bindPronouns(parsed, { focus: adventure.focus, memoryDir });
+    const bound = await bindPronouns(parsed, { discourseHolder, memoryDir });
     if (bound.nudge) return bound.nudge;
     const cmd = bound.cmd;
     const result = await runWorldCommand(cmd, { world: adventure.world, memoryDir, env, graph, cache });
-    // The object a command SUCCESSFULLY named becomes the focus a later
-    // pronoun binds to — so "look lamp" then "examine it" reads the lamp, and
-    // "talk to housekeeper" makes "him"/"her" the housekeeper. A miss leaves
-    // the standing focus untouched; a bare room look or a move carries no
-    // object and so never disturbs it.
-    if (!result.miss && cmd.object) adventure.focus = cmd.object;
+    // The object a command SUCCESSFULLY named registers as a discourse referent
+    // a later pronoun binds to — so "look lamp" then "examine it" reads the
+    // lamp, and "talk to housekeeper" makes "him"/"her" the housekeeper. A miss
+    // leaves the record untouched; a bare room look or a move carries no object
+    // and so never disturbs it.
+    if (!result.miss && cmd.object && discourseHolder) {
+      discourseHolder.record = registerReferent(discourseHolder.record, {
+        kind: "entity", class: "AdventureObject", label: cmd.object,
+        ids: [`adventure:${cmd.object}`], attrs: {},
+        from: { turn: discourseHolder.record.turn, lane: "adventure", query: line },
+      });
+    }
     if (!cmd.corrected?.length) return result;
     // A fuzzy-repaired verb or direction still executes normally, but the
     // response says what it read the line as, so a genuine miss is never

package/src/services/chat-page-viz.mjs

@@ -16,7 +16,7 @@
 // chip is read straight off the SAME "(source: ...)" citation chat.mjs's own
 // factPhrase/renderFactLine convention already appends to most answers (see
 // e.g. `dog is a kind of animal (source: corpus:conceptnet ...)` — already
-// asserted by e2e/pages-chat-fullscreen.test.mjs against this page), never a
+// asserted by test-e2e/pages-chat-fullscreen.test.mjs against this page), never a
 // second provenance computation against memory internals: `provBucketFor`
 // (ledger-viz.mjs) is spliced in unmodified and applied to whatever citation
 // text the answer already carries, so this page's chip and the ledger's own

package/src/services/chat.mjs

@@ -20,7 +20,7 @@
 import { join, dirname } from "node:path";
 import { dispatchTool, loadGraph, TOOLS } from "../tools/server.mjs";
 import { ToolError } from "../adapters/config.mjs";
-import { parseEntities, edgesOfKind, moduleCountOf, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "../domain/codegraph.mjs";
+import { parseEntities, edgesOfKind, moduleCountOf, packageCounts, modulesOf, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "../domain/codegraph.mjs";
 import { classDisplayName, DYNAMIC_TAIL_OK_RE } from "../domain/ask.mjs";
 import { emptyRecord as emptyDiscourseRecord, advanceTurn as advanceDiscourseTurn, register as registerReferent, bind as bindDiscourseForm } from "../domain/discourse.mjs";
 import { uuidv7 } from "../adapters/uuid.mjs";
@@ -462,6 +462,7 @@ const COUNT_NOUNS = {
   class: "Class", classes: "Class",
   function: "Function", functions: "Function", func: "Function", funcs: "Function",
   module: "Module", modules: "Module", file: "Module", files: "Module",
+  package: "Package", packages: "Package",
   method: "Method", methods: "Method",
   attribute: "Attribute", attributes: "Attribute",
   variable: "GlobalVariable", variables: "GlobalVariable", global: "GlobalVariable", globals: "GlobalVariable",
@@ -472,18 +473,25 @@ const COUNT_NOUNS = {
 /** class → [singular, plural] display noun, for echoing a count back in English. */
 const CLASS_LABELS = {
   Class: ["class", "classes"], Function: ["function", "functions"],
-  Module: ["module", "modules"], Method: ["method", "methods"],
+  Module: ["module", "modules"], Package: ["package", "packages"],
+  Method: ["method", "methods"],
   Attribute: ["attribute", "attributes"], GlobalVariable: ["variable", "variables"],
   Commit: ["commit", "commits"], Session: ["session", "sessions"],
 };
 const classNoun = (cls, n) => { const [s, p] = CLASS_LABELS[cls] || [cls, `${cls}s`]; return n === 1 ? s : p; };
 
-/** Count individuals of a class in the loaded graph (live, not the header field). */
-const countClass = (graph, cls) => graph.individuals.filter((i) => (i.class || "") === cls).length;
+/** Count individuals of a class in the loaded graph (live, not the header field).
+ *  No individual is ever stored with class "Package" — packages are the
+ *  directories grouping the modules, derived the same way the architecture map
+ *  derives them. */
+const countClass = (graph, cls) => (cls === "Package"
+  ? packageCounts(modulesOf(graph)).size
+  : graph.individuals.filter((i) => (i.class || "") === cls).length);
 
 /** The classes this graph can actually count, as a human list ("classes, functions, …"). */
 function countableKinds(graph) {
   const present = new Set(graph.individuals.map((i) => i.class).filter(Boolean));
+  if (present.has("Module")) present.add("Package");
   return Object.keys(CLASS_LABELS).filter((c) => present.has(c)).map((c) => CLASS_LABELS[c][1]);
 }
 
@@ -1079,13 +1087,15 @@ const CAPABILITY_PHRASES = [
   /^(?:what(?:'s|s|\s+is)|give me|show me|gimme) the big picture(?:\s+(?:here|(?:on|of|for|about)\s+(?:this|the)\s+(?:app|codebase|repo|repository|project|code)))?\??$/i,
   /^(?:give me|what's) the lay of the land\??$/i,
   // "give me an overview" / "an overview" — the plain-word sibling of "the
-  // big picture" just above, same optional here/of-this-repo tail. Without a
-  // closed entry the word "overview" prose-matches real symbols in an
-  // indexed graph (moduleOverviewText) and the describe rescue dumps that
-  // symbol's card. The detailed forms ("give me a detailed overview of X")
-  // carry a mandatory "detailed"+of-term and stay with the completions
-  // rescue, untouched by this anchor.
-  /^(?:(?:can|could|would) you\s+)?(?:give me|show me|gimme)\s+an overview(?:\s+(?:here|(?:on|of|for|about)\s+(?:this|the)\s+(?:app|codebase|repo|repository|project|code)))?\??$/i,
+  // big picture" just above. Without a closed entry the word "overview"
+  // prose-matches real symbols in an indexed graph (moduleOverviewText) and
+  // the describe rescue dumps that symbol's card. The detailed forms ("give
+  // me a detailed overview of X") carry a mandatory "detailed"+of-term and
+  // stay with the completions rescue, untouched by this anchor. An explicit
+  // of-this-repo tail is NOT matched here: that names the repo as the
+  // subject, so ARCH_OVERVIEW_PHRASES answers it with the architecture map
+  // instead of this card.
+  /^(?:(?:can|could|would) you\s+)?(?:give me|show me|gimme)\s+an overview(?:\s+here)?\??$/i,
   /^an overview(?:\s+please)?\??$/i,
   // "what have we got here"/"what've we got here" — a casual, self-answering
   // opener (matches after a leading "so" strips via LEADING_CONNECTIVE_RE,
@@ -1563,15 +1573,8 @@ const BYE = new Set([
   "bye", "goodbye", "quit", "exit", "see ya", "see you", "cya", "later", "farewell",
   "peace", "peace out", "im off", "i'm off", "gtg", "gotta go", "catch you later",
   "farewell then",
-  // "gtg thx" — the SAME "gtg" farewell above, immediately followed by a
-  // thanks word with no delimiter between them (so farewellOrThanksSignal's
-  // comma/semicolon clause split never sees two clauses to work with).
-  // Whole-phrase entry rather than a general "bye word + thanks word, no
-  // delimiter" mechanism — closed and hand-curated, this exact reported
-  // phrasing only.
-  "gtg thx",
   // "good day to you" deliberately does NOT live here: it's a formal-register
-  // GREETING, not a farewell. foldedBye is checked before GREET in
+  // GREETING, not a farewell. farewellClause is checked before GREET in
   // conversationalTurn, so having it here would silently end the session on
   // a plain formal greeting — every turn piped after it dropped with no log
   // entry, a worse outcome than any wall.
@@ -1677,15 +1680,39 @@ const CLAUSE_SPLIT_RE = /\s*[,;]\s*(?:and\s+)?|\s+and\s+/;
 function conversationalClauses(q) {
   return q.split(CLAUSE_SPLIT_RE).map((c) => c.trim()).filter(Boolean);
 }
-/** BYE match tolerant of informal reduplication ("bye bye", "no no" — general,
- *  not specific to any one word): a clause consisting of the SAME word twice
- *  folds to one instance before the ordinary closed/collapsed BYE lookup.
- *  Shared by the single-clause whole-line check and the multi-clause scan
- *  below, so "bye bye" resolves the same way whether or not a comma follows it. */
-function foldedBye(clause) {
+/** A thanks phrase and a bye phrase butted together with NO delimiter between
+ *  them, in either order ("gtg thx", "thanks bye"). conversationalClauses
+ *  splits on a comma, semicolon or a standalone "and", so these lines arrive
+ *  as one clause and match neither closed set whole. Splitting at each word
+ *  boundary and matching the two halves against their own sets keeps both
+ *  halves closed — no new literal, and no phrase is recognized here that
+ *  isn't already recognized alone. Without this the leading thanks word reads
+ *  as a bare subject noun and the farewell reads as its verb, so "thanks bye"
+ *  parses as a habitual-teach ("a thank can bye"). */
+function gluedThanksBye(clause) {
+  const words = clause.split(/\s+/).filter(Boolean);
+  for (let split = 1; split < words.length; split += 1) {
+    const head = words.slice(0, split).join(" ");
+    const tail = words.slice(split).join(" ");
+    const headIsBye = !!closedOrCollapsed(head, BYE, BYE_COLLAPSED);
+    const tailIsBye = !!closedOrCollapsed(tail, BYE, BYE_COLLAPSED);
+    const headIsThanks = !!closedOrCollapsed(head, THANKS, THANKS_COLLAPSED);
+    const tailIsThanks = !!closedOrCollapsed(tail, THANKS, THANKS_COLLAPSED);
+    if ((headIsBye && tailIsThanks) || (headIsThanks && tailIsBye)) return true;
+  }
+  return false;
+}
+/** Does this clause end the session? The closed BYE set, or informal
+ *  reduplication of one of its entries ("bye bye", "no no" — general, not
+ *  specific to any one word), or a thanks word glued to a bye word. Shared by
+ *  the single-clause whole-line check and the multi-clause scan below, so
+ *  "bye bye" resolves the same way whether or not a comma follows it. Bye wins
+ *  over thanks: a farewell should end the session even alongside gratitude. */
+function farewellClause(clause) {
   if (closedOrCollapsed(clause, BYE, BYE_COLLAPSED)) return true;
   const folded = clause.match(REPEATED_WORD_RE);
-  return !!(folded && closedOrCollapsed(folded[1], BYE, BYE_COLLAPSED));
+  if (folded && closedOrCollapsed(folded[1], BYE, BYE_COLLAPSED)) return true;
+  return gluedThanksBye(clause);
 }
 /** Closing-filler clauses — the CONTENT half of a farewell/thanks sentence
  *  ("thanks, that's everything for now") that isn't itself gratitude or bye
@@ -1739,7 +1766,7 @@ function farewellOrThanksSignal(raw, q) {
     const rawClause = clauses[i];
     const ackMatch = rawClause.match(ACK_LEAD_RE);
     const clause = ackMatch ? ackMatch[1].trim() : rawClause;
-    if (foldedBye(clause)) { byeHit = true; break; }
+    if (farewellClause(clause)) { byeHit = true; break; }
     const deIntensified = clause.replace(THANKS_HELP_TAIL_RE, "").replace(TRAILING_INTENSIFIER_RE, "").trim();
     if (thanksClauseIdx < 0 && closedOrCollapsed(deIntensified, THANKS, THANKS_COLLAPSED)) thanksClauseIdx = i;
   }
@@ -1877,9 +1904,9 @@ function conversationalTurn(line, ctx) {
       ...(end ? { end: true } : {}),
     }, ctx.trace);
   };
-  if (foldedBye(q)) {
+  if (farewellClause(q)) {
     note(ctx.trace, "goal: casual/social — ending the session (no graph intent)");
-    note(ctx.trace, "lane: conversational — farewell (BYE closed set, incl. bare reduplication e.g. \"bye bye\")");
+    note(ctx.trace, "lane: conversational — farewell (BYE closed set, incl. bare reduplication e.g. \"bye bye\" and a thanks word glued to a bye word e.g. \"thanks bye\")");
     return mk(t(T_FAREWELL), { end: true });
   }
   {
@@ -6696,7 +6723,7 @@ function suggestibleSubjectPhrase(subject) {
  *  take the article. */
 const QUANTIFIER_LEAD_RE = /^(?:every|each|all|any)\s+/i;
 
-function factTermVariants(normFactTerm, term) {
+export function factTermVariants(normFactTerm, term) {
   const t = normFactTerm(term);
   const v = new Set();
   // The ask frames glue a quantifier onto the subject and looked up "every
@@ -8440,7 +8467,7 @@ const CARD_EXISTENCE_ASK_RE = /^does\s+an?\s+(.+?)\s+have\s+an?\s+(.+?)[?.!\s]*$
 /** The 4 pattern-5 cardinality-restriction predicates buildCardinalityRestrictions
  *  reconstructs from — owl:onProperty (shared scaffolding with someValuesFrom
  *  restrictions too) is added alongside this set by each reader below, not
- *  folded into it here, mirroring infbench/grade.mjs's own identically-named
+ *  folded into it here, mirroring test-benchmarks/infbench/grade.mjs's own identically-named
  *  set + separate owl:onProperty handling. */
 const CARDINALITY_ROW_PREDICATES = new Set(["owl:cardinality", "owl:minCardinality", "owl:maxCardinality", "owl:onClass"]);
 /** "who owns <X>" / "who maintains <X>" — the closed ownership read-back over
@@ -11215,7 +11242,7 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
   const definition = (await seonDefinitions()).get(term) ?? null;
   if (!definition) return null;
   // The runChat shell hands the loaded graph straight in; the pure runTurn(config)
-  // path (tests, chatbench) does not, so load it the same way dispatchTool does when
+  // path (tests, test-benchmarks/chatbench) does not, so load it the same way dispatchTool does when
   // it's missing. Failure-tolerated: no loadable graph → no concept force.
   let g = graph;
   if (!g && config && source) {
@@ -11984,6 +12011,15 @@ const MOVE_HISTORY_RE = /^where\s+did\s+(.+?)\s+(?:move|get\s+moved|go)(?:\s+to)
  *  the honest miss. */
 const TEMPORAL_COMPARISON_RE = /^(?:was|is)\s+(this one|that one|it|this|that)\s+(before|after)\s+(.+?)\s+(?:was|were)\s+(touched|changed|modified|edited|updated)[?.!\s]*$/i;
 
+/** "were those before logger.mjs was touched" — the plural sibling of
+ *  TEMPORAL_COMPARISON_RE. A plural bindable form (`those`/`them`/`these`)
+ *  binds a `set` referent a listing/filter answer established, and the
+ *  comparison runs over the whole set: each member is dated from the graph,
+ *  and the answer quantifies (all / none / M of N) rather than forcing one
+ *  date. A set whose members are not all datable refuses, the same honest
+ *  miss the singular lane takes on an undated referent. */
+const PLURAL_TEMPORAL_COMPARISON_RE = /^(?:were|are)\s+(those|them|these)\s+(before|after)\s+(.+?)\s+(?:was|were)\s+(touched|changed|modified|edited|updated)[?.!\s]*$/i;
+
 /** ARCHITECTURE-OVERVIEW intent — "show me the architecture", "what is the
  *  architecture of this repo": the whole-repo map the /arch command renders.
  *  A closed phrase set, because the literal word "architecture" is also a
@@ -11994,12 +12030,17 @@ const TEMPORAL_COMPARISON_RE = /^(?:was|is)\s+(this one|that one|it|this|that)\s
  *  an of-this-repo tail, or an overview/map noun); a query that NAMES a
  *  symbol ("describe renderArchitecture") never matches. */
 const ARCH_OVERVIEW_LEAD = "(?:(?:can|could|would)\\s+you\\s+(?:please\\s+)?)?(?:(?:show|give)\\s+(?:me|us)\\s+|describe\\s+|explain\\s+|what(?:'s|s|\\s+is)\\s+)?";
-const ARCH_OVERVIEW_TAIL = "(?:\\s+(?:of|for)\\s+(?:this|the)\\s+(?:app|codebase|repo|repository|project|code))?";
+const ARCH_OVERVIEW_OF_REPO = "(?:of|for)\\s+(?:this|the)\\s+(?:app|codebase|repo|repository|project|code)";
+const ARCH_OVERVIEW_TAIL = `(?:\\s+${ARCH_OVERVIEW_OF_REPO})?`;
 const ARCH_OVERVIEW_PHRASES = [
   // Article-carried: "the architecture" alone, or wrapped/tailed.
   new RegExp(`^${ARCH_OVERVIEW_LEAD}the\\s+architecture(?:\\s+(?:overview|map|diagram))?${ARCH_OVERVIEW_TAIL}(?:\\s+here)?\\??$`, "i"),
   // Article-less: anchored by the of-this-repo tail or the overview/map noun instead.
-  new RegExp(`^${ARCH_OVERVIEW_LEAD}architecture\\s+(?:(?:of|for)\\s+(?:this|the)\\s+(?:app|codebase|repo|repository|project|code)|overview|map|diagram)\\??$`, "i"),
+  new RegExp(`^${ARCH_OVERVIEW_LEAD}architecture\\s+(?:${ARCH_OVERVIEW_OF_REPO}|overview|map|diagram)\\??$`, "i"),
+  // Architecture-less: the topic noun stands in for the word, so the of-this-repo
+  // tail is REQUIRED here. A bare "give me an overview" names no subject and
+  // falls through to the ordinary lanes.
+  new RegExp(`^${ARCH_OVERVIEW_LEAD}(?:(?:an?|the)\\s+)?(?:overview|map|diagram)\\s+${ARCH_OVERVIEW_OF_REPO}(?:\\s+here)?\\??$`, "i"),
 ];
 
 async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null, discourseHolder = null, gameConfig = DEFAULT_GAME_CONFIG, liveReference = false, onLiveLookup = null, uiContext = "cli", synthesisBudget = AUTO_SYNTHESIS_BUDGET }) {
@@ -12012,9 +12053,19 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
   // ask()'s `prev`. Prefers the FULL id set (`allIds`) over `matches`, since a
   // concept-force listing caps `matches` at MAX_EXAMPLES.
-  const prev = (last?.detail?.allIds && last.detail.allIds.length)
+  let prev = (last?.detail?.allIds && last.detail.allIds.length)
     ? last.detail.allIds.filter(Boolean)
     : (last?.detail?.matches || []).map((m) => m?.id).filter(Boolean);
+  // A count erases its own matches to [], so the previous turn carries no id
+  // set for the next "which of those" to narrow. When the carry is empty, fall
+  // back to the session record: a standing `set` referent that "those" binds
+  // keeps a narrowed set alive across a counting hop. No same-turn plural tie
+  // is reachable yet (no lane registers two set referents in one turn), so this
+  // probe needs no tie refusal.
+  if (!prev.length && discourseHolder) {
+    const boundSet = bindDiscourseForm(discourseHolder.record, "those");
+    if (boundSet?.referent?.ids?.length) prev = boundSet.referent.ids.filter(Boolean);
+  }
   // The query the ENGINE parses: a "what about X" continuation is rewritten to the
   // prior shape with X swapped in; everything else parses verbatim. The record and
   // transcript keep the user's ACTUAL words (`query`), only the parse target changes.
@@ -12055,7 +12106,11 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         note(trace, `lane: TEMPORAL_COMPARISON_RE — "${form}" could not compose a comparison; a specific miss names why, never the teach-offer cascade`);
         return plainTurn(query, text, { via: "miss", miss: true, focus, goal: temporalGoal });
       };
-      const bound = discourseHolder ? bindDiscourseForm(discourseHolder.record, form) : null;
+      const bound = discourseHolder ? bindDiscourseForm(discourseHolder.record, form, { tieRefuses: true }) : null;
+      if (bound?.tie) {
+        const options = joinOr(bound.tie.map((r) => r.label));
+        return refMiss(`"${form}" could mean ${options} — which do you mean?`);
+      }
       if (!bound?.referent) {
         return refMiss(`I don't have a referent for "${form}" yet — nothing answered earlier in this conversation binds it. Ask about the event first (e.g. "when was ${clauseSubject} last ${verb}"), then ask the comparison again.`);
       }
@@ -12087,6 +12142,80 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       return turn;
     }
   }
+  // TEMPORAL COMPARISON OVER A PLURAL ANTECEDENT — "were those before
+  // logger.mjs was touched": the plural sibling of the block above. `those`
+  // binds a `set` referent a prior listing/filter established, and the whole
+  // set is compared against the freshly read clause date. Each member is dated
+  // from the graph (the set referent carries member ids, not per-member dates,
+  // so the dates are read here the same way the clause is read fresh), and the
+  // answer quantifies over the set — all, none, or M of N — rather than
+  // forcing the set onto a single date. A set whose members are not all
+  // datable refuses honestly, and an unbound form, an undatable clause, or a
+  // missing graph keep today's miss, the same specific declines the singular
+  // lane makes. Checked here, before the ask engine, for the same reason the
+  // singular lane is: otherwise "those before logger.mjs was" reaches the
+  // keyword-spot strategy as multi-token patient wreckage and the teach-offer
+  // cascade reads it as a subject to learn facts about.
+  {
+    const cmp = String(query).trim().match(PLURAL_TEMPORAL_COMPARISON_RE);
+    if (cmp) {
+      const [, form, cmpOp, clauseSubject, participle] = cmp;
+      const verb = participle.toLowerCase();
+      const temporalGoal = "compare a prior answer's dated set against a freshly read event (cross-turn temporal composition over a plural antecedent)";
+      const refMiss = (text) => {
+        note(trace, `goal: ${temporalGoal}`);
+        note(trace, `lane: PLURAL_TEMPORAL_COMPARISON_RE — "${form}" could not compose a set comparison; a specific miss names why, never the teach-offer cascade`);
+        return plainTurn(query, text, { via: "miss", miss: true, focus, goal: temporalGoal });
+      };
+      const bound = discourseHolder ? bindDiscourseForm(discourseHolder.record, form, { tieRefuses: true }) : null;
+      if (bound?.tie) {
+        const options = joinOr(bound.tie.map((r) => r.label));
+        return refMiss(`"${form}" could mean ${options} — which set do you mean?`);
+      }
+      if (!bound?.referent) {
+        return refMiss(`I don't have a set for "${form}" yet — nothing answered earlier in this conversation binds it. Ask for the set first (e.g. "what changed before <commit>"), then ask the comparison again.`);
+      }
+      const set = bound.referent;
+      const total = set.ids.length;
+      if (!graph) {
+        return refMiss(`"${form}" refers to ${set.label}, but I need a code graph to date its members and when ${clauseSubject} was last ${verb} — no code graph is loaded.`);
+      }
+      const dateOfId = (id) => {
+        const ind = graph.byId?.get?.(id);
+        return ind ? String((ind.attributes || []).find((a) => a.key === "date")?.value || "").slice(0, 10) : "";
+      };
+      const memberDates = set.ids.map(dateOfId);
+      const undated = memberDates.filter((d) => !d).length;
+      if (undated) {
+        return refMiss(`"${form}" refers to ${set.label}, but not every member carries a date I can compare — ${undated} of the ${total} have no date on record, so I can't place the set before or after ${clauseSubject} was ${verb}.`);
+      }
+      const { ask } = await import("../domain/ask.mjs");
+      const fresh = ask(graph, `when was ${clauseSubject} ${participle}`);
+      const freshHit = (!fresh?.tmct_ask?.miss && !fresh?.tmct_ask?.ambiguous) ? fresh?.tmct_ask?.matches?.[0] : null;
+      const freshCommit = freshHit?.id ? graph.byId?.get?.(freshHit.id) : null;
+      const clauseDay = freshCommit?.class === "Commit"
+        ? String((freshCommit.attributes || []).find((a) => a.key === "date")?.value || "").slice(0, 10)
+        : "";
+      if (!clauseDay) {
+        return refMiss(`"${form}" refers to ${set.label}, but I couldn't date when ${clauseSubject} was last ${verb} in this index — so I can't compare the set to it.`);
+      }
+      const before = cmpOp.toLowerCase() === "before";
+      const satisfied = memberDates.filter((d) => before ? d < clauseDay : d > clauseDay).length;
+      const relation = before ? "came before" : "came after";
+      const tail = `${clauseSubject} was last ${verb} (${freshCommit.label}, ${clauseDay})`;
+      const text = satisfied === total
+        ? `Yes — all ${set.label} ${relation} ${tail}.`
+        : satisfied === 0
+          ? `No — none of the ${set.label} ${relation} ${tail}.`
+          : `Partly — ${satisfied} of the ${set.label} ${relation} ${tail}; the other ${total - satisfied} did not.`;
+      note(trace, `goal: ${temporalGoal}`);
+      note(trace, `lane: PLURAL_TEMPORAL_COMPARISON_RE — "${form}" bound ${set.label} (${total} dated members) through the discourse record; ${satisfied}/${total} ${relation} the freshly read clause (${clauseDay})`);
+      const turn = plainTurn(query, text, { via: "composed", miss: false, focus, goal: temporalGoal });
+      const cited = [...set.ids.map((id) => graph.byId?.get?.(id)), freshCommit].filter(Boolean);
+      turn.detail = { traversal: `discourse ${set.ref} (${total} members) vs last-${verb} of ${clauseSubject} (${clauseDay})`, matches: cited };
+      return turn;
+    }
+  }
   // RENAME HISTORY — "what was X called before" and its siblings. The index
   // records current names only, and without this gate "called" fuzzes onto
   // the calls relation ("before" simply drops), so the reply read as fluent
@@ -12272,10 +12401,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // content is still typed) register into the session's record here — the
     // one point both ask paths (direct call and dispatchTool) converge.
     if (discourseHolder && Array.isArray(envelope?.discourse)) {
-      for (const { lane, ...spec } of envelope.discourse) {
+      for (const { lane, bound, ...spec } of envelope.discourse) {
         discourseHolder.record = registerReferent(discourseHolder.record, {
           ...spec, from: { turn: discourseHolder.record.turn, lane, query: askQuery },
-        });
+        }, { bound: !!bound });
       }
     }
   } catch (e) {
@@ -14126,6 +14255,10 @@ function matchImpactIntent(line) {
   return null;
 }
 const joinList = (a) => (a.length > 1 ? `${a.slice(0, -1).join(", ")} and ${a[a.length - 1]}` : (a[0] ?? ""));
+// A discourse tie lists its options with a short Oxford-comma "or" join,
+// deliberately not the resolver's longer numbered ambiguity format.
+const joinOr = (a) => (a.length > 2 ? `${a.slice(0, -1).join(", ")}, or ${a[a.length - 1]}`
+  : a.length === 2 ? `${a[0]} or ${a[1]}` : (a[0] ?? ""));
 
 /** Render the next page of a held remainder (pending: {items:[str], noun}). Returns a
  *  plain turn whose `detail.pending` carries what's still unseen (null when the batch
@@ -14813,7 +14946,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // otherwise read as a declarative or an orientation ask.
   {
     const advTurn = await adventureTurn(workingLine, {
-      planHolder, memoryDir, sessionId, env, lexicon, graph, cache: factRowsCache, isPlanFrameLine,
+      planHolder, memoryDir, sessionId, env, lexicon, graph, cache: factRowsCache, isPlanFrameLine, discourseHolder,
     });
     if (advTurn) {
       note(trace, `lane: ${advTurn.note}`);

package/src/services/index.mjs

@@ -6,7 +6,7 @@
 // ask.mjs keeps the core primitives (resolveObject, traverse, render) and
 // the ask() orchestration.
 
-// Chat surface (also reachable as the `./chat` subpath export).
+// Chat surface.
 // createSession is the library's session sink — the same focus/last/planState
 // threading and memory-backend seam every shell shares; runTurn is the pure
 // single-turn engine underneath it.
@@ -35,6 +35,9 @@ setConstructionBanks(readConstructionFiles);
 // Graph traversal primitives.
 export { relationKind, impactClosure } from "../domain/codegraph.mjs";
 
+// Graph-service construction for a provider-supplied code graph.
+export { createGraphService } from "../adapters/providers/graph-service.mjs";
+
 // Tool dispatch (slash-commands and CLI tool calls route through here).
 export { dispatchTool } from "../tools/server.mjs";
 
@@ -49,13 +52,13 @@ export { foldSessionLogs } from "./fold.mjs";
 // fetchEntities() is the one read path.
 export { fetchEntities, registerProvider } from "../adapters/source.mjs";
 
-// `tmct init` onboarding (also reachable as the `./init` subpath export).
+// `tmct init` onboarding.
 // init.mjs and toml-config.mjs each export a same-named `CONFIG_FILE`
 // constant ("tmct.toml") — aliased here so both can ride the one `.` entry
 // point without colliding.
 export { initRepo, defaultConfig, renderTomlConfig, PERSONA_PRESETS, CONFIG_FILE as INIT_CONFIG_FILE } from "./init.mjs";
 
-// tmct.toml loading (also reachable as the `./toml-config` subpath export).
+// tmct.toml loading.
 export { CONFIG_FILE as TOML_CONFIG_FILE } from "../adapters/toml-config.mjs";
 
 // The "detailed answer" completions pipeline (also reachable as the

package/src/services/ledger-viz.mjs

@@ -795,7 +795,7 @@ ${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` :
   // LEDGER (declared "let" in the embed script above this one — a classic,
   // non-module script's top-level bindings are reachable as bare identifiers
   // by every later script tag in the document, never as window.LEDGER; see
-  // e2e/pages-ledger.test.mjs's own note on this) and its indexes start as
+  // test-e2e/pages-ledger.test.mjs's own note on this) and its indexes start as
   // the server-rendered snapshot but are REASSIGNED wholesale after a live
   // teach (applyLedgerData, below) — a successful teach through the dock
   // changes the underlying graph, and the page has to show that, not keep

package/src/surfaces/web/chat-browser-entry.mjs

@@ -20,7 +20,7 @@
 //     Under the bundle build, scripts/build-chat-bundle.mjs swaps that import
 //     for a live in-memory twin, and this call actually feeds it the page's
 //     embedded structure rows; this file is ALSO imported directly by plain
-//     Node (e2e/web-chat-memory.test.mjs, exercising the same engine contract
+//     Node (test-e2e/web-chat-memory.test.mjs, exercising the same engine contract
 //     without a browser), where the import resolves to the real fs+TOML
 //     adapter — its own setDigestStructures is a documented no-op there
 //     (see that module's header), so the call is harmless either way, never

package/src/surfaces/web/digest-client.mjs

@@ -14,7 +14,8 @@
 
 import { buildStructureTable, digestTerm } from "../../domain/digest/index.mjs";
 import { digestStoreStats, chainsForObjects, isaObjectsOf } from "../../domain/digest/store-stats.mjs";
-import { readFactRows } from "../../adapters/memory/core.mjs";
+import { readFactRows, normFactTerm } from "../../adapters/memory/core.mjs";
+import { factTermVariants } from "../../services/chat.mjs";
 
 /**
  * Digest one term end to end from fact rows and a pre-parsed structure table.
@@ -40,14 +41,18 @@ export function digestTermFromRowsBrowser(term, termRows, allRows, structures, o
  * in-browser surface already holds (the ledger's embedded PAYLOAD, the ledger
  * dock's live memoryDir.payload, the research session's store). Scans the
  * payload once for the term's own rows and the whole-store statistics, so a
- * caller never has to run readFactRows itself.
+ * caller never has to run readFactRows itself. Matches `term` against a fact's
+ * subject through the same spelling-variant fold `factTermVariants` gives the
+ * "what is X" fact reader (plural/irregular-plural folding), so a term seeded
+ * as "dog" is still found when queried as "dogs".
  *
  * Returns the render-ready view (see digestViewFromArticle) or null when the
  * term has no rows, no structures were supplied, or the selector kept nothing.
  */
 export function digestTermFromPayloadBrowser(payload, term, structures, opts = {}) {
   const rows = readFactRows(payload || { individuals: [], objectProperties: [] });
-  const termRows = rows.filter((r) => r.subject === term);
+  const variants = factTermVariants(normFactTerm, term);
+  const termRows = rows.filter((r) => variants.has(r.subject));
   if (!termRows.length) return null;
   const article = digestTermFromRowsBrowser(term, termRows, rows, structures, opts);
   return digestViewFromArticle(article);

package/src/surfaces/web/graph-ask-browser-entry.mjs

@@ -0,0 +1,41 @@
+// graph-ask-browser-entry.mjs — the public, browser-safe entry point for
+// tmct's CODE-graph query engine (`./ask-browser` package export).
+//
+// A plain re-export, zero side effects, zero `globalThis` assignment: unlike
+// this directory's other *-browser-entry.mjs files (built into an IIFE and
+// inlined into a specific tmct page), this one is meant to be imported by a
+// DOWNSTREAM consumer's own bundler (e.g. seonix's website chat panel) as a
+// genuine ESM module, not inlined by tmct's own build scripts.
+//
+// It exists because the package root (`src/services/index.mjs`, and its
+// `.`/exports subpath) also runs Node-side composition wiring at module-load
+// time — `setDefaultNlpAdapter(nlpAdapter)` from `../adapters/ask-nlp.mjs`
+// (wink-nlp, a ~4MB model) and `setConstructionBanks(readConstructionFiles)`
+// from `../adapters/corpus/construction-banks.mjs` (fs reads) — neither of
+// which can run or bundle in a browser. This file imports only ask.mjs and
+// graph-service.mjs directly, so none of that wiring is reachable from here.
+//
+// Verified with `esbuild --bundle --platform=browser --format=esm`
+// (scripts/verify-ask-browser-entry.mjs). ask()'s optional strategies
+// (ace.mjs, constructions.mjs) and the wink lemma/POS adapter are all reached
+// through nlp-registry.mjs's `defaultNlp()` registry seam and each call
+// site's own `typeof X !== "undefined"` guard, not a static import, so a
+// consumer bundling this entry point alone never links wink-nlp or any
+// fs-reading corpus module — none of the ask-nlp.mjs/ace.mjs/
+// constructions.mjs/construction-banks.mjs/digest-bank.mjs family of stubs
+// scripts/build-ask-bundle.mjs needs for chat.mjs is required here.
+//
+// One real gap remains: `createGraphService` pulls in source-slice.mjs,
+// which imports `node:path` (join/resolve/sep) for span math, so a browser
+// bundler with no Node shims will fail on that one specifier. Apply the
+// same generic `stubNodeBuiltins` plugin scripts/lib/browser-bundle.mjs
+// already exports for tmct's own bundles (or an equivalent node:path shim —
+// e.g. esbuild's own `--define`/polyfill options, or a bundler that already
+// ships a node:path shim, as most do). Re-run
+// `node scripts/verify-ask-browser-entry.mjs` (clean) and
+// `node scripts/verify-ask-browser-entry.mjs --with-stubs` (with the shim)
+// after touching ask.mjs's or graph-service.mjs's import graph — if the
+// no-stub run ever passes clean, or a new specifier shows up, update this
+// comment to match what esbuild actually reports.
+export { ask, resolveObject } from "../../domain/ask.mjs";
+export { createGraphService } from "../../adapters/providers/graph-service.mjs";