@polycode-projects/the-mechanical-code-talker 0.7.0 → 0.8.0

package/ROADMAP.md

@@ -12,6 +12,37 @@ 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.0 — Phase 11 landed (Phases 0–10 shipped in 0.7.1).** All five Phase-11 tracks are
+built, merged, and measured; `npm test` green (**869**). Push/publish held for the operator. Highlights:
+
+- **Track 1 — chat levers (measured).** Pronoun/focus binding, discourse-count anaphora, and C1
+  temporal-over-relative composition all landed. `CHATBENCH_0.8.0`: tier-1 spine **331→333**, all three
+  lever families moved their cells (the B1-temporal control did not spill); judged fixed tag
+  `multi-turn-focus` **1.433→1.9** (the pronoun lever's echo). The judged pooled mean (1.44) is **not
+  case-comparable** to 0.7.1's 1.488 — the graded draw re-samples 10% of cells each run, so §1 compares
+  cell-level, not the scalar; the deterministic tier-1 spine is the load-bearing PASS.
+- **Track 2 — the router (designed → DEMONSTRATED).** The Anthropic-compatible `/v1/messages` shim
+  (`serve` mode), the Stage-0 capability registry (STRIPS/PDDL operators, closed-world default-deny),
+  and the resolver (S1) + guardrail (S4) + planner (S3, pure-JS POP/HTN + Steel & Ho monitor). Measured:
+  `AGENTBENCH_0.8.0` (shim-transport floor, 46% completion) → `AGENTBENCH_0.8.0_001` (the real router):
+  **96% completion at 0% hallucination on every rung**, clearing the closed-world ladder to **C1**. The
+  honest gate the phase was staked on is **met on its hallucination axis (0%)**. **Caveat (stated in the
+  artifact):** AGENTBENCH grades the correct **call-plan + proof**, *not* the executed composed result,
+  and B1/B2/C1 are thin rungs (2–3 cases); the C2 case is honestly **refused** (Stage 5, unbuilt).
+- **Track 3 — bedrock-meter surface.** `../bedrock-meter` gained a cost-ascending router ladder with the
+  **tmct `$0` rung at rank 0 below nova-micro**; an end-to-end test meters an in-envelope request at
+  **£0** and escalates out-of-envelope to nova-micro (that repo: 73 green, unpushed).
+- **Track 4 — playtest.** Three frozen dialogue-flow transcripts (`test/chatflow-{coverage,history,
+  architecture}.test.mjs`) from routing dead-ends off the grammar wall.
+- **Track 5 — research.** `docs/references/planning/` gained Stage-2 intent-frames + Stage-5
+  goal-reasoner design notes + a BDI/Goal-Driven-Autonomy reference entry.
+
+**Next:** the C2 goal-reasoner (Stage 5) and Stage-2 imperative intent frames are the designed-but-
+unbuilt edge; the tier-4/tier-5 items in Phase LATER remain the long tail. See Phase 11 below and
+`HANDOVER.md` for the open follow-ups.
+
 ## The umbrella product definition (item 1)
 
 **A tolerant, ELIZA/PARRY-style chat, obsessed with software.** A best-efforts
@@ -279,11 +310,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 +345,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 +355,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 +370,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 +403,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 +436,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 +473,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 +545,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 +628,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 — LANDED)
+
+*(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.0",
+  "version": "0.8.0",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",
@@ -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: [] };

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}`;
@@ -1264,25 +1296,33 @@ async function curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon })
  *  the graph parser reads as a count. Null when the line isn't such a touch. The
  *  concept force is gated further downstream (a KNOWN, instance-bearing concept), so
  *  this only has to recognize the SHAPE, not vet the term. */
-function conceptTermOf(query, envelope) {
-  const base = metaTermOf(query, envelope);
-  if (base) return base;
+/** The VAGUE-TOUCH shapes ("tell me about X", "[and] what about X") — a concept
+ *  touch that is NOT the "what is a X" / "what does X mean" META shape. The meta shape
+ *  has its own established handling (a noun definition, a predicate definition, or the
+ *  honest ambiguity surround for a term that is BOTH a noun and a predicate — e.g.
+ *  "imports"), which the RELATION force must never preempt (frozen case
+ *  am-meta-imports). Gated downstream by CONCEPT_CLASS / RELATION_TERM, so a real
+ *  entity name declines here. */
+function vagueTouchTermOf(query) {
   const q = String(query).trim();
   const m = q.match(/^tell me about\s+(?:an?\s+)?(.+?)[?.!\s]*$/i)
-    // "[and/so/…] what about X" with no good discourse continuation — the concept
-    // KIND word is a concept touch, not a bare module lookup (DEAD-END 4). Gated
-    // downstream by CONCEPT_CLASS/RELATION_TERM, so a real entity name declines here.
     || q.match(/^(?:(?:and|so|but|ok|okay|now|then)\s+)*what about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i);
   return m ? m[1].trim() : null;
 }
 
-/** The RELATION term a vague touch names — reuses conceptTermOf's shapes ("what is
- *  X"/"what does X mean"/"tell me about X"/"what about X"), plus the relation-only
- *  openers the graph parser reads as something else: "what are the imports", "what
- *  calls are there", "what is calling". Null when the line isn't such a touch. Gated
- *  downstream by RELATION_TERM, so this only has to recognize the SHAPE. */
+function conceptTermOf(query, envelope) {
+  return metaTermOf(query, envelope) || vagueTouchTermOf(query);
+}
+
+/** The RELATION term a vague touch names — the VAGUE-touch shapes only ("tell me
+ *  about X", "what about X"), NOT the "what is a X"/"what does X mean" meta shape (a
+ *  relation term that is also a vocabulary word, like "imports", keeps its established
+ *  ambiguity/predicate-definition answer — frozen case am-meta-imports). Plus the
+ *  relation-only openers the graph parser reads as something else: "what are the
+ *  imports", "what calls are there", "what is calling". Null when the line isn't such a
+ *  touch. Gated downstream by RELATION_TERM, so this only has to recognize the SHAPE. */
 function relationTermOf(query, envelope) {
-  const base = conceptTermOf(query, envelope);
+  const base = vagueTouchTermOf(query);
   if (base) return base;
   const q = String(query).trim().toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
   let m;
@@ -1374,7 +1414,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
@@ -1390,7 +1430,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.
@@ -1430,8 +1475,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;
@@ -1503,12 +1559,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
@@ -1566,8 +1624,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));
@@ -1645,7 +1709,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);
 }

package/src/concept.mjs

@@ -213,6 +213,11 @@ export function composeConcept(graph, term, { definition = null, factRows = [] }
     instances: graphInstances.slice(0, MAX_EXAMPLES).map((i) => ({
       id: i.id, label: i.label, type: i.class,
     })),
+    // EVERY instance id (uncapped), for discourse-count anaphora ("count them" /
+    // "how many of those") over a truncated listing: `instances` is capped at
+    // MAX_EXAMPLES and the rest lives in `remainder` as prose labels, invisible to
+    // the counter — so a follow-up count would undercount without the full id set.
+    allInstanceIds: graphInstances.map((i) => i.id),
     // the un-shown instance labels + their plural noun, for the shell's "more"
     // pagination — empty when nothing was truncated.
     remainder: remainderLabels,

package/src/conformance.mjs

@@ -1,6 +1,6 @@
 // conformance.mjs — the Repository-Interface CONTRACT TEST SUITE as a reusable kit.
 //
-// PLAN_REPOSITORY_INTERFACE.md deliverable 3: an implementation is CONFORMANT iff it
+// archive/PLAN_REPOSITORY_INTERFACE.md deliverable 3: an implementation is CONFORMANT iff it
 // passes `runConformance(name, makeProvider)`. tmct's own fixture + bootstrap providers
 // pass it in `npm test`; an EXTERNAL producer (seonix) imports this kit from the
 // published package and runs the SAME suite against its native provider to claim