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

package/src/corpus/templates.mjs

@@ -19,7 +19,7 @@ const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 export const TEMPLATES_FILE = join(PKG_ROOT, "data", "templates", "responses.jsonl");
 export const PHRASEBOOK_FILE = join(PKG_ROOT, "data", "phrasebook", "software-phrases.txt");
 
-// Registers (Phase 6, PLAN_FORMULAIC_COMPETENCE.md): `terse|friendly` are the
+// Registers (Phase 6, archive/PLAN_FORMULAIC_COMPETENCE.md): `terse|friendly` are the
 // conversational bands; `technical` is the C1 / technical-paper band whose
 // templates render item-5 mechanical conclusions (count / comparison /
 // superlative + the provenance we already compute) as advanced prose. A

package/src/finish.mjs

@@ -1,5 +1,5 @@
 // finish.mjs — Phase 7 response finishing: the segmentation IR seam.
-// (PLAN_RESPONSE_FINISHING.md, "The segmentation IR (lever 1)".)
+// (archive/PLAN_RESPONSE_FINISHING.md, "The segmentation IR (lever 1)".)
 //
 // The governing principle is fact-invariance BY CONSTRUCTION. An answer is a
 // list of typed spans, [{ type, text }, …], carried alongside the flat string

package/src/hash.mjs

@@ -1,6 +1,6 @@
 // hash.mjs — the single home for tmct's content-address hash.
 //
-// FNV-1a 32-bit is deliberately home-grown (see PLAN_DEPENDENCY_STRATEGY.md): it
+// FNV-1a 32-bit is deliberately home-grown (see archive/PLAN_DEPENDENCY_STRATEGY.md): it
 // must be synchronous, browser-safe, dependency-free, and — critically —
 // CROSS-VERSION STABLE, because fact ids are content-addressed by it and a fact's
 // id is its identity across the whole memory graph. Every library candidate fails

package/src/interpret/normalize.mjs

