@polycode-projects/the-mechanical-code-talker 0.7.1 → 0.8.1

package/ROADMAP.md

@@ -12,6 +12,44 @@ mapped into them (item numbers retained for traceability); the seven sketches
 formerly held in `code-talker-ideas.txt` are folded into items 8–11 below and
 the file has been deleted.
 
+## Where we are now (2026-07-06)
+
+**Built: v0.8.1 — Phase 11 deepened (0.8.0 shipped + published; 0.8.1 push held for the operator).**
+`npm test` green (**916**). 0.8.1 hardened the router with real *reasoning* measurement and closed the
+frontier stages, all under the same demonstrated-vs-designed honesty discipline:
+
+- **AGENTBENCH now grades the executed composed RESULT, not just the call-plan** (retires the headline
+  0.8.0 caveat). Under result-grading the resolver is **97% plan / 91% result / 0% hallucination**; the
+  honest gap lands exactly where reasoning is hard (C1, C2).
+- **Stage 5 — the C2 goal-reasoner** (BDI + Goal-Driven Autonomy) genuinely lifts result-completion.
+  The honest, **like-for-like** figure is the *driver swap on the identical 39-case ladder*
+  (`AGENTBENCH_0.8.1_001`): resolver **85% → goal-reasoner 95% result** (+10pp, purely the driver, 0%
+  hallucination). C2 is **cleared for one declared coverage-invariant goal-rule** — real and
+  phrasing-robust (validated by held-out phrasings graded blind, no request-string literals), but
+  **thinly sampled, not rule-general**; the open-world case is honestly **refused**. *(NB: the
+  cross-release "0→83% C2" reads on a grown 6-case C2 ladder whose 4 new cases exercise the
+  goal-reasoner — not a like-for-like rate; the same-basket win is one case fixed, 0→50% original C2.)*
+- **Stage 2 — imperative intent frames + ACE reach** (`AGENTBENCH_0.8.1_002`, goal driver): **100% plan
+  / 95% result / 0% hallucination**. `tmct_calls` is now **genuinely NL-reachable** via a distinct
+  edge-dump frame (not by un-tagging — bidirectional conformance enforces it; `NOT_NL_REACHABLE` is now
+  `{}`). ACE is wired **async** into the interpret pipeline so the synchronous CHATBENCH parse spine is
+  **byte-identical** — ACE is inert in the shipped product path (`interpret()` is called nowhere in
+  chat/ask/server/bin), reach without regression.
+- **Chat surface (CHATBENCH_0.8.1):** quick wins (singular "what is a test", friendly commit-author
+  refs, "No tests cover X" honest-empty, the chatbench discourse-count flake root-caused + scrubbed) +
+  two playtests (coverage-survey + authorship routing; **6 frozen `chatflow-*` transcripts** total).
+  Joint deterministic CHATBENCH (both new frame tables together): **no tier-1 regression vs 0.7.1.**
+  Judged tags touched by the text changes were re-judged (not blanket-reused) — see `CHATBENCH_0.8.1`.
+
+**Shipped earlier in v0.8.0 (published):** all five Phase-11 tracks — the `/v1/messages` shim + Stage-0
+registry + resolver/guardrail/planner (`AGENTBENCH_0.8.0_001`: 96% *plan* completion, 0% hallucination,
+closed-world C1); the three chat levers (`CHATBENCH_0.8.0`: tier-1 331→333); the `../bedrock-meter` `$0`
+rung (rank 0 below nova-micro, £0 metered e2e); the playtest; and the Stage-2/Stage-5 research notes.
+
+**Next:** grow the thin C2/coverage sampling to a second goal-rule; author→commit querying (a dead-end
+the friendly-commit-ref quick win opened); AGENTBENCH ladder depth; the tier-4/tier-5 Phase LATER long
+tail. See Phase 11 below and `HANDOVER.md` for the full open-follow-up list.
+
 ## The umbrella product definition (item 1)
 
 **A tolerant, ELIZA/PARRY-style chat, obsessed with software.** A best-efforts
@@ -279,11 +317,13 @@ and the block-index summary (blocks, tokens, top PageRank blocks). Same renderer
 
 > **STATUS: in progress — the two headline B1 levers shipped.** Negation as a bounded SET
 > COMPLEMENT ("which X do not <verb> Y") and reversible-passive traversal ("X is imported by Y")
-> are live; the harness meta-fixes and the rest of the ranked lever board continue.
+> are live; the harness meta-fixes and the rest of the ranked lever board (levers 3–6 + the C2
+> ceiling, below) continue. **This section is the durable home for the tuning arc** — the detailed
+> cycle-4 plan was archived to `archive/PLAN_CYCLE_4.md` once its substance lived here.
 
-> Detailed plans: **PLAN_CYCLE_4.md** (the tuning arc) and **PLAN_DEPENDENCY_STRATEGY.md**
-> (the pre-build dependency audit — verdict: no dep changes now; a standing adoption
-> register + avoid-list for phases 6-9; two near-term actions).
+> The dependency audit that also fed this phase is archived at `archive/PLAN_DEPENDENCY_STRATEGY.md`
+> (verdict: no dep changes now; a standing adoption register + avoid-list for phases 6-9; two
+> near-term actions, both shipped — see below).
 
 The immediate work: drive the graded benchmark up the CEFR ladder, one lever per cycle, per
 `SKILL_TUNING_CYCLE.md`. Cycle 3 (post-wiring-wave, CHATBENCH_003) gave the first full-spectrum
@@ -312,7 +352,7 @@ from meta-1's harness artifact), **C2 ceiling LAST**. Operator decision 2026-07-
 them**. Exit criterion in the plan (roughly: B1 grade mean ≥ ~1.5 with all cells dual-draw
 agreeing unlocks C-grade judging).
 
