@polycode-projects/the-mechanical-code-talker 2.7.0 → 2.7.1

package/README.md

@@ -369,6 +369,51 @@ asserts the plan is exactly 2^n − 1 moves every time, and a second game
 conjunction) solves with zero interpreter changes. `--render blocks` writes
 the plan as a self-contained animated page (see "Two more surfaces" above).
 
+## Play a game with it
+
+Two games run inside an ordinary chat session, no setup.
+
+**Guess the number.** Say `I'm thinking of a number between 1 and 100` and
+tmct guesses by narrowing an interval — answer `higher`, `lower`, or
+`correct`. It finds any number in at most 7 guesses, and if your answers
+contradict each other it names the contradicting pair and stops rather than
+guessing on. Say `think of a number` to swap seats: tmct commits to a secret
+and answers your guesses honestly, reveals on request, and corrects you from
+its own record if you claim it already said `correct`. The behaviour is
+pinned by `test/corpus/games/guess-number.jsonl`, and the home page's demo
+rail plays the guesser side live in your browser.
+
+**A text adventure.** Say `start the adventure` (or `play ashcombe hall`)
+and tmct loads a small country-house mystery from a lazily-fetched worlds
+pack (`corpus/worlds/`) into the session's ordinary memory graph — rooms,
+objects and people become graph facts, and the verbs (`go`, `take`, `open`,
+`unlock`, `look`…) are taught action rules, not hard-wired code. Every move
+writes per-turn snapshot facts, `look` is an extractive digest of the graph,
+a blocked action declines by name, and one of the household moves on its own
+schedule whether you are there to see it or not. The full worked mystery is
+pinned step by step in `test/corpus/games/adventure.jsonl`.
+
+## Learning on a miss
+
+A question tmct cannot ground is still an honest miss — but on the cleanest
+kind of miss (a recognised word, a clean parse, simply no facts anywhere) it
+now consults two shipped, lazily-loaded packs before giving up:
+
+- `corpus/child/` — 93k everyday-world triples filtered from ConceptNet by a
+  child-concept seed. Asked `what is a kettle` cold, tmct loads the term's
+  triples into memory (provenance `child:conceptnet:kettle`, ranked below
+  anything you teach) and answers from them; the next ask answers from
+  memory directly.
+- `corpus/reference/` — 3,887 Simple English Wikipedia summaries. When the
+  triples cannot answer, a matching article answers as a cited read-out
+  (`source: reference article "Otter"…, CC BY-SA 4.0`).
+
+Facts first, prose second; if neither pack carries the term, the turn is the
+same honest miss it always was, byte for byte. An unknown word, a parse
+failure, or an ambiguous reading never consults a pack at all. The gate and
+both fallbacks are pinned by `test/corpus/reference.jsonl` and the
+chat-lane tests beside it, and the home page demos the article path live.
+
 ## How it remembers
 
 tmct's memory has two layers, both fed by every parsed request and response and
@@ -922,7 +967,7 @@ The remaining tools are **cold**: still served, but not billed to an agent every
 | --- | --- | --- |
 | `tmct_describe` | Locate one symbol and list its typed edges (both directions) with provenance. | `symbol` (required) |
 | `tmct_signature` | One symbol's API surface (params, returns, raises/catches, flags, decorators, doc) without the body. | `symbol` (required) |
-| `tmct_impact` | Transitive reverse closure over imports/calls — what breaks if a module changes, by depth, with tests. | `module` (required) |
+| `tmct_impact` | Transitive reverse closure over imports/calls — what breaks if a module or symbol changes, by depth, with tests. | `module` (required) |
 | `tmct_search` | Free-text/ranked lookup over the code-map to find the right module or symbol. | `query`, `kind`, `decorator`, `name` |
 | `tmct_members` | A class's methods + attributes (file:line, decorators) in one slice. | `class` (required) |
 | `tmct_subclasses` | A class's base classes plus the transitive set of classes that extend it. | `class` (required) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "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.",

package/src/domain/ask-vocab.mjs

