@polycode-projects/the-mechanical-code-talker 1.11.6 → 1.12.0

package/ROADMAP.md

@@ -51,12 +51,12 @@ getting silently traded away by inherited caution:
   and an NPC turn scheduler. Design-only.
 - **`PLAN_SYLLOGIST.md`** — retraction-aware consistency checking under a hard budget and trust
   tiers, the one open piece of the reasoning engine's research horizon. Design-only.
-- **`PLAN_HANOI.md`** — shipped in full, including the follow-ups: river-crossing (co-travel
+- **`archive/PLAN_HANOI.md`** — shipped in full, including the follow-ups: river-crossing (co-travel
   effects, the forbidden-together constraint frame, 7-crossing oracle) and planner-side
   consumption of `taught:` capability records (`/plan` in chat and bin). See its dated addenda.
 - **`PLAN_GUESS_NUMBER.md`** — the closed-loop (observe-and-replan) planning domain for the same
   kernels. Design-only.
-- **`PLAN_VIZ_LEDGER.md`** — shipped in full, including the follow-ups, all resolved by
+- **`archive/PLAN_VIZ_LEDGER.md`** — shipped in full, including the follow-ups, all resolved by
   operator decision 2026-07-15: the ledger IS the `tmct viz` surface (node-link page removed),
   `factAnswer`/`factReadBack` carry the additive `goal` field the dock renders, multi-valued
   has/can facts are exempt from `findContradictions`, and page weight is budgeted (~561 KB

package/bin/tmct.mjs

@@ -1235,6 +1235,17 @@ async function main() {
     }
     const { repo, config } = await resolveRuntimeConfig({ argv: rest });
     const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("../src/router/drive.mjs");
+    let ctx;
+    try {
+      ctx = await buildCapabilityPlanCtx({ config, memoryDir: repo });
+    } catch (e) {
+      process.stderr.write(`tmct plan: could not load the graph — ${e?.message || e}\n`);
+      process.exit(1);
+    }
+    // The toolset is read AFTER the ctx build: the memory store's taught:
+    // capability records only register there, so both the default toolset and
+    // an explicit --tools list (e.g. --tools "taught:move onto") see them —
+    // and a world goal refuses when its taught record is outside the toolset.
     const declared = declaredCapabilityNames();
     let tools = declared;
     if (toolsFlag) {
@@ -1245,17 +1256,6 @@ async function main() {
         process.exit(2);
       }
     }
-    let ctx;
-    try {
-      ctx = await buildCapabilityPlanCtx({ config, memoryDir: repo });
-    } catch (e) {
-      process.stderr.write(`tmct plan: could not load the graph — ${e?.message || e}\n`);
-      process.exit(1);
-    }
-    // The default (no --tools) toolset is re-read AFTER the ctx build: the
-    // memory store's taught: capability records only register there, and a
-    // world goal refuses when its taught record is outside the toolset.
-    if (!toolsFlag) tools = declaredCapabilityNames();
     try {
       const result = await runCapabilityPlan(request, tools, ctx);
       if (jsonFlag) {

package/package.json

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

package/src/chat.mjs

@@ -4252,6 +4252,7 @@ export async function helpText() {
     ["/memory [verbose]", "what tmct remembers: facts, utterances, sessions, folded blocks"],
     ["/focus <symbol>", "set the current focus (reused by 'it'/'this' and no-arg entity commands)"],
     ["/plan <request>", "the capability router: plan+execute a compound or maintenance-goal request (\"of the modules impacted by X, which are untested\", \"what most needs a test\")"],
+    ["/capabilities", "what /plan can plan over: the built-in graph tools plus your taught actions"],
     ["/narrate on|off", "verbose developer/debug mode: decision points, matched pattern, results+sources, goal per turn"],
     ["/help", "this list"],
     ["/exit", "leave the session (also Ctrl+C / Ctrl+D)"],
@@ -9263,6 +9264,7 @@ const GOAL_BY_COMMAND = {
   history: GOAL_BY_KIND.touches,
   exports: GOAL_BY_KIND.reexports,
   arch: "understand the overall architecture (package/module boundaries)",
+  capabilities: "see what /plan can plan over — built-in query tools and taught actions",
 };
 
 /** A slash-command → the mapped tool (or the /help, /focus, /narrate, unknown
@@ -9326,6 +9328,37 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     return mk(`focus set to ${ent.label}.`, { resolvedIds: [ent.id], newFocus: ent });
   }
 
+  // /capabilities — everything a /plan request can plan over: the built-in
+  // read-only graph-query tools, plus the taught action families read straight
+  // from this store (they only live in the registry inside a /plan request,
+  // so listing them means reading the rules, not the registry).
+  if (name === "capabilities") {
+    note(trace, "goal: see what /plan can plan over — built-in query tools and taught actions");
+    const { declaredCapabilityNames } = await import("./router/drive.mjs");
+    const { actionFamilies, capabilityFromActionRules } = await import("./router/taught.mjs");
+    const lines = [`read-only graph tools: ${declaredCapabilityNames().join(", ")}`];
+    let families = new Map();
+    if (memoryDir) {
+      try {
+        const { loadMemory } = await import("./memory/core.mjs");
+        families = actionFamilies(await loadMemory(memoryDir));
+      } catch { /* an unreadable store lists like an empty one */ }
+    }
+    if (!families.size) {
+      lines.push('taught actions: none yet — teach one ("you can move a disk onto a peg.") and /plan can use it.');
+    } else {
+      lines.push("taught actions (planned over, never dispatched):");
+      for (const [familyName, family] of [...families.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        const cap = capabilityFromActionRules(familyName, family);
+        const sig = cap.parameters
+          .map((p) => `${p.name}: ${p.classes.filter(Boolean).join("|") || "?"}`)
+          .join(", ");
+        lines.push(`  taught:${familyName} — ${sig}`);
+      }
+    }
+    return mk(lines.join("\n"));
+  }
+
   // /plan <request> — the capability router (src/router/*): plan+execute a
   // compound ("of the modules impacted by X, which are untested", "assess X
   // and then check Y") or maintenance-goal ("what most needs a test") request

package/src/ledger-viz.mjs

@@ -225,6 +225,38 @@ export function resolveAnsweredTerm(answerText, questionText, terms, normFn) {
   return (terms || []).some((t) => t && t.term === norm) ? norm : null;
 }
 
+/** Per-segment facet counts for the rows touching `focus`: each group's count
+ *  is computed against the OTHER groups' active filters (its own group's
+ *  selection is skipped), so a selected family narrows the provenance and
+ *  recency counts but never its own rail. `sel` holds the active multi-select
+ *  Sets ({prov, fam, rec}); `now` anchors the recency buckets. Self-contained
+ *  on purpose: its source is injected into the rendered page verbatim, so it
+ *  must close over nothing. */
+export function facetCounts(rows, focus, sel, now) {
+  const DAY = 86400000;
+  const recencyOf = (r) => {
+    const t = Date.parse(r.createdAt);
+    if (!Number.isFinite(t)) return "older";
+    const age = now - t;
+    return age < DAY ? "today" : age < 7 * DAY ? "this week" : "older";
+  };
+  const passes = (r, skip) =>
+    (skip === "prov" || !sel.prov.size || sel.prov.has(r.prov)) &&
+    (skip === "fam" || !sel.fam.size || sel.fam.has(r.family)) &&
+    (skip === "rec" || !sel.rec.size || sel.rec.has(recencyOf(r)));
+  const counts = { prov: {}, fam: {}, rec: {} };
+  for (const r of rows || []) {
+    if (!focus || (r.s !== focus && r.o !== focus)) continue;
+    if (passes(r, "prov")) counts.prov[r.prov] = (counts.prov[r.prov] || 0) + 1;
+    if (passes(r, "fam")) counts.fam[r.family] = (counts.fam[r.family] || 0) + 1;
+    if (passes(r, "rec")) {
+      const k = recencyOf(r);
+      counts.rec[k] = (counts.rec[k] || 0) + 1;
+    }
+  }
+  return counts;
+}
+
 /** One complete, self-contained document: the ledger, segment rail,
  *  worth-a-look panel, breadcrumb/search, two-hop minimap, and (when the
  *  memory-ask bundle is present) the ask-the-graph chat dock, all over the
@@ -376,6 +408,7 @@ ${hasMemChat ? `<script>\n${bundleStr}\n</script>` : ""}
 (function () {
   "use strict";
   const DAY = 86400000;
+  const facetCounts = ${facetCounts.toString()};
   const el = (id) => document.getElementById(id);
   const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
   const FAMS = ["is-a", "has", "can", "used-for", "rests-on", "role", "other"];
@@ -418,13 +451,11 @@ ${hasMemChat ? `<script>\n${bundleStr}\n</script>` : ""}
     return b;
   }
   function renderSegs() {
-    const mine = LEDGER.rows.filter((r) => focus && touches(r, focus));
+    const counts = facetCounts(LEDGER.rows, focus, sel, Date.now());
     const put = (id, group, values, labelOf, clsOf) => {
       const box = el(id); box.innerHTML = "";
       for (const v of values) {
-        const count = mine.filter((r) => passes(r, group) &&
-          (group === "prov" ? r.prov === v : group === "fam" ? r.family === v : recOf(r) === v)).length;
-        box.appendChild(segButton(group, v, labelOf(v), count, clsOf ? clsOf(v) : null));
+        box.appendChild(segButton(group, v, labelOf(v), counts[group][v] || 0, clsOf ? clsOf(v) : null));
       }
     };
     put("segProv", "prov", PROVS.map((p) => p[0]), (v) => PROVS.find((p) => p[0] === v)[1], (v) => "c-" + provKey(v));