@@ -118,6 +118,33 @@ export const PHRASING_FRAMES = Object.freeze([
   { re: /^what\s+(?:defined|declared)\s+(?:the\s+)?(?:function\s+|method\s+|class\s+|module\s+|variable\s+|constant\s+)?(.+?)\??$/i, to: (m) => `where is ${m[1]} defined` },
   //   "where's X defined" (the "where's" contraction is not in the contraction table)
   { re: /^where'?s\s+(?:the\s+)?(.+?)\s+(defined|declared|located|implemented)\??$/i, to: (m) => `where is ${m[1]} ${m[2]}` },
+
+  // PREDICATIVE QUALIFIER → the ATTRIBUTIVE form the grammar already answers. The
+  // adjective-qualifier post-filters (ask-vocab.mjs QUALIFIERS: tested/untested,
+  // public/private, exported, static/abstract/constant, …) parse in the ATTRIBUTIVE
+  // slot — "untested modules", "public methods" — but a developer just as naturally
+  // asks the PREDICATIVE "which modules are untested" / "what functions are tested",
+  // which hit the grammar wall (and, worse, the wall's own hint SUGGESTED "which
+  // functions are tested" — a shape it could not then answer). Rewriting the
+  // predicative "<which|what> <kind> are <QUALIFIER>" to "<QUALIFIER> <kind>" routes
+  // it onto the working attributive filter. Closed to the known qualifier adjectives
+  // (not a general "… are X" catch), and the QUALIFIER must sit immediately after
+  // are/is, so "which modules are NOT tested" never matches here — that keeps its own
+  // set-complement handler (matchNegationSet, downstream in ask.mjs's parseNegation).
+  {
+    re: /^(?:which|what)\s+(?:the\s+|all\s+)?([a-z][a-z-]*?)\s+(?:are|is)\s+(public|private|protected|static|abstract|constant|exported|re-?exported|tested|covered|untested|uncovered)\??$/i,
+    to: (m) => `${m[2].toLowerCase()} ${m[1].toLowerCase()}`,
+  },
+
+  // CO-CHANGE → the "co-changes with" canonical the RELATIONS table answers. The
+  // cochange verb synonyms (ask-vocab.mjs) include "co-changes with" / "moves
+  // together with" / "tends to change together with", but NOT the plainest form a
+  // developer types — the one the README itself prints and the relation renders as:
+  // "what does X change together with" / "what changes together with X". Both hit a
+  // dead-end ("couldn't resolve one of the terms" / the grammar wall); rewriting them
+  // onto "what co-changes with X" routes them to the working change-coupling query.
+  { re: /^what\s+does\s+(.+?)\s+changes?\s+together\s+with\??$/i, to: (m) => `what co-changes with ${m[1]}` },
+  { re: /^what\s+changes?\s+together\s+with\s+(.+?)\??$/i, to: (m) => `what co-changes with ${m[1]}` },
 ]);
 
 /** Apply the phrasing frames (members-of-class + where-defined) — first match wins
@@ -132,7 +159,7 @@ export function applyPhrasingFrames(text) {
   return text;
 }
 
-// ---- §B1 negation — the SET-COMPLEMENT frame (Cycle 5, PLAN_CYCLE_4.md). Recognizes
+// ---- §B1 negation — the SET-COMPLEMENT frame (Cycle 5, archive/PLAN_CYCLE_4.md). Recognizes
 // a BARE set-negation query — "which X do not <verb> Y", "X that don't <verb> Y",
 // "modules not importing Y", "which X are not <qualifier>" — and returns a descriptor
 // {entWord, predicate} that ask.mjs's compositional grammar turns into a bounded

package/src/interpret/strategies/keywords.mjs

@@ -12,7 +12,7 @@ import {
 import { STOPWORDS } from "../normalize.mjs";
 import { VOCAB_WORDS, eligibleForCanon, fuzzyVocabWord } from "../fuzzy.mjs";
 
-// Reversible-passive detection (Cycle 6, PLAN_CYCLE_4.md): the passive auxiliaries that,
+// Reversible-passive detection (Cycle 6, archive/PLAN_CYCLE_4.md): the passive auxiliaries that,
 // together with an agent-marking "by", flip the active reading, and the wh-words that
 // mark a QUESTIONED agent ("by which classes" / stranded "who is X tested by"). Bare
 // "do/does/did" are deliberately EXCLUDED — "which X do not <verb> Y" is a NEGATION, not
@@ -176,7 +176,7 @@ export function parseKeywordSpot(text, nlp = null) {
     if (objText) return { shape: "when", entityType: null, modifier: "direct", kind: "touches", object: objText };
   }
 
-  // reversible passive (Cycle 6, PLAN_CYCLE_4.md): "PATIENT is VERBed BY AGENT" — an
+  // reversible passive (Cycle 6, archive/PLAN_CYCLE_4.md): "PATIENT is VERBed BY AGENT" — an
   // agent-marking "by" plus a passive auxiliary flips the active reading, so the AGENT
   // (after "by") is the edge SUBJECT and the PATIENT the edge OBJECT. Object-first
   // phrasing is otherwise read subject-first and the edge traversed backwards. Fires

package/src/providers/bootstrap.mjs

@@ -1,5 +1,5 @@
 // The BOOTSTRAP reference provider — the empty/degenerate graph a fresh repo
-// "contains" before anything is indexed. PLAN_REPOSITORY_INTERFACE.md deliverable
+// "contains" before anything is indexed. archive/PLAN_REPOSITORY_INTERFACE.md deliverable
 // 2: "bootstrap returns honest empties".
 //
 // It implements every Repository-Interface service over the empty bootstrap

package/src/providers/fixture.mjs

@@ -1,5 +1,5 @@
 // The FIXTURE reference provider — a small, real, self-contained code graph that
-// implements every Repository-Interface service. PLAN_REPOSITORY_INTERFACE.md
+// implements every Repository-Interface service. archive/PLAN_REPOSITORY_INTERFACE.md
 // deliverable 2: "the executable specification an external producer reads first".
 //
 // It is a degenerate provider in the sense that its graph is tiny and its source

package/src/providers/graph-service.mjs

@@ -1,5 +1,5 @@
 // The reference Repository-Interface service over a parsed code graph.
-// PLAN_REPOSITORY_INTERFACE.md — "the executable specification".
+// archive/PLAN_REPOSITORY_INTERFACE.md — "the executable specification".
 //
 // createGraphService(graph) returns a typed service object implementing EVERY
 // service in src/repository-interface.mjs over the `{ individuals, byId,

package/src/repository-interface.mjs

@@ -1,6 +1,6 @@
 // The Repository Interface — tmct's OWNED, versioned contract between "interpret
 // the query" (tmct, the brittle side) and "ask the graph for truth" (a provider,
-// the stable side). PLAN_REPOSITORY_INTERFACE.md.
+// the stable side). archive/PLAN_REPOSITORY_INTERFACE.md.
 //
 // tmct defines and versions this shape; a provider (seonix, a fixture, a browser
 // page) IMPLEMENTS it over its native graph. Both sides already agree on the

package/src/router/guardrail.mjs

@@ -0,0 +1,120 @@
+// src/router/guardrail.mjs — Stage 4 of the capability router
+// (PLAN_CAPABILITY_ROUTER.md): THE GUARDRAIL. Validate an EXTERNALLY-proposed
+// `tool_use` (e.g. an LLM's chosen call in the hybrid fast-path) against the
+// registry's declared preconditions, and DEFAULT-DENY anything outside the
+// declared, registered envelope. This is the precondition-checking half of the
+// STRIPS model: a call fires only when its preconditions are provably satisfied.
+//
+// WHAT IT PROVES — and what it deliberately does NOT.
+//   The guardrail proves RESOLVABILITY: the tool exists in the registry, it was
+//   declared, every arg-key is one the operator accepts, every required arg is
+//   present, and every `resolves(param, as)` precondition binds to a real graph
+//   entity (delegated to resolveObject — the same oracle Stage 1 uses).
+//
+//   It does NOT prove ANTECEDENT-CORRECTNESS. A cross-turn mis-binding — "it" ->
+//   the wrong Commit, say — produces a call whose symbol STILL resolves to a real
+//   entity, so it PASSES the guardrail. That is by design: binding-confidence
+//   across turns is the CHAT LEVER's job (pronoun/focus binding), not the
+//   guardrail's. A gate that leaned on Stage 4 for antecedent correctness would be
+//   trusting the wrong layer. The guardrail's contract is narrow and honest:
+//   "this symbol denotes SOMETHING real and the call is well-formed", never "this
+//   is the RIGHT something".
+//
+// DEFAULT-DENY: a tool name that is not a registered capability is denied outright
+// (identical to a hallucinated/invented tool). The intentionally-unregistered
+// unbounded tools (tmct_snippet/tmct_context*) are therefore denied here too — the
+// registry is the whole trust boundary.
+//
+// Pure over its inputs + ctx.resolve (the binding oracle). No network, no Date.now.
+
+import { capabilityByName, preconditionsOf, PRECOND } from "./registry.mjs";
+import { hallucinationsIn } from "../../agentbench/grade.mjs";
+
+/** Validate a proposed tool_use. Returns a glass-box verdict:
+ *    { ok, tool, denied:[{reason,detail}], steps:[{pred,ok,...}], provenance }
+ *  - ok=false with a `default-deny`/`undeclared`/`unknown-arg`/`missing-arg`
+ *    denial is a STRUCTURAL rejection (no graph needed).
+ *  - ok=false with an `unresolved` step is a BINDING rejection (a `resolves`
+ *    precondition whose term matched no entity, or matched ambiguously).
+ *  - ok=true means the call is RESOLVABLE + well-formed (NOT proven antecedent-
+ *    correct — see the file header).
+ *  `declaredNames` may be null to skip the declared-set check (validate against
+ *  the registry alone); pass it to also enforce the case/session toolset.
+ *  `ctx.resolve(term)` is the resolveObject oracle; omit it to skip binding proof
+ *  (structural-only validation). */
+export function guard(toolUse, declaredNames = null, ctx = {}) {
+  const name = toolUse?.name;
+  const input = toolUse && typeof toolUse.input === "object" && toolUse.input ? toolUse.input : {};
+  const denied = [];
+  const steps = [];
+
+  // 1. DEFAULT-DENY — unknown/unregistered tool is an automatic reject. Reuse the
+  //    grader's hallucination check as the single source of truth for structural
+  //    well-formedness (unknown-tool / undeclared / unknown-arg / missing-arg).
+  const declaredList = declaredNames ? [...declaredNames] : null;
+  const cap = capabilityByName(name);
+  if (!cap) {
+    denied.push({ reason: "default-deny", detail: `"${name ?? "(none)"}" is not a registered capability` });
+    return { ok: false, tool: name ?? null, denied, steps, provenance: "registry default-deny" };
+  }
+  // structural well-formedness against the registry (and the declared set when
+  // given — an undeclared-but-registered tool is still a policy denial).
+  const structural = hallucinationsIn({ name, input }, declaredList ?? [name]);
+  for (const p of structural) {
+    // when no declared set is supplied, an "undeclared" finding is not a real
+    // denial (we synthesised [name] as the set) — filter it out.
+    if (!declaredList && p.reason === "undeclared") continue;
+    denied.push(p);
+  }
+
+  // 2. PRECONDITION CHECK — the STRIPS safety gate, step by step (the proof).
+  for (const pre of preconditionsOf(name)) {
+    if (pre.pred === PRECOND.graphLoaded) {
+      // graph presence is the harness's responsibility; if a resolver is wired we
+      // treat graph-loaded as satisfied (resolveObject would throw without one).
+      steps.push({ step: "precondition", pred: pre.pred, ok: true });
+    } else if (pre.pred === PRECOND.anyPresent) {
+      const ok = pre.params.some((k) => input[k] !== undefined && input[k] !== null && String(input[k]).trim() !== "");
+      steps.push({ step: "precondition", pred: pre.pred, params: pre.params, ok });
+      if (!ok) denied.push({ reason: "missing-arg", detail: `${name} needs one of ${pre.params.join("|")}` });
+    } else if (pre.pred === PRECOND.resolves) {
+      const term = input[pre.param];
+      const present = term !== undefined && term !== null && String(term).trim() !== "";
+      if (!present) {
+        // a missing required arg is already flagged structurally; record the step.
+        steps.push({ step: "precondition", pred: pre.pred, param: pre.param, value: null, ok: false });
+        continue;
+      }
+      // DELEGATE to resolveObject (the binding oracle). No oracle wired → we can
+      // only assert the arg is PRESENT, not that it binds (structural mode).
+      if (!ctx.resolve) {
+        steps.push({ step: "precondition", pred: pre.pred, param: pre.param, value: term, ok: true, note: "structural-only (no resolver wired)" });
+        continue;
+      }
+      const r = ctx.resolve(String(term));
+      const resolvedOk = Boolean(r && r.match && !r.ambiguous);
+      steps.push({
+        step: "precondition", pred: pre.pred, param: pre.param, value: term,
+        ok: resolvedOk,
+        ...(r && r.match ? { boundTo: r.match.label, boundClass: r.match.class ?? null, tier: r.tier ?? null } : {}),
+        ...(r && r.ambiguous ? { ambiguous: true } : {}),
+      });
+      if (!resolvedOk) {
+        denied.push({
+          reason: "unresolved",
+          detail: r && r.ambiguous
+            ? `${name}.${pre.param}="${term}" is ambiguous (narrow it)`
+            : `${name}.${pre.param}="${term}" resolves to no graph entity`,
+        });
+      }
+    }
+  }
+
+  const ok = denied.length === 0;
+  return { ok, tool: name, denied, steps, provenance: ok ? "resolvable (NOT proven antecedent-correct)" : "denied" };
+}
+
+/** Convenience boolean: does a proposed tool_use PASS the guardrail? */
+export function admits(toolUse, declaredNames = null, ctx = {}) {
+  return guard(toolUse, declaredNames, ctx).ok;
+}

package/src/router/planner.mjs

@@ -0,0 +1,168 @@
+// src/router/planner.mjs — Stage 3 of the capability router
+// (PLAN_CAPABILITY_ROUTER.md): THE PLANNER. Compose a bounded, ordered plan of
+// tool calls for a multi-step request, over the SAME operators Stage 1 resolves
+// single-shot. Pure-JS POP/HTN + a Steel & Ho monitor-and-replan loop under a
+// HARD budget — sound/complete INSIDE the declared operator model, honest-refuse
+// (escalate) for novelty outside it. Deterministic, no-LLM, glass-box.
+//
+// THE MODEL, mapped to the literature:
+//   - HTN decomposition (NONLIN/SHOP2): a compound request is decomposed into an
+//     ORDERED list of sub-goals by declared METHODS — the sequencing connectives
+//     ("... then ...", "... and then ...") and the two closed recipes we author:
+//     the CONDITIONAL method ("if <check>, <action> [instead]") and the
+//     RELATIVE-FILTER method ("of the <set> <rel> X, which are <Y>"). Each leaf
+//     sub-goal is resolved by Stage 1 (resolveOne) — the primitive operator.
+//   - POP causal links (partial-order planning): each step's proof records the
+//     PRODUCER -> CONDITION -> CONSUMER link. An independent step's producer is
+//     the grounded graph (graph-loaded); a THREADED step (one whose entity came
+//     from a prior step via anaphora — "its subclasses", "describe it") records
+//     the prior STEP as its producer. That link IS the proof chain (grade.mjs's
+//     connectedness check reads it), never a flat ok-list. Least commitment: we
+//     only order what the connectives actually order.
+//   - Steel & Ho monitor-and-replan: after each call we read the tool_result;
+//     a failed sub-goal (an unresolvable entity / an operator that errors) forces
+//     an honest STOP (refuse/escalate) rather than pressing on with a broken
+//     chain. Bounded depth + a hard step counter GUARANTEE termination — no
+//     unbounded search can ever wedge the caller (the harness also caps us).
+//
+// THE OPEN-WORLD BOUNDARY, named honestly: novelty the declared methods + operators
+// do not cover (a sub-goal that resolves to nothing, a connective we do not model)
+// is REFUSED/ESCALATED, not guessed. Sound/complete is claimed only INSIDE the
+// declared world.
+
+import { resolveOne, extractEntity } from "./resolver.mjs";
+
+// Hard budget — the planner may emit at most this many steps; a request that
+// decomposes to more is REFUSED (escalate) rather than searched. Guarantees
+// termination independent of the harness backstop.
+export const MAX_STEPS = 8;
+
+const PRONOUN_RE = /\b(?:it|its|them|those|these|that|their)\b/i;
+
+/** HTN decomposition — turn a request into an ORDERED list of leaf sub-goals.
+ *  Returns { method, segments:[{ text, role, thread }] }:
+ *    - role "check"  — a conditional antecedent (a test whose call still emits)
+ *    - role "action" — a plain sub-goal
+ *    - thread:true   — the segment carries an anaphor to bind from a prior step
+ *  A single segment (no connective) means "not multi-step" (the driver hands
+ *  those to resolveOne directly). Pure. */
+export function decompose(request) {
+  const raw = String(request || "").trim();
+
+  // METHOD 1 — the CONDITIONAL recipe: "if <check>, <action> [instead]".
+  const cond = raw.match(/^if\s+(.+?),\s*(.+?)(?:\s+instead)?$/i);
+  if (cond) {
+    return {
+      method: "conditional",
+      segments: [
+        { text: cond[1].trim(), role: "check", thread: PRONOUN_RE.test(cond[1]) },
+        { text: cond[2].trim(), role: "action", thread: PRONOUN_RE.test(cond[2]) },
+      ],
+    };
+  }
+
+  // METHOD 2 — the RELATIVE-FILTER recipe: "of the <set> <rel> X, which are <Y>".
+  // Decomposes to [produce the <set> (the <rel> over X), filter it by <Y>].
+  const rel = raw.match(/^of\s+the\s+(.+?),\s*which\s+(?:are\s+)?(.+?)$/i);
+  if (rel) {
+    return {
+      method: "relative-filter",
+      segments: [
+        { text: rel[1].trim(), role: "action", thread: false },
+        { text: `which are ${rel[2].trim()}`, role: "action", thread: true },
+      ],
+    };
+  }
+
+  // METHOD 3 — SEQUENCING: split on the ordered connectives. Least commitment:
+  // we only split where a connective actually is.
+  const parts = raw.split(/\s*(?:,\s*then\s+|,\s+and\s+then\s+|\s+and\s+then\s+|\s+then\s+|,\s+|\s+and\s+)\s*/i)
+    .map((s) => s.replace(/^(?:then\s+|and\s+then\s+|and\s+|also\s+|check\s+|next\s+)/i, "").trim())
+    .filter(Boolean);
+  const segments = parts.map((text) => ({ text, role: "action", thread: PRONOUN_RE.test(text) }));
+  return { method: segments.length > 1 ? "sequence" : "single", segments };
+}
+
+/** True iff the request is multi-step (the planner owns it); else the driver
+ *  routes it to the single-shot resolver. */
+export function isMultiStep(request) {
+  return decompose(request).segments.length > 1;
+}
+
+/** Substitute a bound anaphor: replace a bare pronoun with the prior step's
+ *  entity label so the leaf resolver can bind it ("its subclasses" + Widget ->
+ *  "Widget subclasses"; "describe it" + fnAlpha -> "describe fnAlpha"). */
+function bindAnaphor(text, lastEntity) {
+  if (!lastEntity) return text;
+  return text.replace(PRONOUN_RE, lastEntity);
+}
+
+/** A conditional ANTECEDENT that tests a SPECIFIC entity's coverage ("X has no
+ *  tests", "fnAlpha is untested") is the CHECK operator tmct_tests_for over that
+ *  entity — NOT the no-arg tmct_untested (which lists the whole codebase). Rewrite
+ *  it to the terse "tests <entity>" command form so the leaf resolver binds the
+ *  entity. A check with no coverage predicate is left untouched. */
+function rewriteCheck(text, lastEntity) {
+  if (!/\b(?:untested|tested|no\s+tests?|has\s+no\s+tests?|tests?|coverage|covered)\b/i.test(text)) return text;
+  const entity = extractEntity(text) || lastEntity;
+  return entity ? `tests ${entity}` : text;
+}
+
+const refuse = (why, driver) => ({ calls: [], refused: true, terminated: true, proof: [], driver, why });
+
+/** Plan + execute a multi-step request. Returns a loopResult
+ *    { calls, refused, terminated, proof, why, driver, observed }
+ *  with a POP causal-link proof chain. Steel & Ho: each step is monitored; a
+ *  failed sub-goal STOPS the plan honestly (refuse/escalate). Bounded by
+ *  MAX_STEPS + a hard step counter. `driver` labels the row.
+ *
+ *  ctx: { dispatch(name,input)->{ok,text,resolved?}, resolve(term)->resolveObject } */
+export async function plan(request, declaredNames, ctx, { driver = "resolver-0.8.0" } = {}) {
+  const { method, segments } = decompose(request);
+  if (segments.length > MAX_STEPS) {
+    return refuse(`plan would need ${segments.length} steps (> budget ${MAX_STEPS}) — escalate`, driver);
+  }
+
+  const calls = [];
+  const proof = [];
+  const why = [`HTN method: ${method} — ${segments.length} sub-goal(s)`];
+  let lastEntity = null; // the most-recent bound entity label (for anaphora threading)
+  let steps = 0;
+
+  for (let i = 0; i < segments.length; i += 1) {
+    if (steps >= MAX_STEPS) return refuse("step budget exhausted mid-plan — escalate", driver);
+    steps += 1;
+    const seg = segments[i];
+    let text = seg.thread ? bindAnaphor(seg.text, lastEntity) : seg.text;
+    if (seg.role === "check") text = rewriteCheck(text, lastEntity);
+
+    const r = await resolveOne(text, declaredNames, ctx, { execute: true });
+    if (r.refused) {
+      // Steel & Ho: an unresolvable sub-goal breaks the causal chain — STOP
+      // honestly (escalate), never emit a partial/guessed plan.
+      return refuse(`sub-goal ${i + 1} ("${text}") did not resolve: ${r.reason}`, driver);
+    }
+
+    calls.push(r.selected);
+    // POP causal link: the producer is the prior step when this step THREADED an
+    // anaphor from it; otherwise the grounded graph. Its condition is the arg the
+    // step needed. This is the "why step i" edge, not a flat ok.
+    const producer = seg.thread && i > 0 ? `step-${i}` : "graph";
+    const boundLabel = r.resolved?.label ?? Object.values(r.selected.input || {})[0] ?? null;
+    proof.push({ step: "causal-link", producer, condition: boundLabel, consumer: `step-${i + 1}:${r.selected.name}`, role: seg.role, ok: true });
+    for (const s of r.proof) proof.push({ ...s, ofStep: i + 1 });
+
+    if (r.resolved?.label) lastEntity = r.resolved.label;
+    why.push(...(r.why || []).map((w) => `[${i + 1}] ${w}`));
+  }
+
+  return {
+    calls,
+    refused: false,
+    terminated: true,
+    proof,
+    driver,
+    why,
+    observed: `plan(${method}): ${calls.map((c) => c.name).join(" -> ")}`,
+  };
+}