-## Near-term actions (from the dependency audit, PLAN_DEPENDENCY_STRATEGY.md)
+## Near-term actions (from the dependency audit, archive/PLAN_DEPENDENCY_STRATEGY.md)
 
 > **STATUS: both shipped.** The wink browser-loader seam is added (shared model loader with a
 > browser registration path) and `fnv1a` is single-sourced into `src/hash.mjs`.
@@ -322,7 +362,7 @@ Two concrete, low-risk actions the audit surfaced — not features, not dep chan
 1. **Fix wink's `createRequire` browser-loader gap** — the wink model IS the browser build, but
    our adapters load it via `createRequire(import.meta.url)` (`ask-nlp.mjs:29`, `prose-nlp.mjs:31`),
    which is Node-only. Browser mode needs a bundler `import` path. **A Phase 8 (browser-mode)
-   blocker** — budget it into `PLAN_REPOSITORY_INTERFACE.md`; it is a wiring fix, not a dependency
+   blocker** — budget it into `archive/PLAN_REPOSITORY_INTERFACE.md`; it is a wiring fix, not a dependency
    change (the model is already browser-capable).
 2. **Single-source `fnv1a`** — extract the content-address hash to one `src/hash.mjs` so the
    cross-version-stable fact-id contract has a single definition. Trivial refactor, do any time;
@@ -337,7 +377,7 @@ Two concrete, low-risk actions the audit surfaced — not features, not dep chan
 > `/memory` inspector surfaces contradictions with provenance. Legacy `mgx:factProvenance` kept
 > as a compat shim.
 