@@ -466,12 +466,20 @@ export const PLACEHOLDER_NOUNS = Object.freeze([
 
 /** Boolean connectives over same-subject clauses -> a set operation on result ids.
  *  "and" = intersection, "or" = union, "but not"/"and not"/"without"/"except" =
- *  difference. Multi-word keys are matched longest-first by ask.mjs so "but not"
- *  wins over a bare "not". Left-associative in ask.mjs's fold. */
+ *  difference. The do-support negations ("but do not import Y", the expanded
+ *  form every "don't" reaches after the contraction pass) are difference too —
+ *  the auxiliary is part of the connective, never of the branch. A bare "but"
+ *  is contrastive coordination, which still intersects ("inheriting from X but
+ *  untested" = both at once). Multi-word keys are matched longest-first by
+ *  ask.mjs so "but do not" wins over "but not" wins over a bare "but".
+ *  Left-associative in ask.mjs's fold. */
 export const BOOLEAN_CONNECTIVES = Object.freeze({
+  "but do not": "difference", "but does not": "difference",
+  "and do not": "difference", "and does not": "difference",
   "but not": "difference", "and not": "difference", "except": "difference",
   "without": "difference",
   "and": "intersection", "plus": "intersection",
+  "but": "intersection",
   "or": "union",
 });
 

package/src/domain/ask.mjs

@@ -437,6 +437,12 @@ function parseNested(w, lc, nlp, depth) {
     if (!noun) continue;                            // marker not preceded by a noun
     const head = w.slice(0, r - 1);                 // outer clause words, minus the placeholder noun
     if (!head.length) continue;                     // noun is the leading subject → subject-relative, not this shape
+    // A head made ENTIRELY of qualifier adjectives ("tested modules importing
+    // X") is an adjective stack over the subject, not an outer clause —
+    // "tested" doubles as a relation verb, so parseSimpleClause would read it
+    // as reverse(tests) over the inner set and answer the test module itself.
+    // parseRelationalOrQualified owns the adjective reading.
+    if (head.every((x) => QUALIFIERS[x.toLowerCase()])) continue;
     const outer = parseSimpleClause([...head, NEST_SENTINEL].join(" "), nlp);
     if (!outer || (outer.shape !== "reverse" && outer.shape !== "forward")) continue;
     if (outer.modifier && outer.modifier !== "direct") continue; // no transitive-over-set closure primitive

package/src/domain/interpret/normalize.mjs

@@ -8,7 +8,7 @@
 import {
   CONTRACTIONS, MISSPELLINGS, WRONG_WORDS, G_DROP, FILLER_WORDS,
   NEGATION_FRAMES, COMMIT_CONTENT_FRAMES, VERB_TO_KIND, ENTITY_TO_TYPE,
-  TRAILING_SCOPE_FILLER, TRAILING_TEMPORAL_ADVERBS,
+  TRAILING_SCOPE_FILLER, TRAILING_TEMPORAL_ADVERBS, stripTrailingDiscourseTag,
 } from "../ask-vocab.mjs";
 
 export function escapeRegex(s) {
@@ -251,18 +251,29 @@ export function applyPreambleFrames(text) {
   return q;
 }
 
-/** Strippable leading framing clause: "since/although/though/while/because/
- *  whereas/given that/now that <clause>, <Q>" -> "<Q>". Comma-anchored and
- *  non-empty-remainder-required, same discipline as GREETING_PREAMBLE_RE. */
+/** Strippable leading framing clause: "since/[even] though/although/while/
+ *  because/[even] if/whereas/given that/now that <clause>, <Q>" -> "<Q>".
+ *  Comma-anchored and non-empty-remainder-required, same discipline as
+ *  GREETING_PREAMBLE_RE. */
 const SUBORDINATION_FRAMES_RE =
-  /^(?:since|although|though|while|because|whereas|given\s+that|now\s+that)\s+.+?,\s*(.+)$/i;
+  /^(?:since|although|(?:even\s+)?though|while|because|whereas|given\s+that|now\s+that)\s+.+?,\s*(.+)$/i;
+
+/** The same framing clause TRAILING the question ("<Q>, because the sprint
+ *  just kicked off") — comma-anchored on the same subordinator set, so the
+ *  clause never reads as part of the object term. A bare "while"/"since"
+ *  mid-question without the comma is untouched (those can be content). */
+const TRAILING_SUBORDINATION_RE =
+  /^(.+?),\s*(?:since|although|(?:even\s+)?though|while|because|whereas|given\s+that|now\s+that)\s+.+$/i;
 
 export function applySubordinationFrames(text) {
   let q = String(text || "");
   for (let pass = 0; pass < 3; pass++) {
-    const m = q.match(SUBORDINATION_FRAMES_RE);
-    if (!m) break;
-    q = m[1].trim();
+    const before = q;
+    let m = q.match(SUBORDINATION_FRAMES_RE);
+    if (m) q = m[1].trim();
+    m = q.match(TRAILING_SUBORDINATION_RE);
+    if (m) q = m[1].trim();
+    if (q === before) break;
   }
   return q;
 }
@@ -390,6 +401,14 @@ export function normalizeQuery(text) {
   q = applySubordinationFrames(q);
   q = applyConditionalFrames(q);
   q = stripFillerWords(q);
+  // A trailing bare discourse tag ("which modules import a.mjs THEN") is
+  // conversational glue, not part of the object term — the same curated call
+  // ask-vocab's stripTrailingDiscourseTag already makes for the meta-whatis
+  // object. Stripped here, in the shared pre-pass and AFTER the filler strip
+  // (the noise wrappers that leave the tag behind sit at the other end), so
+  // both parse strategies see one string and the residue guard never has to
+  // refuse over a word that carried no content.
+  q = stripTrailingDiscourseTag(q);
   // emphatic trailing punctuation (item 10): a run of terminal "?" collapses to
   // one — the anchored templates consume exactly one optional trailing "?", so
   // "…walk.mjs??" otherwise leaks a stray "?" into the captured object term (the
@@ -485,6 +504,11 @@ const PHRASING_FRAMES = Object.freeze([
   { re: /^what\s+does\s+(.+?)\s+changes?\s+together\s+with\??$/i, to: (m) => `what co-changes with ${m[1]}` },
   { re: /^what\s+changes?\s+together\s+with\s+(.+?)\??$/i, to: (m) => `what co-changes with ${m[1]}` },
 
+  // COMMIT-COUNT PASSIVE ("how many commits are recorded for X") → the touch
+  // phrasing the count restrictor already compiles. "recorded" is no relation
+  // verb, so the passive otherwise dies in the restrictor parse.
+  { re: /^how\s+many\s+commits\s+(?:are|were)\s+(?:recorded|logged)\s+(?:for|against)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `how many commits touched ${m[1]}` },
+
   // AUTHORSHIP → "who touched X" (tmct's touch edge IS the authorship signal).
   // A commit sha object is excluded — that dumps the commit's touch-set, not its author.
   { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },

package/src/domain/memory/trust.mjs

@@ -35,6 +35,11 @@ function parseChatTagRest(rest) {
  *      same 0.7 prior, same shared Source as the bulk conceptnet import; the
  *      <term> segment records which miss pulled the fact in and is not part of
  *      the Source identity)
+ *   world:<name>[:turnN]       -> { kind:"corpus",   name:<name> }
+ *     (a loaded world's facts are first-party authored shipped content — the
+ *      same tier the hand-written tier2 corpus already scores at; the :turnN
+ *      segment a snapshot write carries records when, not who, and is not
+ *      part of the Source identity)
  *   ace:chat:<session>@<ts>    -> { kind:"operator",  createdAt:<ts>, sessionId:<session> }
  *   teach:chat:<session>@<ts>  -> { kind:"teach",     createdAt:<ts>, sessionId:<session> }
  *   web:<url> | url:<url>      -> { kind:"web",       url:<url> }
@@ -62,6 +67,10 @@ export function provenanceTagToSource(tag) {
   // child:<pack>:<term> — the lazy child triples pack, scored at the corpus tier
   // under the pack's shared Source; the per-term tail is dropped from the id.
   if (head.startsWith("child:")) return { kind: "corpus", name: head.slice("child:".length).split(":")[0] || "unknown" };
+  // world:<name>[:turnN] — a loaded world's facts and snapshots, first-party
+  // authored shipped content scored at the corpus tier; the per-turn tail is
+  // dropped from the id so every write of one world corroborates one Source.
+  if (head.startsWith("world:")) return { kind: "corpus", name: head.slice("world:".length).split(":")[0] || "unknown" };
   if (head.startsWith("ace:")) return { kind: "operator", ...parseChatTagRest(head.slice("ace:".length)) };
   if (head.startsWith("teach:")) {
     // the chat teach lane's natural frames — chat.mjs's teachProvenanceTag

package/src/services/adventure.mjs

@@ -13,7 +13,7 @@ import { parseImperative } from "../domain/grammar/ace.mjs";
 import { createCompletionsGraphAdapter } from "../domain/completions/graph-adapter.mjs";
 import { actionFamilies } from "../domain/router/taught.mjs";
 import { getWorldsPackProvider } from "../adapters/corpus/worlds-pack.mjs";
-import { appendFacts, appendRule, loadMemory, readFactRows, readRuleRows } from "../adapters/memory/core.mjs";
+import { appendFacts, appendRule, loadMemory, normFactTerm, readFactRows, readRuleRows } from "../adapters/memory/core.mjs";
 import { COMPLETIONS_STORE, generateCompletion } from "./completions.mjs";
 
 // ---- recognizers: the closed opening/stop set --------------------------------
@@ -579,6 +579,53 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
   );
 }
 
+// A mid-game "where is X" aside. Optional trailing "now": the question means
+// the same with or without it, and the fold IS the now.
+const WORLD_WHERE_RE = /^where(?:'s|\s+is|\s+are)\s+(?:the\s+|a\s+|an\s+)?(.+?)(?:\s+now)?[?.!\s]*$/i;
+
+/** A locative aside about a placed world thing, answered from the SAME @turnN
+ *  fold every other world reader uses — never the raw base rows, whose
+ *  superseded placements would answer where things stood at load time. Null
+ *  when the asked thing has no placement in the world, so an ordinary
+ *  locative question (a code symbol, a taught board piece) keeps its lane. A
+ *  hidden thing is declined without naming its hiding place. */
+async function worldWhereAnswer(line, { memoryDir }) {
+  const m = String(line).match(WORLD_WHERE_RE);
+  if (!m) return null;
+  const thing = normFactTerm(m[1]);
+  let rows;
+  try { rows = readFactRows(await loadMemory(memoryDir)); } catch { return null; }
+  const state = foldWorldState(rows);
+  const place = state.placements.get(thing);
+  if (!place) return null;
+  if (place.predicate === "mgx:hidden-in") {
+    return answer(
+      `nothing you've seen says where the ${thing} is.`,
+      `ADVENTURE — where-aside: ${thing} is hidden; declined without naming the hiding place`,
+      { miss: true, goal: `locate the ${thing}` },
+    );
+  }
+  if (thing === "player") {
+    return answer(
+      `you are in the ${place.object}.`,
+      "ADVENTURE — where-aside: the player's own room, from the current world fold",
+      { goal: "check where you are" },
+    );
+  }
+  if (place.object === "player") {
+    return answer(
+      `you are carrying the ${thing}.`,
+      `ADVENTURE — where-aside: ${thing} is carried, from the current world fold`,
+      { goal: `locate the ${thing}` },
+    );
+  }
+  return answer(
+    `the ${thing} is in the ${place.object}.`,
+    `ADVENTURE — where-aside: ${thing}'s current placement from the world fold (as of turn ${place.turn})`,
+    { goal: `locate the ${thing}` },
+  );
+}
+
 async function inventoryAnswer({ memoryDir, graph }) {
   const memory = await loadMemory(memoryDir);
   const rows = readFactRows(memory);
@@ -665,5 +712,7 @@ export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "
   if (INVENTORY_RE.test(line)) return inventoryAnswer({ memoryDir, graph });
   const cmd = parseImperative(line, lexicon ?? undefined);
   if (cmd) return runWorldCommand(cmd, { world: adventure.world, memoryDir, env, graph, cache });
+  const whereAside = await worldWhereAnswer(line, { memoryDir });
+  if (whereAside) return whereAside;
   return null; // a mid-game aside — the ordinary lanes answer, world untouched
 }

package/src/services/chat.mjs

@@ -48,6 +48,8 @@ import { loadLexicon, lookupNoun } from "../domain/grammar/lexicon.mjs";
 import { pickPhrase } from "../domain/answer-variants.mjs";
 import { REFERENCE_PACK_NAME, cleanMissReferenceTerm, renderReferenceAnswer, referenceProvenanceTag } from "../domain/reference-pack.mjs";
 import { getReferencePackProvider } from "../adapters/corpus/reference-pack.mjs";
+import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
+import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
 import { adventureTurn } from "./adventure.mjs";
@@ -2794,6 +2796,16 @@ const GENERAL_VERB_DETERMINER_TEACH_RE = new RegExp(
  *  stored, and cited, as "len"). */
 const QUANTIFIED_HAS_TEACH_RE = /^(every|each|all)\s+([\w'-]+)\s+(?:has|have)\s+(.+?)[.!?]*$/i;
 const quantifiedHasSubject = (m) => (/^all$/i.test(m[1]) ? singularizeSurface(m[2]) : m[2]);
+/** The OBJECT side of the same fold: "all dogs have tails" states one tail
+ *  per dog, so the plural sentence form's object stores as its singular
+ *  ("tail" — the spelling the have-questions and the seeded corpus's own hasA
+ *  facts read back). Only the "all" form folds, the same gate the subject
+ *  uses: "every"/"each" take singular grammar, so their object's number is
+ *  the speaker's own ("every dog has fur"). The last word folds so a
+ *  modified object ("all dogs have long tails") keeps its modifier. */
+const quantifiedHasObject = (m) => (/^all$/i.test(m[1])
+  ? m[3].replace(/[\w'-]+$/, (w) => singularizeSurface(w))
+  : m[3]);
 /** Verbs owned by an earlier, more specific recognizer in this lane — is/are
  *  (class-membership/property, above) and owns/maintains (ownership, above).
  *  generalVerbTeach declines outright on these so it can never race a more
@@ -2942,7 +2954,7 @@ async function generalVerbTeach(payload) {
     if (quantHas) {
       subjectRaw = quantifiedHasSubject(quantHas);
       verbRaw = "has";
-      objectRaw = quantHas[3];
+      objectRaw = quantifiedHasObject(quantHas);
     } else {
       const det = p.match(GENERAL_VERB_DETERMINER_TEACH_RE);
       if (!det) return null; // not a bare-name subject, and no preposition to pin the verb
@@ -9045,14 +9057,15 @@ async function curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon })
   return { text: `${def} (source: corpus/seon)`, term };
 }
 
-// ---- learn-on-miss: the shipped reference pack behind the cleanest miss ----
+// ---- learn-on-miss: the shipped child + reference packs behind the cleanest miss ----
 
-/** The learn-on-miss gate, shared by the articled miss hook and the bare-form
- *  fallback so the two can never disagree. Fires only on the CLEANEST miss: a
- *  definition-shaped term the lexicon knows, resolving to no graph entity and
- *  no remembered fact — then, and only then, the pack provider is consulted.
- *  Null means the turn proceeds byte-identically to a pack-less run. */
-async function referencePackMissAnswer(term, { graph, memoryDir, lexicon, env, cache }) {
+/** The learn-on-miss gate, shared by the child-pack hook, the articled
+ *  reference hook and the bare-form fallback so the three can never disagree.
+ *  Passes only on the CLEANEST miss: a definition-shaped term the lexicon
+ *  knows, resolving to no graph entity and no remembered fact — then, and
+ *  only then, may a pack provider be consulted. Null means the turn proceeds
+ *  byte-identically to a pack-less run. */
+async function cleanMissPackKey(term, { graph, memoryDir, lexicon, cache }) {
   if (!term || !memoryDir) return null;
   let key = null;
   try { key = cleanMissReferenceTerm(term, lexicon ?? undefined); } catch { key = null; }
@@ -9064,12 +9077,43 @@ async function referencePackMissAnswer(term, { graph, memoryDir, lexicon, env, c
   variants.add(key);
   const rows = await factRows(memoryDir, cache);
   if (rows.some((f) => variants.has(f.subject) || variants.has(f.object))) return null;
+  return key;
+}
+
+/** The reference-pack lookup for an already-gated key: the article, or null
+ *  (absent pack, missing term, any read failure — all byte-identical). */
+async function referencePackAnswerForKey(key, env) {
   let article = null;
   try { article = await getReferencePackProvider(env).lookup(key); } catch { article = null; }
   if (!article) return null;
   return { key, article, text: renderReferenceAnswer(key, article) };
 }
 
+/** The gate + the reference lookup in one call, for a caller that has a term
+ *  rather than a gated key. */
+async function referencePackMissAnswer(term, { graph, memoryDir, lexicon, env, cache }) {
+  const key = await cleanMissPackKey(term, { graph, memoryDir, lexicon, cache });
+  return key ? referencePackAnswerForKey(key, env) : null;
+}
+
+/** The child-pack half of learn-on-miss, for an already-gated key: look the
+ *  key up in the shipped child triples pack and append every fact under child
+ *  provenance, so the SAME question can be re-asked from the store. Null on a
+ *  pack miss or any failure — the turn then proceeds byte-identically. */
+async function childPackFactsForKey(key, { memoryDir, env, cache }) {
+  let row = null;
+  try { row = await getChildPackProvider(env).lookup(key); } catch { row = null; }
+  if (!row?.facts?.length) return null;
+  try {
+    const { appendFacts } = await import("../adapters/memory/core.mjs");
+    await appendFacts(memoryDir, row.facts.map(({ subject, predicate, object }) => ({
+      subject, predicate, object, provenance: childProvenanceTag(key),
+    })));
+  } catch { return null; }
+  if (cache) cache.rows = null;
+  return { key, count: row.facts.length };
+}
+
 /** Store the article's first-sentence isa as a subClassOf fact carrying
  *  reference provenance — AFTER the cited answer composed, and failure-
  *  tolerated: the answer stands whether or not the fact lands. */
@@ -10492,9 +10536,12 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // actually stores it, the ORIGINAL ask-engine answer is restored unchanged
   // (see "COLLISION RESTORE" below).
   const trimmedQuery = String(query).trim();
-  const relaxedTeachCollision = !!(envelope?.relaxed?.dropped?.length) && !askMiss && memoryDir
+  // Boolean() and not a bare && chain: with no memoryDir the chain would
+  // short-circuit to null, and `miss` below (askMiss || THIS) would record a
+  // null miss flag on every relaxation-rescued turn of a memory-less session.
+  const relaxedTeachCollision = Boolean(!!(envelope?.relaxed?.dropped?.length) && !askMiss && memoryDir
     && !QUESTION_LEAD_RE.test(trimmedQuery) && !/\?\s*$/.test(trimmedQuery)
-    && DECLARATIVE_KIND_OF_RE.test(trimmedQuery);
+    && DECLARATIVE_KIND_OF_RE.test(trimmedQuery));
   const preCollisionAnswer = relaxedTeachCollision ? answer : null;
   const miss = askMiss || relaxedTeachCollision;
   // Answer provenance (W1): "composed" is the ask engine's productive band; the
@@ -10789,13 +10836,23 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         const def = await curatedDefinitionAnswer(factQuery, envelope, { memoryDir, lexicon });
         if (def) bareMetaHit = { text: def.text, replace: true };
       }
-      // The reference pack's bare-form fallback, beside the curated one and
-      // under the IDENTICAL clean-miss gate the articled hook (4h) applies —
-      // "what is otter" reaches the pack exactly as "what is an otter" does.
+      // The learn-on-miss packs' bare-form fallback, beside the curated one
+      // and under the IDENTICAL clean-miss gate the articled hook (4h)
+      // applies — "what is otter" reaches the packs exactly as "what is an
+      // otter" does, child triples first, article prose second.
       if (!bareMetaHit) {
         const refTerm = metaTermOf(factQuery, envelope);
-        const ref = refTerm ? await referencePackMissAnswer(refTerm, { graph, memoryDir, lexicon, env, cache }) : null;
-        if (ref) bareMetaHit = { text: ref.text, replace: true, reference: ref };
+        const key = refTerm ? await cleanMissPackKey(refTerm, { graph, memoryDir, lexicon, cache }) : null;
+        const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache }) : null;
+        if (learned) {
+          const fact = (await factAnswer(memoryDir, factQuery, envelope, miss, biasByBundle, cache, newFocus?.label))
+            ?? (await factReadBack(memoryDir, factQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
+          if (fact && !fact.miss) bareMetaHit = { text: fact.text, replace: true, child: learned };
+        }
+        if (!bareMetaHit && key) {
+          const ref = await referencePackAnswerForKey(key, env);
+          if (ref) bareMetaHit = { text: ref.text, replace: true, reference: ref };
+        }
       }
     }
     // A bare "what is X" naming a REAL code-graph entity (not a taught fact,
@@ -10851,8 +10908,13 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     if (!bareMetaHit.miss) { via = "fact"; recordMiss = false; }
     handled = true;
     if (bareMetaHit.pending) factPending = bareMetaHit.pending;
-    note(trace, "lane: (2b) BARE META FACT — \"what is X\" (no article) / \"is X <adjective>\" resolved to a remembered fact before the conversational catch-all could claim it");
-    note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
+    if (bareMetaHit.child) {
+      note(trace, "lane: (2b) CHILD PACK — a bare \"what is X\" clean miss pulled the term's triples from the shipped child pack into memory, and the question was re-answered from the store");
+      note(trace, `source: child pack ${CHILD_PACK_NAME} — ${bareMetaHit.child.count} fact(s) appended as ${childProvenanceTag(bareMetaHit.child.key)}, answer served from .tmct/memory Facts`);
+    } else {
+      note(trace, "lane: (2b) BARE META FACT — \"what is X\" (no article) / \"is X <adjective>\" resolved to a remembered fact before the conversational catch-all could claim it");
+      note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
+    }
   } else if (isConversationalCandidate && habitualGroundingHint) {
     // A bare habitual teach ("penguins swim") naming a subject grounded
     // nowhere: an honest, actionable grounding hint beats the orientation
@@ -11212,22 +11274,40 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, `lane: (4g) FUZZY-VERB DECLINE — "${from}" only became a verb through the edit-distance repair tier ("${to}"), and the two words are different verbs, so the repaired sentence's graph answer is dropped rather than shown as an answer to what was typed`);
     }
   }
-  // (4h) REFERENCE PACK — the cleanest miss consults the shipped reference
-  // pack: a definition-shaped term the lexicon knows, no graph entity, no
-  // remembered fact. A hit answers with the article's summary, always cited;
-  // a null from any gate leaves the turn byte-identical. After the answer
-  // composes, the article's first-sentence isa is stored as a subClassOf fact
-  // with reference provenance, so the NEXT ask answers from memory.
+  // (4h) LEARN-ON-MISS PACKS — the cleanest miss consults the shipped packs:
+  // a definition-shaped term the lexicon knows, no graph entity, no
+  // remembered fact. The CHILD triples pack goes first (facts before prose):
+  // a hit appends the term's triples under child provenance and the SAME
+  // question is re-asked from the store, so the answer is an ordinary cited
+  // fact answer. Only when the store still cannot answer does the reference
+  // pack's article speak, cited as before. Both packs missing leaves the
+  // honest miss byte-identical.
   if (miss && recordMiss && via === "composed" && memoryDir) {
     const refTerm = metaTermOf(query, envelope);
-    const ref = refTerm ? await referencePackMissAnswer(refTerm, { graph, memoryDir, lexicon, env, cache }) : null;
-    if (ref) {
-      answer = ref.text;
-      via = "reference";
-      recordMiss = false;
-      note(trace, "lane: (4h) REFERENCE PACK — a clean miss on a lexicon term answered from the shipped reference pack, cited");
-      note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${ref.article.title}" (revid ${ref.article.revid})`);
-      await appendReferenceIsaFact(memoryDir, ref.key, ref.article, cache);
+    const key = refTerm ? await cleanMissPackKey(refTerm, { graph, memoryDir, lexicon, cache }) : null;
+    const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache }) : null;
+    if (learned) {
+      const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle, cache, newFocus?.label))
+        ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
+      if (fact && !fact.miss) {
+        answer = fact.replace ? fact.text : `${answer}\n${fact.text}`;
+        via = "fact";
+        recordMiss = false;
+        if (fact.pending) factPending = fact.pending;
+        note(trace, "lane: (4h) CHILD PACK — a clean miss on a lexicon term pulled the term's triples from the shipped child pack into memory, and the question was re-answered from the store");
+        note(trace, `source: child pack ${CHILD_PACK_NAME} — ${learned.count} fact(s) appended as ${childProvenanceTag(key)}, answer served from .tmct/memory Facts`);
+      }
+    }
+    if (miss && recordMiss && via === "composed" && key) {
+      const ref = await referencePackAnswerForKey(key, env);
+      if (ref) {
+        answer = ref.text;
+        via = "reference";
+        recordMiss = false;
+        note(trace, "lane: (4h) REFERENCE PACK — a clean miss on a lexicon term answered from the shipped reference pack, cited");
+        note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${ref.article.title}" (revid ${ref.article.revid})`);
+        await appendReferenceIsaFact(memoryDir, ref.key, ref.article, cache);
+      }
     }
   }
   // (5) #1 SHORT TAILORED MISS — replace ONLY the engine's full grammar cheat-sheet
@@ -12532,7 +12612,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     if (advTurn) {
       note(trace, `lane: ${advTurn.note}`);
       if (advTurn.goal) note(trace, `goal: ${advTurn.goal}`);
-      const result = plainTurn(workingLine, advTurn.text, { via: "game", focus });
+      const result = plainTurn(workingLine, advTurn.text, { via: "game", miss: !!advTurn.miss, focus });
       if (advTurn.goal) result.goal = advTurn.goal;
       result.lane = advTurn.lane;
       const rec = withLast(result, advTurn.goal ?? "play the adventure");

package/src/surfaces/web/memory-ask-browser.bundle.js

@@ -673,12 +673,17 @@
         "symbols"
       ]);
       BOOLEAN_CONNECTIVES = Object.freeze({
+        "but do not": "difference",
+        "but does not": "difference",
+        "and do not": "difference",
+        "and does not": "difference",
         "but not": "difference",
         "and not": "difference",
         "except": "difference",
         "without": "difference",
         "and": "intersection",
         "plus": "intersection",
+        "but": "intersection",
         "or": "union"
       });
       QUALIFIERS = Object.freeze({
@@ -985,6 +990,7 @@
     if (head.startsWith("corpus-weak:")) return { kind: "corpusWeak", name: head.slice("corpus-weak:".length) || "unknown" };
     if (head.startsWith("corpus:")) return { kind: "corpus", name: head.slice("corpus:".length) || "unknown" };
     if (head.startsWith("child:")) return { kind: "corpus", name: head.slice("child:".length).split(":")[0] || "unknown" };
+    if (head.startsWith("world:")) return { kind: "corpus", name: head.slice("world:".length).split(":")[0] || "unknown" };
     if (head.startsWith("ace:")) return { kind: "operator", ...parseChatTagRest(head.slice("ace:".length)) };
     if (head.startsWith("teach:")) {
       return { kind: "teach", ...parseChatTagRest(head.slice("teach:".length)) };
@@ -2752,9 +2758,12 @@ ${shown.join("\n")}${tail}`;
   function applySubordinationFrames(text) {
     let q = String(text || "");
     for (let pass = 0; pass < 3; pass++) {
-      const m = q.match(SUBORDINATION_FRAMES_RE);
-      if (!m) break;
-      q = m[1].trim();
+      const before = q;
+      let m = q.match(SUBORDINATION_FRAMES_RE);
+      if (m) q = m[1].trim();
+      m = q.match(TRAILING_SUBORDINATION_RE);
+      if (m) q = m[1].trim();
+      if (q === before) break;
     }
     return q;
   }
@@ -2799,6 +2808,7 @@ ${shown.join("\n")}${tail}`;
     q = applySubordinationFrames(q);
     q = applyConditionalFrames(q);
     q = stripFillerWords(q);
+    q = stripTrailingDiscourseTag(q);
     q = q.replace(/\?{2,}\s*$/, "?");
     return q.replace(/\s+/g, " ").trim();
   }
@@ -2824,7 +2834,7 @@ ${shown.join("\n")}${tail}`;
     if (!predicate) return null;
     return { entWord, predicate };
   }
-  var tableRe, CONTRACTION_RE, correctionRe, MISSPELLING_RE, WRONG_WORD_RE, W_SLASH_RE, FOR_DIGIT_THANKS_RE, FOR_DIGIT_EXAMPLE_RE, KIND_NOUN_ANAPHORA_RE, VERB_ALTERNATION, FILLER_RE, RELATION_VERB_RE, INTERROGATIVE_LEAD_RE, LISTING_TAIL_KINDS, BARE_KIND_RE, isListingRemainder, GREETING_PREAMBLE_RE, THANKS_PREAMBLE_RE, ACK_PREAMBLE_RE, BROWSING_PREAMBLE_RE, HEDGE_ADVERB_PREAMBLE_RE, TROUBLE_ASIDE_RE, MODAL_WRAPPER_RE, EXPLAIN_WRAPPER_RE, TELL_ME_WRAPPER_RE, KNOW_WRAPPER_RE, WANT_KNOW_WRAPPER_RE, WONDERING_WRAPPER_RE, EMBEDDED_WHATIS_RE, EMBEDDED_MEANS_RE, SHOW_GIVE_ME_RE, LEADING_CONNECTIVE_RE, QUESTION_AUX_LEAD_RE, TOPIC_SWITCH_PREAMBLE_RE, SUBORDINATION_FRAMES_RE, SELF_CORRECTION_RE, CONDITIONAL_VERB_GERUND, CONDITIONAL_KIND_PLURAL, CONDITIONAL_QUALIFIER_SRC, CONDITIONAL_QUALIFIER_RE, COUNTERFACTUAL_RE, WHERE_TRAILING_TEMPORAL_RE, PHRASING_FRAMES, NEGATION_SET_RE, STOPWORDS2, splitWords, wordsOf;
+  var tableRe, CONTRACTION_RE, correctionRe, MISSPELLING_RE, WRONG_WORD_RE, W_SLASH_RE, FOR_DIGIT_THANKS_RE, FOR_DIGIT_EXAMPLE_RE, KIND_NOUN_ANAPHORA_RE, VERB_ALTERNATION, FILLER_RE, RELATION_VERB_RE, INTERROGATIVE_LEAD_RE, LISTING_TAIL_KINDS, BARE_KIND_RE, isListingRemainder, GREETING_PREAMBLE_RE, THANKS_PREAMBLE_RE, ACK_PREAMBLE_RE, BROWSING_PREAMBLE_RE, HEDGE_ADVERB_PREAMBLE_RE, TROUBLE_ASIDE_RE, MODAL_WRAPPER_RE, EXPLAIN_WRAPPER_RE, TELL_ME_WRAPPER_RE, KNOW_WRAPPER_RE, WANT_KNOW_WRAPPER_RE, WONDERING_WRAPPER_RE, EMBEDDED_WHATIS_RE, EMBEDDED_MEANS_RE, SHOW_GIVE_ME_RE, LEADING_CONNECTIVE_RE, QUESTION_AUX_LEAD_RE, TOPIC_SWITCH_PREAMBLE_RE, SUBORDINATION_FRAMES_RE, TRAILING_SUBORDINATION_RE, SELF_CORRECTION_RE, CONDITIONAL_VERB_GERUND, CONDITIONAL_KIND_PLURAL, CONDITIONAL_QUALIFIER_SRC, CONDITIONAL_QUALIFIER_RE, COUNTERFACTUAL_RE, WHERE_TRAILING_TEMPORAL_RE, PHRASING_FRAMES, NEGATION_SET_RE, STOPWORDS2, splitWords, wordsOf;
   var init_normalize = __esm({
     "src/domain/interpret/normalize.mjs"() {
       init_ask_vocab();
@@ -2893,7 +2903,8 @@ ${shown.join("\n")}${tail}`;
       LEADING_CONNECTIVE_RE = /^(?:and|also|so|then|now|but)\s+(.+)$/i;
       QUESTION_AUX_LEAD_RE = /^(?:does|do|did|is|are|was|were|has|have|had|can|could|will|would|should)\b/i;
       TOPIC_SWITCH_PREAMBLE_RE = /^(?:(?:actually|no\s+wait|wait|hold\s+on|never\s+mind|scratch\s+that|on\s+second\s+thought|i\s+mean(?:t)?)[\s,.]+)+(.+)$/i;
-      SUBORDINATION_FRAMES_RE = /^(?:since|although|though|while|because|whereas|given\s+that|now\s+that)\s+.+?,\s*(.+)$/i;
+      SUBORDINATION_FRAMES_RE = /^(?:since|although|(?:even\s+)?though|while|because|whereas|given\s+that|now\s+that)\s+.+?,\s*(.+)$/i;
+      TRAILING_SUBORDINATION_RE = /^(.+?),\s*(?:since|although|(?:even\s+)?though|while|because|whereas|given\s+that|now\s+that)\s+.+$/i;
       SELF_CORRECTION_RE = /^.+?(?:\s*(?:--|—|-)\s*)?\b(?:sorry|i\s+mean)\b\s*(?:--|—|-|,|:)\s*(.+)$/i;
       CONDITIONAL_VERB_GERUND = Object.freeze({
         imports: "importing",
@@ -2992,6 +3003,10 @@ ${shown.join("\n")}${tail}`;
         // CO-CHANGE → "what co-changes with X" (the plainest phrasing a developer types).
         { re: /^what\s+does\s+(.+?)\s+changes?\s+together\s+with\??$/i, to: (m) => `what co-changes with ${m[1]}` },
         { re: /^what\s+changes?\s+together\s+with\s+(.+?)\??$/i, to: (m) => `what co-changes with ${m[1]}` },
+        // COMMIT-COUNT PASSIVE ("how many commits are recorded for X") → the touch
+        // phrasing the count restrictor already compiles. "recorded" is no relation
+        // verb, so the passive otherwise dies in the restrictor parse.
+        { re: /^how\s+many\s+commits\s+(?:are|were)\s+(?:recorded|logged)\s+(?:for|against)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `how many commits touched ${m[1]}` },
         // AUTHORSHIP → "who touched X" (tmct's touch edge IS the authorship signal).
         // A commit sha object is excluded — that dumps the commit's touch-set, not its author.
         { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
@@ -3908,6 +3923,7 @@ ${shown.join("\n")}${tail}`;
       if (!noun) continue;
       const head = w.slice(0, r - 1);
       if (!head.length) continue;
+      if (head.every((x) => QUALIFIERS[x.toLowerCase()])) continue;
       const outer = parseSimpleClause([...head, NEST_SENTINEL].join(" "), nlp);
       if (!outer || outer.shape !== "reverse" && outer.shape !== "forward") continue;
       if (outer.modifier && outer.modifier !== "direct") continue;
@@ -22013,7 +22029,7 @@ ${codeblock}`, options);
   });
 
   // src/adapters/corpus/conceptnet.mjs
-  var import_meta6, PKG_ROOT4, SLICE_FILE, MAP_FILE, SEON_CONCEPTS_FILE, SEON_DEFINITIONS_FILE, TIER2_DIR, TIER2_MANIFEST_FILE, WORDNET_DIR, WORDNET_MANIFEST_FILE;
+  var import_meta7, PKG_ROOT5, SLICE_FILE, MAP_FILE, SEON_CONCEPTS_FILE, SEON_DEFINITIONS_FILE, TIER2_DIR, TIER2_MANIFEST_FILE, WORDNET_DIR, WORDNET_MANIFEST_FILE;
   var init_conceptnet = __esm({
     "src/adapters/corpus/conceptnet.mjs"() {
       init_node_fs();
@@ -22023,15 +22039,15 @@ ${codeblock}`, options);
       init_node_path();
       init_dist();
       init_core();
-      import_meta6 = {};
-      PKG_ROOT4 = join(dirname(fileURLToPath2(import_meta6.url)), "..", "..", "..");
-      SLICE_FILE = join(PKG_ROOT4, "corpus", "conceptnet", "slice.jsonl");
-      MAP_FILE = join(PKG_ROOT4, "src", "adapters", "corpus", "conceptnet-map.toml");
-      SEON_CONCEPTS_FILE = join(PKG_ROOT4, "corpus", "seon", "concepts.jsonl");
-      SEON_DEFINITIONS_FILE = join(PKG_ROOT4, "corpus", "seon", "definitions.jsonl");
-      TIER2_DIR = join(PKG_ROOT4, "corpus", "tier2");
+      import_meta7 = {};
+      PKG_ROOT5 = join(dirname(fileURLToPath2(import_meta7.url)), "..", "..", "..");
+      SLICE_FILE = join(PKG_ROOT5, "corpus", "conceptnet", "slice.jsonl");
+      MAP_FILE = join(PKG_ROOT5, "src", "adapters", "corpus", "conceptnet-map.toml");
+      SEON_CONCEPTS_FILE = join(PKG_ROOT5, "corpus", "seon", "concepts.jsonl");
+      SEON_DEFINITIONS_FILE = join(PKG_ROOT5, "corpus", "seon", "definitions.jsonl");
+      TIER2_DIR = join(PKG_ROOT5, "corpus", "tier2");
       TIER2_MANIFEST_FILE = join(TIER2_DIR, "manifest.json");
-      WORDNET_DIR = join(PKG_ROOT4, "corpus", "wordnet");
+      WORDNET_DIR = join(PKG_ROOT5, "corpus", "wordnet");
       WORDNET_MANIFEST_FILE = join(WORDNET_DIR, "manifest.json");
     }
   });
@@ -22125,7 +22141,7 @@ ${codeblock}`, options);
       }
     };
   }
-  var import_meta7, NAMENET_DIR, EXTENSION_KINDS, CONCEPTNET_PREFER, BUILTIN_EXTENSIONS;
+  var import_meta8, NAMENET_DIR, EXTENSION_KINDS, CONCEPTNET_PREFER, BUILTIN_EXTENSIONS;
   var init_extensions = __esm({
     "src/services/extensions.mjs"() {
       init_node_path();
@@ -22133,8 +22149,8 @@ ${codeblock}`, options);
       init_node_url();
       init_toml_config();
       init_conceptnet();
-      import_meta7 = {};
-      NAMENET_DIR = join(dirname(fileURLToPath2(import_meta7.url)), "..", "..", "corpus", "namenet");
+      import_meta8 = {};
+      NAMENET_DIR = join(dirname(fileURLToPath2(import_meta8.url)), "..", "..", "corpus", "namenet");
       EXTENSION_KINDS = Object.freeze(["corpus", "lexicon", "templates", "pack", "ontology"]);
       CONCEPTNET_PREFER = ["rdfs:subClassOf", "rdf:type", "mgx:usedFor", "mgx:partOf", "mgx:capableOf"];
       BUILTIN_EXTENSIONS = Object.freeze(builtinExtensions());
@@ -22300,8 +22316,8 @@ ${codeblock}`, options);
     {
       name: "tmct_impact",
       tier: "cold",
-      summary: "Transitive reverse closure over imports/calls \u2014 what breaks if a module changes, by depth, with tests.",
-      inputSchema: moduleArg("The module whose dependents you want."),
+      summary: "Transitive reverse closure over imports/calls \u2014 what breaks if a module or symbol changes, by depth, with tests.",
+      inputSchema: moduleArg("The module (or a symbol it defines) whose dependents you want."),
       example: { module: "django/utils/text.py" }
     },
     {
@@ -23233,6 +23249,17 @@ ${JSON.stringify(envelope, null, 2)}`;
   var import_meta4 = {};
   var PKG_ROOT2 = join(dirname(fileURLToPath2(import_meta4.url)), "..", "..", "..");
 
+  // src/domain/child-pack.mjs
+  init_hash();
+
+  // src/adapters/corpus/child-pack.mjs
+  init_node_fs();
+  init_node_url();
+  init_node_path();
+  init_hash();
+  var import_meta5 = {};
+  var PKG_ROOT3 = join(dirname(fileURLToPath2(import_meta5.url)), "..", "..", "..");
+
   // src/domain/dialogue-acts.mjs
   var DIALOGUE_ACT_DIMENSIONS = Object.freeze([
     "task",
@@ -23392,10 +23419,10 @@ ${JSON.stringify(envelope, null, 2)}`;
   init_node_fs();
   init_node_url();
   init_node_path();
-  var import_meta5 = {};
-  var PKG_ROOT3 = join(dirname(fileURLToPath2(import_meta5.url)), "..", "..", "..");
+  var import_meta6 = {};
+  var PKG_ROOT4 = join(dirname(fileURLToPath2(import_meta6.url)), "..", "..", "..");
   function worldsPackDir(env = process.env) {
-    return env?.TMCT_WORLDS_PACK_DIR || join(PKG_ROOT3, "corpus", "worlds");
+    return env?.TMCT_WORLDS_PACK_DIR || join(PKG_ROOT4, "corpus", "worlds");
   }
   var indexCacheByDir = /* @__PURE__ */ new Map();
   var worldCacheByKey = /* @__PURE__ */ new Map();

package/src/tools/definitions.mjs

@@ -146,8 +146,8 @@ export const TOOL_DEFINITIONS = Object.freeze([
   {
     name: "tmct_impact",
     tier: "cold",
-    summary: "Transitive reverse closure over imports/calls — what breaks if a module changes, by depth, with tests.",
-    inputSchema: moduleArg("The module whose dependents you want."),
+    summary: "Transitive reverse closure over imports/calls — what breaks if a module or symbol changes, by depth, with tests.",
+    inputSchema: moduleArg("The module (or a symbol it defines) whose dependents you want."),
     example: { module: "django/utils/text.py" },
   },
   {