-> Detailed plan: **PLAN_PROVENANCE_TRUST.md**.
+> Detailed plan: **archive/PLAN_PROVENANCE_TRUST.md**.
 
 *(Operator-specified 2026-07-05, from the observation that Phase-6 canonicalise-and-link,
 tier-4 learn-on-miss, and the ConceptNet slice all share one shape: raw source preserved,
@@ -370,7 +410,7 @@ fact enters memory:
 > **STATUS: shipped.** A technical (C1) register of templates and productive/performance
 > dual-banding (computed from the `via` provenance) are live in the benchmark.
 
-> Detailed plan: **`PLAN_FORMULAIC_COMPETENCE.md`**.
+> Detailed plan: **`archive/PLAN_FORMULAIC_COMPETENCE.md`**.
 
 The operator's insight upgraded to the strategy: a consistently-failed C1/C2 graded cell whose
 answer EXISTS as a stable phrasing in technical prose is not a ceiling — it is a
@@ -403,7 +443,7 @@ answer EXISTS as a stable phrasing in technical prose is not a ceiling — it is
 > pass runs on prose spans only under a protected-span invariance guard. The a/an article fix is
 > active; broader voice/agreement rules are implemented-but-parked.
 
-> Detailed plan: **`PLAN_RESPONSE_FINISHING.md`**.
+> Detailed plan: **`archive/PLAN_RESPONSE_FINISHING.md`**.
 
 *(Refined 2026-07-05; decisions settled with the operator. Fact invariance is achieved by
 CONSTRUCTION, not by hope. Finishing operates over a SEGMENTED answer, never a raw string.
@@ -440,7 +480,7 @@ ever emerge.)*
 > runnable conformance/compatibility suite; and `tmct init` (scaffold `.tmct/`, `tmct.toml`,
 > tier-1 seed, provenance).
 
-> Detailed plan: **`PLAN_REPOSITORY_INTERFACE.md`**.
+> Detailed plan: **`archive/PLAN_REPOSITORY_INTERFACE.md`**.
 
 *(Operator-specified 2026-07-05; upgraded from research item to a build phase. tmct was spun OUT
 of seonix; this inverts the relationship: seonix reorients as a USER that imports the tmct
@@ -512,7 +552,7 @@ a passive payload loader into the product's primary integration surface.)*
 before it — PROACTIVELY extending memory with inferences that will be useful later, forward and
 backward chaining over the OWL base during idle/fold time rather than at query time.)*
 
-> Detailed plan: **`PLAN_SPECULATIVE_INFERENCE.md`**.
+> Detailed plan: **`archive/PLAN_SPECULATIVE_INFERENCE.md`**.
 
 **A maintenance job, not a query-time cost.** Speculative inference runs as an explicit
 batch — `npx tmct syllogise --depth <N>` (default depth bounded, e.g. 32) — and **once
@@ -595,6 +635,75 @@ you toward precision" promise on the conversational surface.
   with new graded cells for the miss / empty-graph / concept-touch surfaces so these become
   regression-protected levers, not one-off polish.
 
+## Phase 11 — The capability router & the agentic bench (0.8.0 shipped · 0.8.1 deepened)
+
+*(Operator-directed 2026-07-06; built the same day across five concurrent tracks.)* tmct as a **deterministic, no-LLM
+tool router** behind an Anthropic-compatible API — the workstream specified in
+`PLAN_CAPABILITY_ROUTER.md`, grounded in `docs/references/planning/`. This is a **new capability on a
+new axis** (driving a tool loop, not answering a chat turn), so it gets its **own benchmark**:
+**`AGENTBENCH`**, a sibling to CHATBENCH — same versioned-naming + grading discipline
+(`AGENTBENCH_<version>.md`, `_00N` for re-runs), but the levels are the **A0→C2 agentic rungs** and a
+**hallucinated tool call is an automatic fail**.
+
+**Status: DEMONSTRATED (with a stated scope caveat).** The router is built and measured:
+`AGENTBENCH_0.8.0_001` = **96% completion at 0% hallucination on every rung**, closed-world ladder
+cleared to **C1**. The gate the phase was staked on — a **0% hallucination rate on a real domain** (the
+graph-query toolset over the fixture) — **is met.** The honest scope line, held from the start:
+AGENTBENCH grades the correct **call-plan + causal-link proof, not the executed composed result**; the
+B1/B2/C1 rungs are **thin (2–3 cases)**; and the one C2 case is **refused** (the Stage-5 goal-reasoner
+is designed, not built). So "closed-world C1" means *the router provably selects and binds the right
+tool sequence*, not *end-to-end multi-step reasoning* — the demonstrated-vs-designed boundary is the
+real deliverable. The five tracks below are all built; the two research-agent stages (Track 4 below)
+remain designed-not-built by intent.
+
+### Track 1 — chat-surface levers (next CHATBENCH; all three)
+The three levers `CHATBENCH_0.7.1` measured + ranked — which **double as router prerequisites** (they
+gate the A2→B1→C1 rungs, per Phase B of the router plan):
+1. **Pronoun / focus binding** — the "it → Commit" mis-bind (`B1 pron 1.24`); biggest movable mass.
+2. **Discourse-count anaphora** — "count them / how many of those" over a prior listing (clears the 2
+   `CHATBENCH_0.7.1` tier-1 misses).
+3. **C1 temporal-over-relative composition** — the two-hop ceiling (`C1 temp 0.31`).
+Land all three (not just #1); they raise the chat floor *and* the router's floor at once.
+
+### Track 2 — the router build (the within-horizon slice, in order)
+Buildable now with a frontier model as co-author (see PLAN §"solved vs unsolved"):
+- **Phase A — the shim.** An Anthropic Messages API endpoint (`/v1/messages`, `tool_use`/`tool_result`
+  blocks). **Extended:** also present as a **`bedrock-meter`-compatible routing target** (see below).
+- **Phase B — measure today → `AGENTBENCH_0.7.2.md`.** Shim + a small graph-query toolset up the
+  A0→C2 ladder; the honest baseline (expected A0 solid, A1–A2 partial, per the CHATBENCH_0.7.1
+  inherited assets).
+- **Phase C — the grading ladder.** The AGENTBENCH benchmark itself (rungs as levels, comparable
+  local/hosted models as reference bands, zero-hallucination gate).
+- **Stage 0 — capability registry** (`Capability`/`Parameter`/`Precondition`/`Effect` = STRIPS/PDDL
+  operators as facts).
+- **Stage 1 — the resolver** (unification + backward chaining / a mini Datalog).
+- **Stage 4 — the guardrail** (validate an LLM's proposed `tool_use` against declared preconditions —
+  the hybrid fast-path; cheap once 0–1 exist).
+- **Stage 3 — the planner** (POP/HTN over operators + Steel & Ho monitor-and-replan → **closed-world
+  C1**; optionally defer search to an external PDDL solver).
+
+### Phase A extension — the `bedrock-meter` deployment surface
+`../bedrock-meter` is pre-flight Bedrock cost metering + capping, with a **roadmap optimiser** that
+"cheaply assesses a task's complexity … and routes to the lowest-cost capable model" (it already
+meters Nova Lite + Nova Micro). tmct — **benchmarked against agent capabilities by AGENTBENCH** — slots
+in as the **$0 floor *below* Nova-micro** in that routing ladder: for a request class AGENTBENCH proves
+in-envelope, the optimiser routes to tmct (deterministic, ~$0, ms latency) instead of any metered
+model. So Phase A's shim is built **bedrock-meter-pluggable**, and AGENTBENCH is what defines the
+envelope the optimiser is allowed to trust. This is the concrete "near-free alternative" deployment.
+
+### Track 3 — playtest alongside the build (`git worktree`)
+Run `SKILL_CHAT_PLAYTEST.md` **in a parallel `git worktree`** while the router is built — the
+dialogue-flow dead-end hunt keeps running without blocking the build, and its fixes **merge back**.
+(The worktree is auto-cleaned if unchanged; merge the frozen `test/chatflow-*` transcripts in.)
+
+### Track 4 — research agents (the "at the edge" stages)
+Two stages need design judgment + exploration, so they run as **background research agents**, off the
+critical build path:
+- **Stage 2 — intent frames, controlled fragment** — imperative NL → structured intent for the
+  controlled command language (the front-end; the general case stays out-of-scope / escalate).
+- **Stage 5 — goal-reasoner, closed-world C2** — BDI + Goal-Driven Autonomy: deduce-goals (long-chain
+  deduction) → plan-each (C1) → threat-aware, *persistent* first-step arbitration.
+
 ## Phase LATER — recognized, deferred, not now
 
 Features we have deliberately shaped seams for but will not build until the phases above have

package/bin/tmct.mjs

@@ -48,6 +48,10 @@ Usage:
   tmct syllogise [--repo <abs>] speculative inference (offline maintenance job): forward-
        [--depth <n>] [--budget <n>]  chain the memory's rdfs:subClassOf closure, materialising
                                bounded, low-trust, retractable entailed facts (never on the chat path)
+  tmct serve [--repo <abs>]    run the Anthropic Messages API-compatible endpoint
+       [--host <h>] [--port <n>]  (POST /v1/messages) over the graph — a deterministic,
+                               no-LLM "model" a tool-loop client can call; $0 usage.
+                               Defaults: host 127.0.0.1, port 8787. Ctrl+C to stop.
   tmct cli <tool> '{…}'        invoke a graph tool directly (carry-over, de-emphasized)
   tmct cli digest '{…}'        architecture map + per-module context bundles
   tmct --help                  show this help
@@ -387,6 +391,47 @@ async function main() {
     return;
   }
 
+  if (mode === "serve") {
+    // `tmct serve` — the Phase-A capability-router interface: an Anthropic
+    // Messages API-compatible HTTP endpoint (POST /v1/messages) over the graph.
+    // A deterministic, no-LLM "model" a tool-loop client (Claude Code) can point
+    // at; every response reports $0 usage. Read-only: no session artifacts, no
+    // writes back to the graph. See src/server-http.mjs.
+    const rest = process.argv.slice(3);
+    if (rest.includes("--help") || rest.includes("-h")) {
+      process.stdout.write(
+        "tmct serve — Anthropic Messages API-compatible endpoint (POST /v1/messages)\n\n" +
+        "Usage:\n" +
+        "  tmct serve [--repo <abs>] [--host <h>] [--port <n>]\n\n" +
+        "  --repo <abs>   target a repo's graph (<abs>/.tmct/graph.json); default: cwd/TMCT_GRAPH_FILE\n" +
+        "  --host <h>     bind address (default 127.0.0.1)\n" +
+        "  --port <n>     TCP port (default 8787; 0 picks an ephemeral port)\n\n" +
+        "Request:  { model, messages:[...], tools:[...], max_tokens, system? }\n" +
+        "Response: { id, type:\"message\", role:\"assistant\", content:[...blocks], stop_reason, usage }\n" +
+        "          usage is always { input_tokens: 0, output_tokens: 0 } — tmct is the $0 floor.\n",
+      );
+      return;
+    }
+    const strFlag = (name, dflt) => { const j = rest.indexOf(name); return j !== -1 ? rest[j + 1] : dflt; };
+    const repoPath = strFlag("--repo", undefined);
+    const host = strFlag("--host", "127.0.0.1");
+    const portRaw = strFlag("--port", undefined);
+    const port = portRaw !== undefined && Number.isFinite(Number(portRaw)) ? Number(portRaw) : 8787;
+    const { join } = await import("node:path");
+    const { startServer } = await import("../src/server-http.mjs");
+    const { loadConfig, DEFAULT_GRAPH_REL } = await import("../src/config.mjs");
+    const configFor = (rp) => rp ? { graphFile: join(rp, DEFAULT_GRAPH_REL) } : loadConfig();
+    const srv = await startServer({ config: configFor(repoPath), host, port });
+    process.stdout.write(
+      `tmct serve — Anthropic Messages API at ${srv.url}/v1/messages (POST) — ` +
+      `graph ${srv.config.graphFile} — usage billed $0 — Ctrl+C to stop\n`,
+    );
+    const shutdown = async () => { await srv.close(); process.exit(0); };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    return; // the listening server keeps the event loop alive
+  }
+
   if (mode === "cli") {
     await runCliMode();
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "0.7.1",
+  "version": "0.8.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.",
@@ -85,6 +85,8 @@
     "example:polyglot": "node bin/tmct.mjs chat --repo examples/polyglot --ephemeral",
     "chatbench:run": "node chatbench/run.mjs",
     "chatbench:judge": "node chatbench/judge.mjs",
+    "serve": "node bin/tmct.mjs serve",
+    "agentbench:run": "node agentbench/run.mjs",
     "audit": "npm audit --audit-level=high",
     "audit:fix": "npm audit fix"
   },

package/src/ask-vocab.mjs

@@ -220,7 +220,7 @@ export const MODIFIER_TO_KIND = Object.freeze({
   transitively: "transitive", indirectly: "transitive",
 });
 
-// ---- reversible-passive participles (Cycle 6, PLAN_CYCLE_4.md) — past participles ->
+// ---- reversible-passive participles (Cycle 6, archive/PLAN_CYCLE_4.md) — past participles ->
 // relation kind, for the agent-marked passive "X is <participle> by Y". Kept SEPARATE
 // from VERB_TO_KIND on purpose: these forms are NOT standalone active verbs in this
 // grammar ("defined" belongs to the multi-word "is defined in" and to the WHERE_MARKERS

package/src/ask.mjs

@@ -246,6 +246,7 @@ function parseComposite(text, nlp) {
   const lc = w.map((x) => x.toLowerCase());
   return parseNegation(text, nlp, 0)
     || parseForwardNegation(w, lc, nlp)
+    || parseTemporal(w, lc, nlp, 0)
     || parseAnaphora(w, lc, nlp)
     || parseAggregate(w, lc, nlp)
     || parseSuperlative(w, lc, nlp)
@@ -254,7 +255,7 @@ function parseComposite(text, nlp) {
     || parseRelationalOrQualified(w, lc, nlp, 0);
 }
 
-// B1 NEGATION (Cycle 5, PLAN_CYCLE_4.md) — the SET COMPLEMENT. "which X do not <verb>
+// B1 NEGATION (Cycle 5, archive/PLAN_CYCLE_4.md) — the SET COMPLEMENT. "which X do not <verb>
 // Y" / "X that don't <verb> Y" / "modules not importing Y" / "which X are not
 // <qualifier>" compiles to allOfClass(kind) DIFFERENCE (the positive result set),
 // reusing the EXISTING machinery: evalBoolean already folds a "difference" atom, and
@@ -416,6 +417,44 @@ function parseNested(w, lc, nlp, depth) {
   return null;
 }
 
+// TEMPORAL-OVER-RELATIVE (Phase 11 Track 1, lever 3) — "when did <relative set> [last]
+// change". The flat when-shape (traverse) dates the commits touching ONE resolved term;
+// this composes that same touches→commit→date-sort machinery as an OUTER operator over a
+// NESTED inner set ("when did the modules that import X last change", "when were the
+// functions that call Y last touched"). Fires only for a RELATIVE subject (a "that/which"
+// marker) so the single-entity "when did X change" stays on the flat path untouched; a
+// marker present but uncompilable inner is an honest miss, never a guess.
+const TEMPORAL_AUX = new Set(["did", "was", "were", "do", "does", "has", "have", "had"]);
+const TEMPORAL_TAIL = new Set([
+  "change", "changed", "changes", "update", "updated", "updates",
+  "modify", "modified", "modifies", "touch", "touched", "touches", "edit", "edited", "revise", "revised",
+]);
+const TEMPORAL_TRAIL_FILLER = new Set(["last", "recently", "ever", "get", "got", "been", "then", "now", "already"]);
+const TEMPORAL_DET = new Set(["the", "a", "an", "all", "those", "these", "any"]);
+
+function parseTemporal(w, lc, nlp, depth = 0) {
+  if (lc[0] !== "when") return null;              // temporal questions lead with "when"
+  let i = 1;
+  if (!TEMPORAL_AUX.has(lc[i])) return null;      // need an auxiliary ("when did …")
+  i += 1;
+  // the change-verb tail — take the LAST occurrence so "…that import X last change" works.
+  let t = -1;
+  for (let k = lc.length - 1; k >= i; k -= 1) { if (TEMPORAL_TAIL.has(lc[k])) { t = k; break; } }
+  if (t < 0) return null;                          // no change verb → not a temporal question
+  let subjWords = w.slice(i, t);
+  let subjLc = lc.slice(i, t);
+  while (subjLc.length && TEMPORAL_TRAIL_FILLER.has(subjLc[subjLc.length - 1])) { subjWords = subjWords.slice(0, -1); subjLc = subjLc.slice(0, -1); }
+  while (subjLc.length && TEMPORAL_DET.has(subjLc[0])) { subjWords = subjWords.slice(1); subjLc = subjLc.slice(1); }
+  if (!subjWords.length) return null;
+  // ONLY a relative/nested subject composes here; a bare named entity is the flat path's.
+  if (!subjLc.some((x) => RELATIVE_PRONOUNS.includes(x))) return null;
+  const framed = FRAME_WORDS.has(subjLc[0]) ? subjWords.join(" ") : `which ${subjWords.join(" ")}`;
+  const inner = parseSetPhrase(framed, nlp, depth + 1);
+  if (!inner || inner.node === "miss") return inner ? { node: "miss", reason: inner.reason || "the inner set of the temporal query didn't parse" } : { node: "miss", reason: "the inner set of the temporal query didn't parse" };
+  const noun = entityNoun(subjLc[0]);
+  return { node: "temporal", inner, entityType: (noun && noun.entityType) || null };
+}
+
 /** ANAPHORA over the previous result set: "which of those/them <filter>", "how many
  *  of those <filter>". Requires "of <pronoun>" (so a bare "those" in a term never
  *  fires). Returns a {node:"anaphora"} (mode count|list), a miss (filter present but
@@ -745,7 +784,15 @@ function reverseOverSet(graph, kind, entityType, objectIds) {
     const edges = edgesOfKind(graph, symbolKind).filter((e) => objectIds.has(e.object));
     return uniqueById(edges.map((e) => graph.byId.get(e.subject)).filter((s) => s && s.class === entityType));
   }
-  const edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => objectIds.has(e.object));
+  // GRAIN-AWARE OBJECT SET (Phase 11 Track 1, lever 3): when the inner set resolved to
+  // FINE symbols (functions/methods/…), also scan the symbol-grain sibling — the coarse
+  // edge (touches Commit→Module, calls Module→Module) can never point AT a symbol, so a
+  // two-hop whose inner clause produced symbols ("which commits touched the functions
+  // that call X") would falsely miss without it. Mirrors traverse()'s objIsFineSymbol
+  // branch for the flat path; the module-coarse case is byte-unchanged (no fine ids).
+  const objHasFine = !!symbolKind && [...objectIds].some((id) => FINE_ENTITY_TYPES.has(graph.byId.get(id)?.class));
+  const scanKinds = objHasFine ? [...kindsFor(kind), symbolKind] : kindsFor(kind);
+  const edges = scanKinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => objectIds.has(e.object));
   const subjects = uniqueById(edges.map((e) => graph.byId.get(e.subject)).filter(Boolean));
   if (!entityType || entityType === "Change") return subjects;
   const direct = subjects.filter((s) => s.class === entityType);
@@ -933,6 +980,24 @@ function degreeMetric(graph, ind, metric) {
   }
   return n;
 }
+/** TEMPORAL over a nested set (lever 3) — the commits that touched ANY member of the
+ *  inner set, newest commit date first. Reuses the SAME touches→commit→date-sort the
+ *  flat when-shape runs (mgx:commitDate is ISO-8601, so a lexical sort IS a date sort;
+ *  undated commits sort last and render says so). `entityType` is the inner noun, only
+ *  for phrasing. An empty inner set (nothing resolved) or no touching commit is an
+ *  honest empty — never a guess. */
+function evalTemporal(graph, ast, opts) {
+  const inner = evalSet(graph, ast.inner, opts);
+  const ids = new Set(inner.map((i) => i.id));
+  if (!ids.size) return { compositeKind: "temporal", matches: [], entityType: ast.entityType, innerCount: 0 };
+  // reverseOverSet(touches) collects the touching commits across BOTH grains (its
+  // grain-aware object-set branch reads touchesSymbol when the inner set is symbols).
+  const commits = reverseOverSet(graph, "touches", "Commit", ids);
+  const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
+  commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+  return { compositeKind: "temporal", matches: commits, entityType: ast.entityType, innerCount: inner.length };
+}
+
 function evalSuperlative(graph, ast) {
   const pool = graph.individuals.filter((i) => i.class === ast.entityType);
   const scored = pool.map((ind) => ({ ind, score: degreeMetric(graph, ind, ast.metric) }))
@@ -950,6 +1015,7 @@ export function evalComposite(graph, ast, opts = {}) {
   if (ast.node === "count") return { compositeKind: "count", count: evalSet(graph, ast.base, opts).length, entityType: ast.entityType, matches: [] };
   if (ast.node === "list") return { compositeKind: "list", matches: evalSet(graph, ast.base, opts), entityType: ast.entityType, scoped: ast.scoped };
   if (ast.node === "superlative") return evalSuperlative(graph, ast);
+  if (ast.node === "temporal") return evalTemporal(graph, ast, opts);
   if (ast.node === "anaphora") return evalAnaphora(graph, ast, opts);
   return { compositeKind: "set", matches: evalSet(graph, ast, opts), entityType: ast.entityType || null };
 }
@@ -1000,6 +1066,32 @@ function renderComposite(parsed, result) {
       miss: false, ambiguous: false, matches: result.matches,
     };
   }
+  // temporal (lever 3): the newest touching commit + its date over the inner set;
+  // honest empty when nothing in the set was touched, undated commits said out loud —
+  // the same discipline as the flat when-shape, now over a composed set.
+  if (result.compositeKind === "temporal") {
+    const n = result.innerCount || 0;
+    const setNoun = result.entityType ? nounFor(result.entityType, n || 2) : (n === 1 ? "entity" : "entities");
+    const wasWere = n === 1 ? "was" : "were";
+    if (!n) {
+      return { content: `nothing in the index matches the inner set, so there is no change history to date.`, miss: true, ambiguous: false, matches: [] };
+    }
+    if (!result.matches.length) {
+      return { content: `no recorded commit touched the ${n} ${setNoun} in that set in this index.`, miss: true, ambiguous: false, matches: [] };
+    }
+    const newest = result.matches[0];
+    const date = (newest.attributes || []).find((a) => a.key === "date")?.value || "";
+    if (!date) {
+      return { content: `the ${setNoun} in that set ${wasWere} last touched by commit ${newest.label}, but this index records no commit dates — regenerate the graph to attach mgx:commitDate.`, miss: true, ambiguous: false, matches: result.matches };
+    }
+    const msg = (newest.attributes || []).find((a) => a.key === "message")?.value || "";
+    const day = String(date).slice(0, 10);
+    const more = result.matches.length - 1;
+    return {
+      content: `the ${setNoun} in that set ${wasWere} last touched by commit ${newest.label} on ${day}${msg ? ` ("${msg}")` : ""}${more ? `; ${more} earlier commit${more === 1 ? "" : "s"} recorded` : ""}.`,
+      miss: false, ambiguous: false, matches: result.matches,
+    };
+  }
   // set-producing
   if (!result.matches.length) {
     return { content: `nothing in the index matches that${result.entityType ? ` (${nounFor(result.entityType, 2)})` : ""}.`, miss: true, ambiguous: false, matches: [] };
@@ -1554,6 +1646,17 @@ function symbolLabelOf(ind) {
   return ["Function", "Method"].includes(ind.class) ? `function ${label}()` : label;
 }
 
+/** A FRIENDLY commit reference for a "who touched X" list — the raw sha alone reads as
+ *  noise, so when the Commit individual carries an author (mgx:commitAuthor → key
+ *  "author") name them beside it. The label is already the graph's short ref (the
+ *  builder stores sha.slice(0,12)), so it is used verbatim. Degrades gracefully: a
+ *  commit with no recorded author renders the sha alone, exactly as before. */
+function commitRefOf(ind) {
+  const sha = String(ind.label || ind.id || "");
+  const author = (ind.attributes || []).find((a) => a.key === "author")?.value;
+  return author ? `${sha} (${author})` : sha;
+}
+
 function listJoin(syms) {
   return syms.length > 1 ? `${syms.slice(0, -1).join(", ")} and ${syms[syms.length - 1]}` : syms[0];
 }
@@ -1742,6 +1845,20 @@ function renderCore(parsed, result) {
         miss: true, ambiguous: false,
       };
     }
+    // "what tests cover X" / "what tests X" — the tests themselves are the search
+    // target (no explicit entity keyword → entityType null), and "tests" reads as a
+    // verb phrase, so the generic "No <modules> found whose module directly tests <obj>"
+    // template garbles: it mislabels the searched kind as "modules" and lets the leaked
+    // "cover " verb ride into the object ("…directly tests cover X"). Render the honest
+    // empty as the natural "No tests cover X." The frozen entity-keyword form ("which
+    // modules test X", entityType="Module") keeps its pinned wording below.
+    if (parsed.kind === "tests" && !parsed.entityType) {
+      const obj = String(parsed.object || "").replace(/^cover(?:s|ing)?\s+/i, "").trim();
+      return {
+        content: `No tests cover ${obj}. (traversal: ${result.traversal || "no traversal resolved"})`,
+        miss: true, ambiguous: false,
+      };
+    }
     // NOTE (Cycle 5): a voice-nit rephrasing ("that directly <verb>") was reverted —
     // the frozen v1 cases.jsonl pins the "whose module directly <verb>s X" wording
     // (hm-empty-result-calls / tf-wat-calls / ns-wondering), and the case set is
@@ -1761,7 +1878,10 @@ function renderCore(parsed, result) {
   // Commit list ("which commits touched X") has no containing module to group by, so
   // anything that is not a fine entity takes the flat join.
   if (parsed.shape === "forward" || parsed.entityType === "Module" || result.matches.every((m) => !FINE_ENTITY_TYPES.has(m.class))) {
-    const shown = result.matches.slice(0, OVERFLOW_CAP).map((m) => m.label);
+    // A reverse "who touched X" resolves to Commit individuals — render friendly refs
+    // (short sha + author) instead of the raw stored sha; every other flat list (module
+    // labels, etc.) keeps its own label verbatim.
+    const shown = result.matches.slice(0, OVERFLOW_CAP).map((m) => m.class === "Commit" ? commitRefOf(m) : m.label);
     const extra = result.matches.length > OVERFLOW_CAP ? `, …and ${result.matches.length - OVERFLOW_CAP} more` : "";
     return { content: shown.join(" and ") + extra + ".", miss: false, ambiguous: false, matches: result.matches };
   }

package/src/chat.mjs

@@ -105,6 +105,29 @@ export const COMMANDS = {
  *  back to the focus for, and that update the focus on a successful resolve. */
 const ENTITY_ARGS = new Set(["symbol", "module", "class"]);
 
+/** The individual classes that are FOCUS-WORTHY — the code entities the ENTITY_ARGS
+ *  commands (symbol/module/class) name and that "it"/"this" should bind to. A
+ *  `Commit`/`Session` (history/provenance) or a `SchemaClass`/`SchemaPredicate`
+ *  (vocabulary meta-node) is a real graph individual but NOT a standing antecedent:
+ *  it must not silently DISPLACE a code-entity focus, or the next turn's pronoun
+ *  binds to the wrong thing (CHATBENCH_0.7.1 B1-pron: "it" → Commit). */
+const FOCUS_WORTHY_CLASSES = new Set(["Module", "Function", "Class", "Method", "Attribute", "GlobalVariable"]);
+
+/** Is the individual with this id a focus-worthy code entity? Looks the class up on
+ *  the loaded graph (focus objects stay `{id,label}` — the class is never stored on
+ *  them, so a caller that deepEquals the focus shape is unaffected). An unknown id
+ *  (ext: endpoint, missing) is treated as not-worthy: conservative, so it never
+ *  displaces a standing code focus but is freely adopted when there is none. */
+const isFocusWorthy = (graph, id) => FOCUS_WORTHY_CLASSES.has(graph?.byId?.get(id)?.class);
+
+/** The focus to carry forward after a turn resolved `ent`. A newly-resolved entity
+ *  becomes the focus UNLESS it is not focus-worthy (a Commit/Session/schema node)
+ *  AND there is already a standing focus-worthy (code) focus — in which case the
+ *  standing code focus holds. So a query whose object resolves to a Commit never
+ *  hijacks the "it" antecedent from the module/function the user was working on. */
+const nextFocus = (graph, focus, ent) =>
+  (!focus?.id || isFocusWorthy(graph, ent.id) || !isFocusWorthy(graph, focus.id)) ? ent : focus;
+
 /** System-command words that a forgiving shell accepts WITHOUT the leading "/":
  *  `stats`, `memory`, `describe X`, `members X`, … all work bare. "help" is left
  *  out on purpose — bare "help" stays the friendly orientation; "/help" is the
@@ -127,9 +150,18 @@ export function asBareCommand(line) {
   if (!trimmed || trimmed.startsWith("/")) return null;
   const [first, ...restTok] = trimmed.split(/\s+/);
   if (!COMMAND_WORDS.has(first.toLowerCase())) return null;
+  const fl = first.toLowerCase();
   const rest = restTok.join(" ");
   // Zero-arg system commands are always the command; a bare command word is too.
-  if (!rest || first.toLowerCase() === "stats" || first.toLowerCase() === "memory") return `/${trimmed}`;
+  if (!rest || fl === "stats" || fl === "memory") return `/${trimmed}`;
+  // A NO-ARGUMENT command word ("untested") with trailing words is NOT a command
+  // call — the /untested tool takes no argument and would silently drop the qualifier,
+  // listing MODULES for "untested classes". "untested classes" / "untested modules"
+  // is a kind-FILTERED query the ask engine answers correctly (Base, Button for
+  // classes) AND, as a listing, seeds discourse-count anaphora ("count them",
+  // "how many of those are tested") with its match set — the CHATBENCH_0.7.1
+  // discourse-count tier-1 misses (g-b1-disc-count-22/-3). Fall through to the engine.
+  if (COMMANDS[fl]?.arg == null && rest) return null;
   // Arg commands: route only a short, name-like argument (no query connectives),
   // so "describe Widget" / "members my class" route but a compositional query does not.
   if (restTok.length <= 3 && !QUERY_CONNECTIVES.test(rest)) return `/${trimmed}`;
@@ -1300,6 +1332,19 @@ function relationTermOf(query, envelope) {
   if ((m = q.match(/^what\s+([a-z][a-z-]*?)\s+are\s+there$/))) return m[1];
   // "what is calling", "what is importing" (bare gerund, no object)
   if ((m = q.match(/^what\s+(?:is|are)\s+([a-z][a-z-]*ing)$/))) return m[1];
+  // THE SINGULAR META FORM — "what is a test" / "what is an import". The whole meta
+  // shape used to be excluded here to keep the frozen am-meta-imports ambiguity case
+  // ("what does imports mean") out; but that case is a DIFFERENT shape (ambiguousParse
+  // → envelope.parsed is null), and a relation word whose SINGULAR reads as a real
+  // graph-schema class/predicate ("what is a contains"/"cochange") answers non-miss
+  // from the ordinary meta path. So admit the article meta form ONLY when the ordinary
+  // path MISSED on a plain definitional parse (envelope.miss on a shape:"meta" object):
+  // an unambiguous relation word like "test" — no schema reading, no ambiguity — then
+  // reaches the relation-concept force exactly as its plural "what are the tests" does.
+  // RELATION_TERM still gates the term downstream, so a non-relation miss is untouched.
+  if (envelope?.miss === true && envelope?.parsed?.shape === "meta" && envelope.parsed.object) {
+    return envelope.parsed.object;
+  }
   return null;
 }
 
@@ -1382,7 +1427,7 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
   const pending = composed.remainder && composed.remainder.length
     ? { items: composed.remainder, noun: composed.noun }
     : null;
-  return { text, instances: composed.instances, pending };
+  return { text, instances: composed.instances, allIds: composed.allInstanceIds, pending };
 }
 
 /** A bare question → tmct_ask. When a focus is set AND the graph is in hand we
@@ -1398,7 +1443,12 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // answer's entity set. That set is the ids the last dispatched turn cited — carried
   // on `last.detail.matches`. Threading it as ask()'s `prev` is what lets the anaphora
   // node resolve instead of the "needs a previous answer" honest miss.
-  const prev = (last?.detail?.matches || []).map((m) => m?.id).filter(Boolean);
+  // Prefer the FULL id set (`allIds`) when the last turn carried one — a concept-force
+  // listing caps its shown `matches` at MAX_EXAMPLES, so counting `matches` alone would
+  // undercount "count them" over a truncated listing (CHATBENCH_0.7.1 discourse-count).
+  const prev = (last?.detail?.allIds && last.detail.allIds.length)
+    ? last.detail.allIds.filter(Boolean)
+    : (last?.detail?.matches || []).map((m) => m?.id).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.
@@ -1438,8 +1488,19 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   let resolvedIds = [];
   let newFocus = focus;
   if (graph && envelope?.parsed?.object) {
-    const ent = await resolveEntity(graph, envelope.parsed.object);
-    if (ent) { resolvedIds = [ent.id]; newFocus = ent; }
+    const obj = envelope.parsed.object;
+    // A PRONOUN object ("it"/"this") was already resolved against the focus via
+    // contextId — the resolved antecedent IS the focus. Re-resolving the literal
+    // pronoun string is the CHATBENCH_0.7.1 B1-pron bug: "it" substring-matches the
+    // "Commit" schema node (label contains "it"), so the focus jumped off the module
+    // to a Commit and the NEXT "it" bound wrong. Reuse the focus directly instead.
+    const ent = (isPronoun(obj) && focus?.id) ? focus : await resolveEntity(graph, obj);
+    if (ent) {
+      resolvedIds = [ent.id];
+      // Class-gate the focus update: a Commit/Session/schema object never displaces a
+      // standing code-entity focus (see nextFocus).
+      newFocus = nextFocus(graph, focus, ent);
+    }
   }
   const answeredIds = (envelope?.matches || []).map((m) => m?.id).filter(Boolean);
   const miss = envelope ? !!envelope.miss : true;
@@ -1511,12 +1572,14 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // Runs after the corpus-fact/curated branches (via composed|corpus/seon) but not
   // over a "you told me" fact, a meta/self summary, or the conversational lanes.
   let conceptInstances = null;
+  let conceptAllIds = null;
   let conceptPending = null;
   if (via === "composed" || via === "corpus/seon") {
     const concept = await conceptForceAnswer(query, envelope, { graph, config, source, memoryDir, templates });
     if (concept) {
       answer = concept.text; via = "corpus/seon"; recordMiss = false;
       conceptInstances = concept.instances;
+      conceptAllIds = concept.allIds;
       conceptPending = concept.pending;
     } else {
       // THE RELATION CONCEPT FORCE — the noun force declined, so try the edge-kind
@@ -1574,8 +1637,14 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // holds it on conceptPending (the relation force resolves no instance ids, so it can
   // still page even with an empty matches set); a fact listing holds it on factPending.
   const pending = conceptPending ?? factPending;
+  // `allIds` carries the FULL result-set ids (uncapped) so discourse-count anaphora
+  // ("count them" / "how many of those") survives a truncated render: the concept
+  // force shows only MAX_EXAMPLES instances on `matches`, but a follow-up count must
+  // see them all. The ordinary ask-engine listing already carries its whole set on
+  // `matches`, so only the concept force needs the extra field (a full id array).
+  const allIds = conceptAllIds && conceptAllIds.length ? conceptAllIds : null;
   const detail = conceptInstances
-    ? { traversal: envelope?.traversal || null, matches: conceptInstances, ...(pending ? { pending } : {}) }
+    ? { traversal: envelope?.traversal || null, matches: conceptInstances, ...(allIds ? { allIds } : {}), ...(pending ? { pending } : {}) }
     : (envelope
       ? { traversal: envelope.traversal || null, matches: envelope.matches || [], ...(pending ? { pending } : {}) }
       : (pending ? { traversal: null, matches: [], pending } : null));
@@ -1653,7 +1722,10 @@ async function runCommand(line, { config, source, graph, focus, memoryDir }) {
   // follow-up ("what calls it", a no-arg /context) reuses it.
   if (entityArg) {
     const ent = await resolveEntity(graph, value);
-    if (ent) return mk(answer, { resolvedIds: [ent.id], newFocus: ent });
+    // Same class-gate as the ask path (nextFocus): a command whose arg resolves to a
+    // Commit/Session/schema node records the resolution but does not displace a
+    // standing code-entity focus that "it" is meant to keep binding to.
+    if (ent) return mk(answer, { resolvedIds: [ent.id], newFocus: nextFocus(graph, focus, ent) });
   }
   return mk(answer);
 }