Preserve quantity, relation and conversation meaning in legacy runtime paths

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_operator_specs_v1.py

@@ -198,33 +198,63 @@ def _gcd_ref(a):
 
 
 # ── 3. base conversion ────────────────────────────────────────────────────────
-# fn is repeated divmod; ref is positional expansion of the digits it produced.
-_BASE_RX = re.compile(
-    r'\b(?:convert|write|express)?\s*(-?\d+)\s*(?:from\s*)?(?:base\s*(\d+))?\s*'
-    r'(?:in|to|into)\s*(?:base\s*)?(\d+|binary|hex|hexadecimal|octal|decimal)\b', re.I)
+# The parser binds the original digits and source base. The function decodes
+# with int(); the reference independently expands source digits positionally.
 _BASE_NAME = {'binary': 2, 'hex': 16, 'hexadecimal': 16, 'octal': 8, 'decimal': 10}
+_BASE_ATOM = r'(?:base\s*\d+|binary|hexadecimal|hex|octal|decimal)'
+_BASE_RX = re.compile(
+    r'^\s*(?:(?:convert|write|express|what\s+is)\s+)?'
+    r'(?:(?P<prefix>' + _BASE_ATOM + r')\s+)?'
+    r'(?P<digits>[+-]?[0-9a-z]+)'
+    r'(?:\s+(?:(?:from|in)\s+)?(?P<source>' + _BASE_ATOM + r'))?'
+    r'\s+(?:in|to|into|as)\s+(?P<target>' + _BASE_ATOM + r'|\d+)'
+    r'\s*[.?!]?\s*$', re.I | re.ASCII)
 _DIGITS = '0123456789abcdefghijklmnopqrstuvwxyz'
 
 
 def _base_parse(s):
-    m = _BASE_RX.search(s)
+    m = _BASE_RX.fullmatch(s)
     if not m:
-        raise NotOurs('no number and target base here')
-    n = int(m.group(1))
-    frm = int(m.group(2)) if m.group(2) else 10
-    tgt = m.group(3).lower()
-    to = _BASE_NAME.get(tgt, None)
-    if to is None:
-        to = int(tgt)
-    if not (2 <= to <= 36) or not (2 <= frm <= 36):
-        raise OutOfFragment('I convert between base 2 and base 36 only')
-    if n < 0:
+        raise NotOurs('no complete integer base conversion here')
+
+    def base(token):
+        token = token.lower()
+        value = _BASE_NAME.get(token)
+        if value is None:
+            numeral = re.sub(r'^base\s*', '', token)
+            if len(numeral) > 3:
+                raise OutOfFragment('I convert between base 2 and base 36 only')
+            value = int(numeral)
+        if not 2 <= value <= 36:
+            raise OutOfFragment('I convert between base 2 and base 36 only')
+        return value
+
+    sources = [base(token) for token in (m['prefix'], m['source']) if token]
+    raw = m['digits'].lower()
+    if raw.startswith('-'):
         raise OutOfFragment('I convert non-negative whole numbers only')
-    return {'n': n, 'frm': frm, 'to': to}
+    raw = raw.lstrip('+')
+    # A conventional literal prefix is source evidence, not a digit to discard.
+    # Explicit bases above 16 may use x as a digit; only infer prefixes when no
+    # explicit source is supplied, or that source matches the prefix convention.
+    literal = {'0b': 2, '0o': 8, '0x': 16}.get(raw[:2])
+    if literal is not None and (not sources or all(b == literal for b in sources)):
+        sources.append(literal)
+        raw = raw[2:]
+    elif literal is not None and sources and sources[0] in (2, 8, 10, 16):
+        raise OutOfFragment('the literal prefix conflicts with the stated source base')
+    if len(set(sources)) > 1:
+        raise OutOfFragment('the stated source bases disagree')
+    frm = sources[0] if sources else 10
+    to = base(m['target'])
+    if not raw or len(raw) > 128 or any(_DIGITS.index(c) >= frm for c in raw):
+        raise OutOfFragment('I need 1 to 128 valid digits in the stated source base')
+    n = int(raw, frm)
+    return {'n': n, 'digits': raw, 'frm': frm, 'to': to}
 
 
 def _base_fn(a):
-    n, steps, out = a['n'], [], ''
+    n, steps, out = int(a['digits'], a['frm']), [], ''
     if n == 0:
         return '0', ['0 in any base is 0']
     while n:
@@ -235,8 +265,13 @@ def _base_fn(a):
 
 
 def _base_ref(a):
-    """Independent: build with a positional table, then check by expanding it."""
-    n = a['n']
+    """Expand original source digits, then encode using a positional table.
+
+    This does not share int() source decoding or repeated output division with
+    the primary function. Both still depend on the same untrusted parse.
+    """
+    n = sum(_DIGITS.index(digit) * a['frm'] ** power
+            for power, digit in enumerate(reversed(a['digits'])))
     if n == 0:
         return '0'
     digits, powers = [], []
@@ -418,8 +453,9 @@ SPECS = [
      'parse': _base_parse, 'fn': _base_fn, 'ref': _base_ref,
      'render': lambda a, v, s: '%d in base %d is %s.' % (a['n'], a['to'], v),
      'warrant': 'computation',
-     'independence': 'moderate: repeated division against positional expansion; '
-                     'both walk the same digits, in opposite directions',
+     'independence': 'moderate: int source decoding and repeated output division '
+                     'against positional source expansion and output encoding; '
+                     'both still depend on the same untrusted parse',
      'fragment': 'non-negative whole numbers, bases 2 to 36'},
 
     {'name': 'statistics', 'family': 'measurement',

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_release_runtime_ao.py

@@ -22,6 +22,16 @@ import re
 
 from oracle_release_runtime_an import OracleReleaseRuntimeAN
 
+# Untrusted grammar guard: in "does it take/cost ... to <action>", it
+# may be a grammatical subject rather than an entity from the conversation.
+# Decline substitution for that token; other references remain eligible. The
+# match stays within a clause and accepts decimal amounts before the infinitive.
+DUMMY_IT = re.compile(
+    r"\b(?:does|did|will|would|can|could|should|has|had)\s+(?P<it>it)\s+"
+    r"(?:take|taken|cost)\s+"
+    r"(?:(?:\d+(?:\.\d+)?\s+(?:milliseconds?|seconds?|minutes?|hours?|days?|weeks?|"
+    r"months?|years?|dollars?|euros?|pounds?)|[$€£]\d+(?:\.\d+)?)\s+)?"
+    r"to\s+[a-z]", re.I)
 DEICTIC = re.compile(r"\b(it|there|that|this|its|they|them|those|these|the same)\b", re.I)
 ELLIPSIS = re.compile(r"^(?:and|what about|the same for)\s+(?P<t>.+?)\??$", re.I)
 BARE = re.compile(r"^(?:the\s+)?[a-z][a-z \-']{2,40}$", re.I)
@@ -41,6 +51,17 @@ PREDICATE_OF = {
 }
 
 
+def referential_deictic(text):
+    """First eligible reference, excluding only take/cost-infinitive dummy it.
+
+    This does not claim to parse all English expletives. Skipping an ambiguous
+    token leaves the original question available to the unchanged handler.
+    """
+    dummy_spans = {match.span("it") for match in DUMMY_IT.finditer(text)}
+    return next((match for match in DEICTIC.finditer(text)
+                 if match.span() not in dummy_spans), None)
+
+
 class OracleReleaseRuntimeAO(OracleReleaseRuntimeAN):
     """Conversions are applied ONLY when the unchanged chain would not answer."""
 
@@ -103,10 +124,11 @@ class OracleReleaseRuntimeAO(OracleReleaseRuntimeAN):
             if not CONTINUATION.match(s):
                 return f"Summarize {s.strip()}.", "ELLIPSIS_COMPLETION"
         topic = self._live_topic(session_id)
-        if topic and DEICTIC.search(s):
+        reference = referential_deictic(s)
+        if topic and reference:
             if low in PREDICATE_OF:
                 return PREDICATE_OF[low].format(t=topic), "REFERENT_SUBSTITUTION"
-            return DEICTIC.sub(topic, s, count=1), "REFERENT_SUBSTITUTION"
+            return s[:reference.start()] + topic + s[reference.end():], "REFERENT_SUBSTITUTION"
         return None, None
 
     def chat(self, text: str, session_id: str = "default") -> dict:

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_release_runtime_w442.py

@@ -130,14 +130,34 @@ class OracleReleaseRuntimeW442(_Base):
         numbers = {t for t in terms if t.isdigit()}
         terms_stem = [_stem(t) for t in terms]
         best = None
+        covered_verdicts = []
         for sent in _sentences(passage):
             pool = set(_stem(t) for t in _toks(sent))
             ok, cov, via = self._r436_covered(terms, terms_stem, numbers, pool)
             if ok:
+                # Every covering sentence matters: selecting the first tied
+                # sentence can silently choose one of conflicting versions.
+                vt = set(terms) | set(terms_stem) | {_stem(a) for _, a in via} | {a for _, a in via}
+                candidate_verdict, _ = self._r434_verdict(sent, vt, terms_stem, q)
+                if candidate_verdict is not None:
+                    covered_verdicts.append((cov, candidate_verdict, sent))
                 hits = sum(1 for t in terms_stem if t in pool)
                 if best is None or hits > best[0]:
                     best = (hits, sent, cov, via)
         out = dict(res)
+        # A partial lexical match may concern another subject (e.g. Cedar
+        # Archive rather than Lumen Archive). It must not veto a fully
+        # covered answer. Aliases count as covered, as in the existing reader.
+        best_coverage = best[2] if best is not None else 0.0
+        conflicting_candidates = [(v, sentence) for coverage, v, sentence in covered_verdicts if coverage >= best_coverage]
+        settled_verdicts = {v for v, _ in conflicting_candidates}
+        if len(settled_verdicts) > 1:
+            conflict = self._r434_receipt(out, res,
+                'The passage contains covering sentences with conflicting answers, so I will not choose a version.',
+                'conflicting_covering_sentences')
+            conflict['references'] = [{'id': 'passage', 'text': sentence}
+                                      for _, sentence in conflicting_candidates]
+            return conflict
         if best is None:
             return self._r434_receipt(out, res, 'I read the passage and the question but found no sentence that covers the question in full, so I will not guess.', 'no_covering_sentence')
         _, sent, cov, via = best

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_release_runtime_w468.py

@@ -33,6 +33,14 @@ try:
 except Exception:  # noqa: BLE001
     _ir = None
 
+# Untrusted bounded grammar guard, kept equal to AO without importing its
+# runtime chain. Both binding and clarification exclude the same dummy token.
+DUMMY_IT = re.compile(
+    r"\b(?:does|did|will|would|can|could|should|has|had)\s+(?P<it>it)\s+"
+    r"(?:take|taken|cost)\s+"
+    r"(?:(?:\d+(?:\.\d+)?\s+(?:milliseconds?|seconds?|minutes?|hours?|days?|weeks?|"
+    r"months?|years?|dollars?|euros?|pounds?)|[$€£]\d+(?:\.\d+)?)\s+)?"
+    r"to\s+[a-z]", re.I)
 POINTER = re.compile(r"\b(it|its|that|this|they|them|those|these)\b", re.I)
 DEICTIC = re.compile(r"\b(?:the|that|this)\s+(?:thing|one|place|stuff|topic|subject|idea|person|guy|animal|city|country)"
                      r"(?:\s+(?:with|from|about|of|in|on)\s+(?:the\s+)?[a-z][\w\-]*(?:\s+[a-z][\w\-]*)?)?\b", re.I)
@@ -96,6 +104,20 @@ def from_thread(question, subject, replies, year_now):
     return None
 
 
+def _referential_pointer(text):
+    """One genuine pointing phrase/token, preserving later refs after dummy it.
+
+    Take/cost-infinitive grammar may use it without any prior entity. Leave that
+    token to the original reader; this is not a general English pronoun parser.
+    """
+    phrase = DEICTIC.search(text)
+    if phrase:
+        return phrase
+    dummy_spans = {match.span("it") for match in DUMMY_IT.finditer(text)}
+    return next((match for match in POINTER.finditer(text)
+                 if match.span() not in dummy_spans), None)
+
+
 class OracleReleaseRuntimeW468(_Base):
 
     def _r468_thread(self, sid):
@@ -148,19 +170,17 @@ class OracleReleaseRuntimeW468(_Base):
             del th[:-MAX_THREAD]
 
     def _r468_bind(self, text, subject):
-        m = DEICTIC.search(text)
-        if m:
-            return text[:m.start()] + subject + text[m.end():]
-        m = POINTER.search(text)
+        m = _referential_pointer(text)
         if m:
-            word = m.group(1).lower()
+            word = m.group(0).lower()
             rep = subject + "'s" if word == "its" else subject
             return text[:m.start()] + rep + text[m.end():]
         return None
 
     def _r468_door(self, text, sid, res):
         thread = self._r468_thread(sid)
-        points = bool(DEICTIC.search(text) or POINTER.search(text))
+        reference = _referential_pointer(text)
+        points = reference is not None
         named = self._r468_subjects(text)
         if points and thread and not named:
             subject = thread[-1]
@@ -197,13 +217,13 @@ class OracleReleaseRuntimeW468(_Base):
                     out = dict(res)
                     out.update({"status": "withheld", "path": "door:bound|vessel:receipt",
                                 "response": "I took \"%s\" to mean %s, but I have no attested answer to that about %s."
-                                            % ((DEICTIC.search(text) or POINTER.search(text)).group(0), subject, subject),
+                                            % (reference.group(0), subject, subject),
                                 "provenance": {"kind": "dialogue_state",
                                                "r468_door": {"act": "bound_no_answer", "subject": subject,
                                                              "rewritten": rewritten}}})
                     return out
         # ASK: a specific question, naming what could not be resolved and what this conversation has raised
-        unresolved = (DEICTIC.search(text) or POINTER.search(text))
+        unresolved = reference
         phrase = unresolved.group(0) if unresolved else None
         offers = list(reversed(thread[-3:]))
         if phrase and offers:

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_release_runtime_w488.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 """oracle_release_runtime_w488 - WORD PROBLEMS: single-step prose read into an equation by a stored schema.
 
+This Python routing shim is untrusted; its checks are not proof or admission authority.
+
 The math organ (v1/v2) declines a word problem ("the quantities must be translated into equations first"). This fold
 connects word_problems_v1 (sha 4c0c60b1): each SCHEMA is a stored form - trigger words, the TYPED quantities it needs
 (money, percent, time, length, mass, volume; read with their units), and a formula - and it fires only when every
@@ -34,6 +36,7 @@ def _fmt(v, unit):
         return "$%s" % ("{:,.2f}".format(v) if v % 1 else "{:,.0f}".format(v))
     if unit == "%":
         return "%s%%" % ("%g" % round(v, 4))
+    unit = unit.replace("^2", "²").replace("^3", "³")
     return ("%g" % round(v, 6)) + ((" " + unit) if unit and unit not in ("sq", "cu") else
                                    (" square units" if unit == "sq" else (" cubic units" if unit == "cu" else "")))
 
@@ -46,13 +49,23 @@ class OracleReleaseRuntimeW488(_Base):
             return out
         a = _run(_wp.answer, text)
         if not a:
-            return out
+            explain = getattr(_wp, 'explain_refusal', None)
+            reason = _run(explain, text) if callable(explain) else None
+            if not reason:
+                return out
+            new = dict(out)
+            new.update({'status': 'clarification', 'path': 'organ:math>word:%s' % reason['reason'],
+                        'response': reason['response'],
+                        'provenance': {'kind': 'word_problem_refusal', 'schema': reason['schema'],
+                                       'reason': reason['reason'], 'conflict': reason['conflict'],
+                                       'parent_path': str(out.get('path', '')), 'parent_status': out.get('status')}})
+            return new
         body = ("[ev:derived] %s. Read as %s: %s. Checked: every quantity the formula needs was found with its unit, "
                 "and the question asks for what the formula gives." % (_fmt(a["value"], a["unit"]),
                                                                         a["schema"].replace("_", " "),
                                                                         "; ".join(a["steps"])))
         new = dict(out)
         new.update({'status': 'answered', 'path': 'organ:math>word:%s' % a['schema'], 'response': body,
-                    'provenance': {'kind': 'organ_word_problem', 'schema': a['schema'], 'value': a['value'],
+                    'provenance': {'kind': 'organ_word_problem', 'schema': a['schema'], 'value': a['value'], 'unit': a['unit'],
                                    'parent_path': str(out.get('path', '')), 'parent_status': out.get('status')}})
         return new

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_release_runtime_w534.py

@@ -16,6 +16,9 @@ in both variants - bar <= 2) and CONVERSATION TEST 2 (run once, head w533). Two
      to. Here the turn is resolved FIRST (the same engine, chat_context_v2.rewrite), the whole stack is asked the
      standalone question, and the conversation state is updated from the FINAL answer (its receipt names the entity).
      A turn the engine splits into parts, or cannot resolve, goes down exactly as typed.
+A last-question recall may pass G2 only when its complete reply and turn references match
+the same session's dialogue record captured before this turn. This does not authorize
+guessing personal facts or answering an additional private question.
 Every guard WITHHOLDS with its reason; nothing here invents an answer. The fold imports no runtime other than its parent;
 the conversation engine is called through its own public functions (rewrite, update, split_parts)."""
 from __future__ import annotations
@@ -64,6 +67,37 @@ def private_state(q):
     return bool(PRIVATE.search(q)) and not QUANTITY.search(q)
 
 
+# A whole request for the last recorded question/utterance, not a substring in
+# a compound private-state request. First-question/history-list semantics are
+# deliberately outside this exception: the dialogue organ selects the last turn.
+LAST_TURN = re.compile(r"\s*(?:what\s+did\s+i\s+(?:(?:just|last)\s+)?(?:ask|say)(?:\s+you)?|"
+                       r"what\s+was\s+my\s+(?:last|previous)\s+question)\s*[?.!]*\s*", re.I)
+
+
+def recorded_history_reply(q, out, expected):
+    """An exact match to a same-session reply captured before the parent ran.
+
+    Path/citation strings alone are not authority. The caller obtains expected
+    from the dialogue organ's pure read of its current, bounded session history.
+    This Python check does not prove the authenticity of that in-memory history.
+    """
+    if not LAST_TURN.fullmatch(q) or not isinstance(expected, dict):
+        return False
+    if expected.get("kind") != "discourse:asked_last":
+        return False
+    turns = expected.get("turns") or []
+    provenance = out.get("provenance")
+    references = [{"id": "session:turn %d" % turn, "text": "this conversation, turn %d" % turn,
+                   "role": "discourse"} for turn in turns]
+    return (out.get("path") == "organ:dialogue>discourse:asked_last"
+            and out.get("response") == expected.get("response")
+            and out.get("references") == references
+            and isinstance(provenance, dict)
+            and provenance.get("kind") == "organ_dialogue"
+            and provenance.get("move") == expected["kind"]
+            and provenance.get("turns") == turns)
+
+
 def premise_years(q):
     m = PREMISE.match(q)
     if not m or _EL is None:
@@ -98,7 +132,7 @@ def _withhold(out, rule, reason):
     return new
 
 
-def final_guards(q, out):
+def final_guards(q, out, history_reply=None):
     """the w532 guards, on the FINAL answer of any route"""
     if not isinstance(out, dict) or str(out.get("status", "")) != "answered":
         return out
@@ -107,7 +141,7 @@ def final_guards(q, out):
         return out
     if "specialist" in path and sign_dropped(q, reply):
         return _withhold(out, "G1_sign_kept", REASON["G1_sign_kept"])
-    if private_state(q):
+    if private_state(q) and not recorded_history_reply(q, out, history_reply):
         return _withhold(out, "G2_private_state", REASON["G2_private_state"])
     try:
         pm = premise_years(q)
@@ -131,10 +165,19 @@ class OracleReleaseRuntimeW534(_Base):
                         standalone = s
             except Exception:  # noqa: BLE001 - an engine failure leaves the turn exactly as typed
                 standalone = None
+        history_reply = None
+        if LAST_TURN.fullmatch(standalone or q):
+            try:
+                # DialogueOrgan.answer only reads its bounded session log. Read
+                # before the parent appends this turn, including on an empty log.
+                dialogue = self._c480_dialogue()
+                history_reply = dialogue.answer(standalone or q, session_id) if dialogue else None
+            except Exception:  # noqa: BLE001 - missing history keeps the existing private-state guard
+                pass
         out = super().chat(standalone or q, session_id=session_id)
         if not isinstance(out, dict):
             return out
-        out = final_guards(standalone or q, out)
+        out = final_guards(standalone or q, out, history_reply)
         if standalone:
             out = dict(out)
             if not str(out.get("path", "")).startswith("chat:"):

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_release_runtime_w557.py

@@ -73,7 +73,7 @@ ROUTE_SPELLING = [
 # what an answer may stand on and still become state: a citation or source tag, a proof, or a checked route
 CITED = re.compile(r"\[[^\]\s]{2,}\]")
 CHECKED = ("specialist_call", "specialist_after_guard", "owner_first", "family_precedence", "network", "compute:", "organ:math",
-           "op:", "verified:", "algebra:", "deduce:")
+           "op:", "verified:", "algebra:", "deduce:", "organ:relation>")
 SESSION_STORES = ("dialogue", "transitions", "_pending_conversion", "_paths")
 _ADJ = {s: [] for s in SEPH}
 for _i, (_a, _b) in enumerate(EDGES):

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/runtime_conversation_state.py

@@ -0,0 +1,98 @@
+"""Untrusted reconciliation of legacy conversation caches with delivered replies.
+
+This is Python bookkeeping, not a proof or an answer authority. The runtime
+serializes chat calls. Module-global v2 context is borrowed only for one turn;
+committed contexts belong to a runtime instance and a conversation ID.
+"""
+from copy import deepcopy
+import math
+import re
+import sys
+
+_TOPIC = re.compile(r"^\s*(?:new topic|switching topics|change of topic)\s*:", re.I)
+_SCALAR = re.compile(r"^\s*\[ev:derived\]\s+([-+]?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)\. In steps:")
+
+
+def begin(runtime, text, sid):
+    cc = sys.modules.get("chat_context_v2")
+    stores = getattr(runtime, "_conversation_contexts", None)
+    if stores is None:
+        stores = runtime._conversation_contexts = {}
+    prior = deepcopy(stores.get(sid))
+    frame = {"cc": cc, "prior": prior, "sid": sid}
+    if cc is not None:
+        frame["ambient"] = (sid in cc._STATES, cc._STATES.get(sid))
+        cc._STATES[sid] = deepcopy(prior) if prior is not None else cc.Turn()
+    values = getattr(runtime, "_last_value", {})
+    frame["value"] = (sid in values, values.get(sid))
+    if _TOPIC.match(str(text)):
+        if cc is not None:
+            cc._STATES[sid] = cc.Turn()
+        frame["prior"] = None
+        values.pop(sid, None)
+        getattr(runtime, "_v4_disc", {}).pop(sid, None)
+    return frame
+
+
+def scalar(reply, speculative, previous):
+    """Only the two known scalar arithmetic routes can populate w29's cache."""
+    prov = reply.get("provenance")
+    prov = prov if isinstance(prov, dict) else {}
+    path = str(reply.get("path", ""))
+    if prov.get("kind") == "computation" and prov.get("verified") is True and path in ("compute:verified", "chat:resolved>compute:verified"):
+        # The final closed arithmetic route wrote this value itself.
+        return speculative
+    if path == "organ:math>evaluate" and prov.get("kind") == "organ_math" and prov.get("directive") == "evaluate":
+        match = _SCALAR.match(str(reply.get("response", "")))
+        if match:
+            value = float(match.group(1))
+            return value if math.isfinite(value) else None
+    if path.startswith("act:"):
+        return previous
+    return None
+
+
+def finish(runtime, text, reply, frame, supported):
+    sid, cc = frame["sid"], frame["cc"]
+    values = getattr(runtime, "_last_value", None)
+    if values is None:
+        values = runtime._last_value = {}
+    previous = frame["value"][1] if frame["value"][0] else None
+    value = scalar(reply, values.get(sid), previous) if supported else None
+    values.pop(sid, None)
+    if value is not None:
+        values[sid] = value
+    if cc is None:
+        return
+    prior = frame["prior"]
+    cc._STATES[sid] = deepcopy(prior) if prior is not None else cc.Turn()
+    if not supported:
+        cc._STATES[sid] = cc.Turn()
+    elif not str(reply.get("path", "")).startswith("act:"):
+        # Direct questions legitimately carry chat_resolved: null. Only a
+        # typed rewrite record with a string question overrides the input.
+        prov = reply.get("provenance")
+        resolved = prov.get("chat_resolved") if isinstance(prov, dict) else None
+        question = resolved.get("read_as") if isinstance(resolved, dict) else None
+        question = question if isinstance(question, str) and question.strip() else text
+        # Clear numerical slots before recognition so an unrecognized final
+        # correction cannot silently retain an older number or solved variable.
+        cc._STATES[sid].result = None
+        cc._STATES[sid].solved = {}
+        cc.update(sid, question, reply)
+        if value is not None:
+            cc._STATES[sid].result = (value, "")
+    stores = runtime._conversation_contexts
+    if sid not in stores and len(stores) >= cc.STATE_CAP:
+        stores.pop(next(iter(stores)))
+    stores[sid] = deepcopy(cc._STATES[sid])
+
+
+def release(frame):
+    cc = frame["cc"]
+    if cc is not None:
+        had, value = frame["ambient"]
+        if had:
+            cc._STATES[frame["sid"]] = value
+        else:
+            cc._STATES.pop(frame["sid"], None)

root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/runtime_final_outcome.py

@@ -10,6 +10,7 @@ from functools import wraps
 import os
 import re
 import time
+import runtime_conversation_state as conversation
 
 _FRAMES = ContextVar("oracle_final_turns", default=())
 _CITE = re.compile(r"\[[a-z0-9_]+:?[a-z0-9_.\-]*\]")
@@ -45,6 +46,7 @@ def final_turn(method):
                      "snapshot": self._v4_snapshot(session_id),
                      "started": time.perf_counter(), "first": None,
                      "hits": sum(rc.hits for rc in self._v4_recall())}
+            frame["conversation"] = conversation.begin(self, text, session_id)
             token = _FRAMES.set(frames + (frame,))
         try:
             result = method(self, text, session_id)
@@ -65,6 +67,7 @@ def final_turn(method):
             raise
         finally:
             if outer:
+                conversation.release(frame["conversation"])
                 _FRAMES.reset(token)
 
     wrapped._oracle_final_turn = True
@@ -101,6 +104,7 @@ def finish_turn(runtime, text, session_id, result, frame, stands, append, entry,
         # AN's recorder derives all terms and metrics again from the final reply.
         runtime._record_turn(text, session_id, reply, frame["started"], prior)
         getattr(runtime, "_pending_conversion", {}).pop(session_id, None)
+    conversation.finish(runtime, text, reply, frame["conversation"], answered and not unsupported)
     commit_disc = getattr(runtime, "_v4_commit_disc", None)
     if commit_disc:
         commit_disc(text, session_id, reply)

root/specialists/_gate/combo_runtime_v1.py

@@ -238,6 +238,58 @@ QWORDS = set("what what's how who whom whose which where when why is are was wer
              "please tell give name".split())
 
 
+CONDITION_START = re.compile(
+    r"^(?:please\s+)?(?:use|using|assume|assuming|take|given|with|without|ignore|ignoring|neglect|neglecting)\b", re.I)
+CONDITION_NEW_TASK = re.compile(
+    r"\b(?:calculate|compute|determine|find|tell|give|show|convert|list|summarize|compare|explain|"
+    r"evaluate|solve|plot|draw|write|read|search|estimate|measure|prove|derive|differentiate|integrate|"
+    r"derivatives?|integrals?|square root|report|what|who|whom|whose|which|where|when|why|how)\b", re.I)
+DECLARED_CONSTANT = re.compile(
+    r"^(?:the\s+)?(?:load|gravity|density|specific heat(?: capacity)?|pressure|volume|mass|"
+    r"flow(?: rate)?|temperature|stiffness|efficiency)\s+(?:is|remains|stays)\s+"
+    r"(?:constant|steady|fixed)(?:\s+throughout)?\s*[.!]?$", re.I)
+CONDITION_PARAMETER = re.compile(
+    r"\b(?:specific heat|heat capacity|gravity|density|efficiency|temperature|pressure|mass|volume|"
+    r"flow|stiffness|load|capacity|loss(?:es)?|friction|phase change|constant)\b|\b[a-z]\s*=", re.I)
+
+
+def _condition_prefix(part: str) -> tuple[str, str]:
+    """Separate explicit declarative conditions from a later independent task.
+
+    Only condition-led sentences without an unquoted question or request verb
+    attach backwards. A new question stays separate even when its preceding
+    sentence starts with 'Use'. Quoted/code text is never a split boundary.
+    This is deliberately a small untrusted English recognizer, not a proof that
+    arbitrary prose expresses only conditions.
+    """
+    masked = CODE_SPAN.sub(lambda m: "\x00" * len(m.group(0)), part)
+    # A 'Given ...' premise before another question normally belongs to that
+    # new question; it is only a backwards continuation when no question follows.
+    if re.match(r"^(?:please\s+)?given\b", masked, re.I) and "?" in masked:
+        return "", part
+    ends = [m.end() for m in re.finditer(r"[.!]\s+", masked)] + [len(part)]
+    start, consumed = 0, 0
+    for end in ends:
+        sentence = masked[start:end].strip()
+        if not sentence:
+            start = end
+            continue
+        if not (CONDITION_START.match(sentence) or DECLARED_CONSTANT.fullmatch(sentence)) or "?" in sentence or CONDITION_NEW_TASK.search(sentence):
+            break
+        if re.match(r"^(?:please\s+)?(?:use|using|take)\b", sentence, re.I) and not CONDITION_PARAMETER.search(sentence):
+            break  # "Take the square root ..." / "Use a calculator ..." is a task, not a model input.
+        consumed = end
+        start = end
+    return part[:consumed].strip(), part[consumed:].strip()
+
+
+def _short_followup_fragment(text: str) -> bool:
+    """A small explicit elliptical vocabulary; brevity alone never implies dependence."""
+    return bool(re.fullmatch(
+        r"\s*(?:and\s+)?(?:how\s+(?:many|much|long|far)|what(?:\s+else)?|who|when|where|why|which(?:\s+one)?)\s*[?!.]*\s*",
+        text, re.I))
+
+
 def _split_parts(text: str) -> list[str]:
     """split a turn at its question marks; never inside `code` or quoted spans (SQL, JSON, strings).
     Semicolons never split: "10 of 40 deer were tagged; 50 had been tagged ..." is one question."""
@@ -251,7 +303,16 @@ def _split_parts(text: str) -> list[str]:
         out.append(t[prev:c].strip())
         prev = c
     out.append(t[prev:].strip())
-    return [p for p in out if p]
+    grouped = []
+    for part in out:
+        if not part:
+            continue
+        condition, remainder = _condition_prefix(part) if grouped else ("", part)
+        if condition:
+            grouped[-1] += " " + condition
+        if remainder:
+            grouped.append(remainder)
+    return grouped
 
 
 class Combo:
@@ -340,9 +401,9 @@ class Combo:
         return self._arbitrate(text, self._ask_all(text, session_id), session_id)
 
     def _segment(self, parts, session_id):
-        """left to right: a SHORT part (<= 6 words) that no organ takes alone rejoins its neighbour when the joined
-        text is taken ("... in 5-card poker? How many?", "Is Basque related to ...? What family is it?").
-        A full question nobody covers is never glued on (it would vanish inside the neighbour's answer)."""
+        """An explicit elliptical fragment that no organ takes alone may rejoin its neighbour
+        ("... in 5-card poker? How many?"). Pronoun backreferences are handled separately.
+        A full question nobody covers is never glued on just because it is short."""
         segs = []
         ok = lambda x: x[1] is not None or bool(x[2].get("disagree"))   # noqa: E731
         for p in parts:
@@ -353,13 +414,13 @@ class Combo:
                 segs[-1] = (joined,) + self._one(joined, session_id)
                 continue
             cur = (p,) + self._one(p, session_id)
-            if segs and not ok(cur) and len(WORD.findall(p.lower())) <= 6:
+            if segs and not ok(cur) and _short_followup_fragment(p):
                 joined = segs[-1][0] + " " + p
                 j = (joined,) + self._one(joined, session_id)
                 if ok(j):
                     segs[-1] = j
                     continue
-            if segs and not ok(segs[-1]) and len(WORD.findall(segs[-1][0].lower())) <= 6:
+            if segs and not ok(segs[-1]) and _short_followup_fragment(segs[-1][0]):
                 joined = segs[-1][0] + " " + p
                 j = (joined,) + self._one(joined, session_id)
                 if ok(j):

root/specialists/energy-v3/organ_energy_v1.py

@@ -2,9 +2,11 @@
 """organ_energy_v1 - household energy arithmetic, every step shown: energy used by a device (W x h -> kWh), what it costs
 at a stated tariff, how long a battery runs a load (Wh, or V x Ah), a solar array's daily yield (kW x peak-sun-hours,
 x a stated derate, otherwise said to be before losses), a payback period, and the yearly saving from swapping one
-device for another. It never assumes a tariff, a price or sun-hours it was not given. Returns {kind, status, response, value}."""
+device for another. It never assumes a tariff, a price or sun-hours it was not given. Returns {kind, status, response, value}.
+The English recognizer and Python calculations are untrusted; these are explicit constant-energy models, not proofs."""
 from __future__ import annotations
 
+import math
 import re
 
 N = r"(\d+(?:,\d{3})*(?:\.\d+)?)"
@@ -60,6 +62,150 @@ def money(x):
     return "$%.2f" % x if x < 1000 else "$%s" % format(round(x), ",")
 
 
+QN = r"(?<![\w.,])([+-]?(?:\d+(?:,\d{3})*(?:\.\d+)?|\.\d+))"
+POWER = re.compile(QN + r"\s*(kw|kilowatts?|w|watts?)\b")
+DEVICE = r"(?:load|device|appliance|fridge|light|laptop|lamp|fan|tv|router|pump|heater|bulb|motor)\b"
+
+
+def check_energy_conditions(low):
+    for m in re.finditer(r"(?<![\w.,])[+-]?\d[\d,.]*", low):
+        token = m[0].rstrip(".")
+        if "," in token and not re.fullmatch(r"[+-]?\d{1,3}(?:,\d{3})+(?:\.\d+)?", token):
+            raise ValueError("numbers with unambiguous decimal points and three-digit comma groups")
+    if re.search(r"\bbatteries\b|\b(?:loads|devices|appliances|fridges|lights|laptops|lamps|fans|routers|pumps|heaters|bulbs|motors)\b", low):
+        raise ValueError("one battery source and one total consumed load; multiple sources or loads need an explicit combined model")
+
+
+def one_value(values, description):
+    if not values:
+        raise ValueError(description)
+    if len(set(values)) != 1:
+        raise ValueError("one unambiguous " + description)
+    value = values[0]
+    if not math.isfinite(value) or value < 0:
+        raise ValueError("a finite nonnegative " + description)
+    return value
+
+
+def capacity_wh(low):
+    check_energy_conditions(low)
+    values = [num(m[1]) * (1000 if m[2] == "kwh" else 1)
+              for m in re.finditer(QN + r"\s*(kwh|wh)\b", low)]
+    if values:
+        energy = one_value(values, "battery energy in Wh or kWh")
+        if re.search(QN + r"\s*ah\b", low):
+            volts = [num(m[1]) for m in re.finditer(QN + r"\s*v(?:olts?)?\b", low)]
+            amps = [num(m[1]) for m in re.finditer(QN + r"\s*ah\b", low)]
+            equivalent = one_value(volts, "battery voltage") * one_value(amps, "battery capacity in Ah")
+            if not math.isclose(energy, equivalent, rel_tol=1e-9, abs_tol=1e-9):
+                raise ValueError("consistent Wh and voltage/amp-hour capacity values")
+        return energy
+    volts = [num(m[1]) for m in re.finditer(QN + r"\s*v(?:olts?)?\b", low)]
+    amps = [num(m[1]) for m in re.finditer(QN + r"\s*ah\b", low)]
+    return one_value([one_value(volts, "battery voltage") * one_value(amps, "battery capacity in Ah")], "battery energy")
+
+
+def load_and_rating(low):
+    """Untrusted grammar: inverter rating is a constraint, never consumed power."""
+    loads, ratings, unbound = [], [], []
+    for m in POWER.finditer(low):
+        value = num(m[1]) * (1000 if m[2].startswith("k") else 1)
+        before, after = low[max(0, m.start()-55):m.start()], low[m.end():m.end()+55]
+        is_rating = (re.match(r"\s*(?:rated\s+)?inverter\b", after)
+                     or re.search(r"\binverter(?:\s+(?:rating|rated|is|of|at|for|has|a))*(?:\s*[:=])?\s*$", before)
+                     or re.match(r"\s*(?:inverter\s+)?(?:rating|rated)\b", after))
+        is_load = (re.match(r"\s*(?:(?:ac|dc|constant)\s+)?" + DEVICE, after)
+                   or re.search(r"\b(?:load|device|appliance)\s*(?:(?:draws|uses|is|of|at)\s*)?[:=]?\s*$", before))
+        if is_rating and not is_load:
+            ratings.append(value)
+        elif is_load and not is_rating:
+            loads.append(value)
+        else:
+            unbound.append(value)
+    if not loads and len(unbound) == 1 and not ratings:
+        loads, unbound = unbound, []  # the legacy single-load form
+    if unbound:
+        raise ValueError("the consumed load and inverter rating labelled separately")
+    if len(loads) != 1:
+        raise ValueError("one total consumed load in watts")
+    load = one_value(loads, "consumed load in watts")
+    rating = one_value(ratings, "inverter rating in watts") if ratings else None
+    if load <= 0:
+        raise ValueError("a consumed load greater than zero watts")
+    if rating is not None and load > rating:
+        raise ValueError("a load within the stated inverter rating")
+    return load, rating
+
+
+def energy_factors(low, storage=False):
+    """Bind each stated fraction to its role, or reject an unbound condition.
+
+    These are simple constant-energy models, not battery chemistry or a proof.
+    Efficiency and loss are alternative descriptions of the same conversion;
+    depth of discharge is a separate capacity fraction.
+    """
+    check_energy_conditions(low)
+    if (not storage and re.search(r"\b(?:charging|storage)\s+efficiency\b", low)) or (storage and re.search(r"\binverter\s+efficiency\b", low)):
+        raise ValueError("an efficiency bound to the requested conversion (charging and load supply are different stages)")
+    groups = {
+        "efficiency": r"(?:(?:inverter|overall|conversion|charging|storage|battery)\s+)?efficiency",
+        "depth": r"(?:depth of discharge|usable (?:depth|capacity|fraction)|discharge depth)",
+        "loss": r"(?:(?:inverter|conversion|charging|storage|system)\s+)?loss(?:es)?",
+    }
+    if storage:
+        groups["stored"] = r"(?:stored fraction|storage fraction)"
+    found, spans = {}, []
+    numeric = r"([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*(%?)"
+    for role, label in groups.items():
+        patterns = [r"(?<![\w.])" + numeric + r"\s+" + label + r"\b",
+                    r"\b" + label + r"\s*(?:(?:of|is|=|:)\s*)?" + numeric + r"(?![\w.])"]
+        if role == "efficiency":
+            patterns.append(r"(?<![\w.])" + numeric + r"\s+efficient(?:\s+inverter)?\b")
+        if role == "stored":
+            patterns.append(r"\b(?:stores|store|retains|retain)\s+" + numeric + r"\s+of\b")
+        for pattern in patterns:
+            for m in re.finditer(pattern, low):
+                f = float(m[1]) / (100 if m[2] else 1)
+                if not math.isfinite(f) or not 0 <= f <= 1:
+                    raise ValueError("efficiency, loss and usable fractions between 0 and 1 (or 0% and 100%)")
+                found.setdefault(role, []).append(f)
+                spans.append(m.span())
+    # Every percentage and every adjustment term must be accounted for. Ignoring
+    # losses is an explicit ideal-model assumption, not an unknown loss factor.
+    masked = list(low)
+    for start, end in spans:
+        masked[start:end] = " " * (end-start)
+    rest = "".join(masked)
+    rest = re.sub(r"\b(?:ignoring|ignore|without|no|neglecting)\s+(?:(?:inverter|conversion)\s+)?loss(?:es)?\b", "", rest)
+    if re.search(r"%|\befficien\w*|\bloss(?:es)?\b|\bdepth of discharge\b|\busable (?:depth|capacity|fraction)\b|\b(?:idle|standby|variable|surge|peukert|temperature|degradation|derate|reserve)\b|\bperformance ratio\b|\b(?:half full|partly charged|partially charged|state of charge)\b", rest):
+        raise ValueError("each loss, efficiency, usable-capacity or variable-load condition explicitly bound to this model")
+    factors = {role: one_value(values, role + " fraction") for role, values in found.items()}
+    efficiency = factors.get("efficiency", 1)
+    if "loss" in factors:
+        retained = 1 - factors["loss"]
+        if "efficiency" in factors and not math.isclose(efficiency, retained, abs_tol=1e-12):
+            raise ValueError("consistent efficiency and loss fractions")
+        efficiency = retained
+    if "stored" in factors:
+        if "efficiency" in factors or "loss" in factors:
+            if not math.isclose(efficiency, factors["stored"], abs_tol=1e-12):
+                raise ValueError("one unambiguous stored fraction (not two unexplained conversion stages)")
+        efficiency = factors["stored"]
+    return efficiency, factors.get("depth", 1), bool(found)
+
+
+def duration_hours(low):
+    durations = [num(m[1]) for m in re.finditer(QN + r"\s*(?:hours?|hrs?|h|minutes?)\b", low)]
+    if any(not math.isfinite(x) or x < 0 for x in durations):
+        raise ValueError("a finite nonnegative load duration")
+    if len(durations) > 1:
+        raise ValueError("one unambiguous load duration")
+    duration = hours(low)
+    if duration is not None and not math.isfinite(duration[0]):
+        raise ValueError("a finite load duration")
+    return duration
+
+
 class EnergyOrgan:
     def _say(self, kind, text, value=None, status="answered"):
         return {"kind": kind, "status": status, "response": text, "value": value}
@@ -70,6 +216,63 @@ class EnergyOrgan:
     def answer(self, text, session_id="default"):
         t = " ".join(str(text or "").split())
         low = t.lower()
+        # Explicit continuations. The goal is read from the question, not from
+        # a noun in the initial conditions ("initially stores" is not a goal).
+        question = re.search(r"\b(?:what|how much)\b[^?]*\??$", low)
+        goal = question.group(0) if question else ""
+        remaining = re.search(r"\bremain\w*\b|\bleft\b", goal)
+        stored = re.search(r"\bstored\b|\bstore\b", goal)
+        if remaining and re.search(r"\bbatter(?:y|ies)\b", low):
+            try:
+                if not re.search(r"\binitial\w*\b|\bstarts? with\b|\bfully charged\b", low):
+                    raise ValueError("the initially stored energy or an explicit fully charged battery")
+                initial = capacity_wh(low)
+                load, rating = load_and_rating(low)
+                efficiency, depth, adjusted = energy_factors(low)
+                duration = duration_hours(low)
+                if duration is None:
+                    raise ValueError("the duration of the constant load")
+                if efficiency == 0 and duration[0] > 0:
+                    raise ValueError("positive conversion efficiency to supply this load")
+                spent = load * duration[0] / efficiency if efficiency else 0
+                if spent > initial * depth + 1e-10:
+                    raise ValueError("a duration within the battery's available energy at the stated load and factors")
+                base = initial * depth if re.search(r"\busable\b", goal) else initial
+                value = (base - spent) / 1000
+                return self._say("energy", "The %sremaining energy is %s kWh (%s Wh initially%s − %s Wh withdrawn; load %s W × %s, conversion efficiency %s)." % (
+                    "usable " if base != initial else "", g(value), g(initial), " × %s usable fraction" % g(depth) if base != initial else "", g(spent), g(load), duration[1], g(efficiency)), value)
+            except ValueError as error:
+                return self._need(str(error))
+        if stored and re.search(r"\b(?:solar|panel|batter(?:y|ies)|charging)\b", low):
+            try:
+                efficiency, depth, adjusted = energy_factors(low, storage=True)
+                if depth != 1:
+                    raise ValueError("charging/storage efficiency; discharge depth does not specify stored energy")
+                if not adjusted and not re.search(r"\b(?:ignoring|without|no|neglecting)\s+loss", low):
+                    raise ValueError("the fraction of generated/input energy stored, or an explicit no-loss assumption")
+                powers = list(POWER.finditer(low))
+                duration = duration_hours(low)
+                sun = re.search(N + r"\s*(?:peak\s+)?sun[ -]?hours?\b", low)
+                if sun:
+                    duration = (num(sun[1]), "%s peak sun hours" % sun[1])
+                if len(powers) == 1 and duration:
+                    power = one_value([num(powers[0][1]) * (1000 if powers[0][2].startswith("k") else 1)], "input/generating power")
+                    panel_count = re.search(QN + r"\s+panels?\b", low)
+                    if panel_count:
+                        if not re.search(r"\beach\b|\bper panel\b", low):
+                            raise ValueError("whether panel power is per panel or for the whole array")
+                        power *= one_value([num(panel_count[1])], "panel count")
+                    generated = power * duration[0] / 1000
+                elif not powers:
+                    generated = capacity_wh(low) / 1000
+                else:
+                    raise ValueError("one input/generating power and duration, or one stated input energy")
+                if re.search(r"\binitial\w*|\bcapacity|\bfull\b", low):
+                    raise ValueError("a charging plan with initial charge and capacity bounds; this calculation gives newly stored energy only")
+                value = one_value([generated * efficiency], "newly stored energy")
+                return self._say("energy", "The newly stored energy is %s kWh (%s kWh generated/input energy × %s storage fraction)." % (g(value), g(generated), g(efficiency)), value)
+            except ValueError as error:
+                return self._need(str(error))
         # payback
         if re.search(r"\bpayback|\bpay (?:for )?itself|\bbreak even\b|\bpay back\b", low):
             cost = re.search(r"\$\s*" + N + r"(?:\s*(k))?", low)
@@ -83,26 +286,17 @@ class EnergyOrgan:
             y = c / s
             return self._say("payback", "The payback period is %s years (%s ÷ %s saved per year), ignoring price changes and financing." % (g(y), money(c), money(s)), y)
         # battery runtime
-        if re.search(r"\bbattery|\bpower bank\b|\bups\b", low) and re.search(r"\bhow long\b|\bruntime\b|\brun time\b|\blast\b", low):
-            wh = re.search(N + r"\s*(kwh|wh)\b", low)
-            ah = re.search(N + r"\s*ah\b", low)
-            v = re.search(N + r"\s*v(?:olts?)?\b", low)
-            load = re.search(r"\b(?:a|an|the)?\s*" + N + r"\s*(w|watts?)\b(?!\s*h\b)\s*(?:device|load|appliance|fridge|light|laptop|lamp|fan|tv|router|pump|heater)?", low)
-            if wh:
-                cap = num(wh.group(1)) * (1000 if wh.group(2) == "kwh" else 1)
-                capnote = "%s Wh" % g(cap)
-            elif ah and v:
-                cap = num(ah.group(1)) * num(v.group(1))
-                capnote = "%s V × %s Ah = %s Wh" % (g(num(v.group(1))), g(num(ah.group(1))), g(cap))
-            else:
-                return self._need("the battery's capacity (Wh, or volts and amp-hours)")
-            if not load:
-                return self._need("the load in watts")
-            w = num(load.group(1))
-            if w <= 0:
-                return self._say("impossible", "A load must draw more than 0 W.", status="withheld")
-            hrs = cap / w
-            return self._say("runtime", "The runtime is about %s hours (%s ÷ %s W), before inverter and depth-of-discharge losses." % (g(hrs), capnote, g(w)), hrs)
+        if re.search(r"\bbatter(?:y|ies)|\bpower bank\b|\bups\b", low) and re.search(r"\bhow long\b|\bruntime\b|\brun time\b|\blast\b", low):
+            try:
+                cap = capacity_wh(low)
+                w, rating = load_and_rating(low)
+                efficiency, depth, adjusted = energy_factors(low)
+                hrs = one_value([cap * efficiency * depth / w], "runtime")
+                note = "at the stated conversion and usable-capacity factors" if adjusted else "before inverter and depth-of-discharge losses"
+                return self._say("runtime", "The runtime is about %s hours (%s Wh × %s conversion efficiency × %s usable fraction ÷ %s W load), %s%s." % (
+                    g(hrs), g(cap), g(efficiency), g(depth), g(w), note, "; load is within the %s W inverter rating" % g(rating) if rating is not None else ""), hrs)
+            except ValueError as error:
+                return self._need(str(error))
         # solar daily yield
         if re.search(r"\bsolar\b|\bpv\b|\bpanels?\b", low) and re.search(r"\bsun ?hours?\b|\bpeak sun\b|\bsunlight hours?\b", low):
             k = re.search(N + r"\s*(kw|kilowatts?|w|watts?)\b(?!\s*h\b)", low)

root/specialists/geometry-v4/manifest.json

@@ -45,7 +45,7 @@
    "underspecified",
    "impossible"
   ],
-  "context_regex": "\\b(?:circle|sphere|cylinder|cone|cube|rectangle|triangle|hypotenuse|polygon|pentagon|hexagon|heptagon|octagon|nonagon|decagon|quadrilateral)\\b"
+  "context_regex": "\\b(?:circles?|circular|spheres?|cylinders?|cones?|cubes?|rectangles?|rectangular|squares?|triangles?|box|boxes|cuboids?|hypotenuse|polygons?|pentagons?|hexagons?|heptagons?|octagons?|nonagons?|decagons?|quadrilaterals?)\\b"
  },
  "panel": {
   "path": "__ORACLE7_ROOT__/specialists/geometry-v4/geometry_panel_v3.json",
@@ -73,4 +73,4 @@
  },
  "notes": "v4 = v3 + imperative verbs (compute / calculate / determine / give / work out) read as 'find' for the hypotenuse. Judged under spec_gate_v2 on a FRESH panel (new seeds, new phrasings both splits including the class). Same author - disclosed. Earlier notes: v3 = v1 + narrowing (v2: word problems to the head; no false 'I need X' when numbers are present - the full-core sweep found v1 taking 17 core word problems incl. a confident wrong 10.95 for 5) + two reading classes v1 missed (sides stated with a verb, 'sides are a, b and c' - all 8 v1 held-out misses; a hypotenuse value stated after the verb). Judged under spec_gate_v2 on a FRESH panel v2 (new seeds, new phrasings both splits, new declines). Same author - disclosed. Deliberately does NOT read '10 feet across' as a diameter: those core textbook problems use pi = 3.14.",
  "supersedes": "geometry-v3 (ADMIT gate v2, 93/100; 7 misses = imperative 'Compute the hypotenuse')"
-}
+}

root/specialists/geometry-v4/organ_geometry_v4.py

@@ -1,16 +1,189 @@
 #!/usr/bin/env python3
 """organ_geometry_v4 - organ_geometry_v3 (admitted 2026-09-29, held-out 93/100) plus imperative verbs: all 7 v3 held-out
 misses were "Compute the hypotenuse of a right triangle whose legs are a and b." (v1's reader knew only find / what is /
-how long is). Compute / calculate / determine / give / work out now read as "find". Everything else v3."""
+how long is). Compute / calculate / determine / give / work out now read as "find". Everything else v3.
+
+This Python dimensional reader is untrusted; it grants no proof or admission authority.
+Explicit same-unit dimensions retain their units, bound rectangles may normalize mixed
+length units, and inherited formulas decline unsupported or inconsistent dimensions.
+"""
 from __future__ import annotations
 
 import re
+import math
 
 from organ_geometry_v3 import GeometryOrganV3
+from organ_geometry_v1 import g
 
 IMPERATIVE = re.compile(r"\b(?:compute|calculate|determine|give|work out|get)\s+(?=the (?:length of the )?hypotenuse\b)", re.I)
 
 
+# This organ remains standalone: its dimensional reader must not depend on the
+# head's import path or turn an unsupported binding into a legacy raw product.
+_LENGTHS = {}
+for _unit, _scale, _names in (
+    ("mm", .001, "mm millimeter millimeters"), ("cm", .01, "cm centimeter centimeters"),
+    ("m", 1., "m meter meters"), ("km", 1000., "km kilometer kilometers"),
+    ("in", .0254, "in inch inches"), ("ft", .3048, "ft foot feet"),
+    ("yd", .9144, "yd yard yards"), ("mi", 1609.344, "mi mile miles"),
+):
+    for _name in _names.split():
+        _LENGTHS[_name] = (_unit, _scale)
+_NUMBER = r"(\d+(?:\.\d+)?)"
+_FIELDS = re.compile(r"\b(length|width|radius|diameter|height|side|edge|base|leg|hypotenuse)\s*"
+                     r"(?:(?:of|is|equals|exactly|measures|=|:)\s*)*" + _NUMBER, re.I)
+_NUMBERS = re.compile(r"(?<![\w.+-])" + _NUMBER + r"(?!\d|\.\d)")
+_POWERS = {"rect_area": 2, "rect_perimeter": 1, "circle_area": 2, "circumference": 1,
+           "sphere_volume": 3, "sphere_surface": 2, "cylinder_volume": 3, "cylinder_surface": 2,
+           "cone_volume": 3, "cube_volume": 3, "cube_surface": 2, "box_volume": 3,
+           "square_area": 2, "square_perimeter": 1, "tri_area": 2, "heron": 2,
+           "hypotenuse": 1, "leg": 1}
+
+
+def _unit_at(tail, strict=False):
+    tail = tail.lstrip()
+    if re.match(r"in\s+(?:the|this|a)\s+(?:diagram|drawing|figure)\b", tail):
+        return None, True, None
+    word = re.match(r"([^\W\d_]+)", tail)
+    if not word:
+        return None, False, None
+    token = word.group(1)
+    if token in _LENGTHS:
+        rest = tail[word.end():].lstrip()
+        if re.match(r"(?:\^|\d|[²³]|/|per\b)", rest):
+            return None, False, "These dimensions require length units, not powered or compound units."
+        if token == "in" and rest and not re.match(r"[.,;:?!)]|(?:and|long|wide|tall|high)\b", rest):
+            return None, False, "I cannot tell whether 'in' denotes inches or a preposition here. Please spell out the length unit."
+        return _LENGTHS[token], False, None
+    if strict and token not in ("and", "or", "by", "x", "units", "unit", "long", "wide", "high", "tall"):
+        return None, False, "I cannot bind the stated length unit '%s'; please use an explicit supported length unit." % token
+    return None, False, None
+
+
+def _dimensions(t):
+    fields, positions, units, diagram = {}, set(), [], False
+    for match in _FIELDS.finditer(t):
+        role, raw = match.group(1), match.group(2)
+        unit, drawn, error = _unit_at(t[match.end():], strict=True)
+        if error:
+            return None, None, False, error
+        record = (float(raw), unit)
+        if role in fields:
+            previous = fields[role]
+            if (previous[1] is None) != (unit is None) or previous[0] * (previous[1][1] if previous[1] else 1) != record[0] * (unit[1] if unit else 1):
+                return None, None, False, "The supplied %s values contradict each other; please supply one consistent measurement." % role
+        fields[role] = record
+        positions.add(match.start(2))
+        units.append(unit)
+        diagram = diagram or drawn
+    # A unit or diagram dimension not bound to an explicit role cannot be
+    # silently fed to the old first-number reader.
+    for number in _NUMBERS.finditer(t):
+        unit, drawn, error = _unit_at(t[number.end():])
+        if error:
+            return None, None, False, error
+        if (unit or drawn) and number.start(1) not in positions:
+            return None, None, False, "I cannot bind every supplied length to a geometry role; please name each dimension explicitly."
+        if (any(units) or diagram) and number.start(1) not in positions:
+            # Explicit apartment identifiers are not shape dimensions. Other
+            # unused numbers (including a second '5 by 6' tuple) remain ambiguous.
+            if not re.search(r"\bapartment\s*$", t[:number.start(1)]):
+                return None, None, False, "I cannot account for every number in this dimensional request; please clarify the extra dimensions or constraints."
+    return fields, units, diagram, None
+
+
+def _request_issue(t):
+    asking = re.split(r"(?<=[.!?])\s+", t)[-1]
+    if len(set(re.findall(r"\b(?:area|perimeter|volume|circumference)\b", asking))) > 1:
+        return "I can calculate one geometry measure at a time; please ask for the measures separately."
+    if re.search(r"\b(?:rectangles|rooms|circles|spheres|cylinders|cones|cubes|boxes|triangles|squares|cuboids)\b", t) or re.search(r"\b(?:their|both)\b", asking):
+        return "I can calculate one shape at a time; this request refers to multiple shapes."
+    for requested in re.finditer(r"\b(?:in|into|to)\s+(?:(square|cubic|sq\.?|cu\.?)\s+|(units?\s+of)\s+)?([a-z]+)(?:\^?[23]|[²³])?\b", asking):
+        if requested.group(1) or requested.group(2) or requested.group(3) in _LENGTHS:
+            return "I cannot yet bind an explicitly requested output unit for this geometry calculation."
+    return None
+
+
 class GeometryOrganV4(GeometryOrganV3):
     def answer(self, text, session_id="default"):
-        return super().answer(IMPERATIVE.sub("find ", str(text or "")), session_id)
+        t = IMPERATIVE.sub("find ", str(text or ""))
+        asking = re.split(r"(?<=[.!?])\s+", t.strip())[-1]
+        if (re.match(r"^(?:who|when|where|why|explain|describe|tell me)\b", asking, re.I)
+                or re.search(r"\b(?:colou?r|name|history|origin)\b", asking, re.I)):
+            return None
+        if not re.search(r"\b(?:area|perimeter|volume|circumference|hypotenuse|leg|angles?)\b", asking, re.I):
+            return None  # shape mentions alone are not requests for a calculation
+        low = " ".join(t.lower().replace("−", "-").split())
+        issue = _request_issue(low)
+        if issue and re.search(r"\b(?:rectangles?|rectangular|circles?|spheres?|cylinders?|cones?|cubes?|squares?|triangles?|box|boxes|cuboids?)\b", low):
+            return self._say("underspecified", issue, status="withheld")
+        reply = super().answer(t, session_id)
+        if not reply or reply.get("status") != "answered" or reply.get("kind") not in _POWERS:
+            return reply
+        def refuse(message):
+            return self._say("underspecified", message, status="withheld")
+        if re.search(r"(?<!\w)-\d", low):
+            return refuse("A negative length is not a valid dimension for this geometry calculation.")
+        fields, units, diagram, issue = _dimensions(low)
+        if issue:
+            return refuse(issue)
+        physical = [u for u in units if u]
+        if physical and len(physical) != len(units):
+            return refuse("Some dimensions have length units and others do not; please specify the missing units.")
+        if "radius" in fields and "diameter" in fields:
+            r, ru = fields["radius"]; d, du = fields["diameter"]
+            if 2 * r * (ru[1] if ru else 1) != d * (du[1] if du else 1):
+                return refuse("The radius and diameter contradict each other: the diameter must be twice the radius.")
+        kind = reply["kind"]
+        if physical or diagram:
+            allowed_roles = {
+                "rect_area": {"length", "width"}, "rect_perimeter": {"length", "width"},
+                "circle_area": {"radius", "diameter"}, "circumference": {"radius", "diameter"},
+                "sphere_volume": {"radius", "diameter"}, "sphere_surface": {"radius", "diameter"},
+                "cylinder_volume": {"radius", "diameter", "height"}, "cylinder_surface": {"radius", "diameter", "height"},
+                "cone_volume": {"radius", "diameter", "height"},
+                "cube_volume": {"side", "edge"}, "cube_surface": {"side", "edge"},
+                "box_volume": {"length", "width", "height"},
+                "square_area": {"side"}, "square_perimeter": {"side"},
+                "tri_area": {"base", "height"}, "hypotenuse": {"leg"}, "leg": {"hypotenuse", "leg"},
+            }.get(kind, set())
+            if set(fields) - allowed_roles:
+                return refuse("This formula does not account for all supplied geometry roles; please clarify the extra dimensions or constraints.")
+        if kind.startswith("cube_") and "side" in fields and "edge" in fields:
+            side, su = fields["side"]; edge, eu = fields["edge"]
+            if side * (su[1] if su else 1) != edge * (eu[1] if eu else 1):
+                return refuse("The cube's side and edge values contradict each other; they describe the same length.")
+        scales = {u[1] for u in physical}
+        power = _POWERS[kind]
+        unit = physical[0][0] if physical else None
+        value = reply.get("value")
+        steps = None
+        if kind in ("rect_area", "rect_perimeter") and (physical or diagram):
+            if set(fields) != {"length", "width"}:
+                return refuse("I need exactly a bound length and width for this rectangle calculation.")
+            length, lu = fields["length"]; width, wu = fields["width"]
+            if len(scales) > 1:
+                length, width = length * lu[1], width * wu[1]
+                unit = "m"
+            value = length * width if power == 2 else 2 * (length + width)
+            steps = ("A = l × w = %g × %g" if power == 2 else "P = 2(l + w) = 2(%g + %g)") % (length, width)
+        elif len(scales) > 1:
+            return refuse("I cannot combine mixed length units for this geometry formula; please express its dimensions in one unit.")
+        # Unitless published formulas retain their original behavior. Explicit
+        # diagram dimensions remain useful but must not be presented as inches.
+        if not physical and not diagram:
+            return reply
+        if not math.isfinite(value):
+            return refuse("The geometry result is outside the finite numeric range I can return.")
+        rounding = re.search(r"round(?:ed)?\s+to\s+(?:the\s+nearest\s+)?(tenth|hundredth|thousandth|whole)\b", low)
+        if re.search(r"\bround(?:ed)?\b", low) and not rounding:
+            return refuse("I cannot bind that rounding request; please name the nearest tenth, hundredth, thousandth or whole unit.")
+        if rounding:
+            value = round(value, {"tenth": 1, "hundredth": 2, "thousandth": 3, "whole": 0}[rounding.group(1)])
+        label = (unit + ("²" if power == 2 else "³" if power == 3 else "")) if unit else {1: "units", 2: "square units", 3: "cubic units"}[power]
+        response = reply["response"]
+        if steps is not None:
+            response = "The %s is %s %s (%s)." % ("area" if power == 2 else "perimeter", g(value), label, steps)
+        else:
+            response = re.sub(r"\bis\s+-?\d+(?:\.\d+)?(?:e[+-]?\d+)?", "is %s %s" % (g(value), label), response, count=1)
+        return {**reply, "value": value, "unit": unit if power == 1 else ("%s^%d" % (unit, power) if unit else label), "response": response}

root/wander-train/math_organ_v1.py

@@ -1,9 +1,11 @@
-"""math_organ_v1 - exact mathematics as specified free moves, every result independently checked, the method cited.
+"""Untrusted math_organ_v1: SymPy operations with heuristic numerical checks.
+
+These checks share the evaluator and are not independent proofs. The method is cited when available.
 
 REQUEST    directive (solve / simplify / factor / expand / evaluate / differentiate / integrate / limit / decompose)
            + the expression(s), read from the question or from its exercise set's instruction
 MOVES      SymPy operations legal for that directive and that expression's type
-CHECK      independent of the move that produced the answer:
+CHECK      numerical or symbolic checks, not a theorem about the user question:
              solve      every solution substituted back satisfies every equation / inequality
              factor     the product expands back to the input, and is a product
              simplify   equivalent to the input at random points, and no more complex than the input
@@ -15,6 +17,7 @@ STORED FORM the textbook's own method for the directive (a howto or a worked exa
 Nothing is asserted unless the check passes; a failed check is an abstention with the reason."""
 from __future__ import annotations
 
+import math
 import random
 import re
 import sqlite3
@@ -189,6 +192,23 @@ def rand_pts(syms, k=5):
     return [{s: sp.Rational(rng.randint(2, 29), rng.randint(3, 11)) for s in syms} for _ in range(k)]
 
 
+def finite_numeric_agreement(a, b, tolerance):
+    """Reject NaN/infinity before comparison; finite complex values are allowed.
+
+    Both evaluations use SymPy. Agreement is a heuristic check, not independent
+    verification, and values outside machine complex range are declined.
+    """
+    try:
+        va, vb = complex(a.evalf()), complex(b.evalf())
+        if not all(math.isfinite(x) for x in (va.real, va.imag, vb.real, vb.imag)):
+            return False
+        difference = abs(va - vb)
+        bound = tolerance * max(1.0, abs(va), abs(vb))
+        return math.isfinite(difference) and math.isfinite(bound) and difference <= bound
+    except (TypeError, ValueError, OverflowError):
+        return False
+
+
 def equiv(a, b):
     try:
         d = sp.simplify(a - b)
@@ -196,8 +216,7 @@ def equiv(a, b):
             return True
         syms = sorted((a.free_symbols | b.free_symbols), key=str)
         for pt in rand_pts(syms):
-            va, vb = complex(a.subs(pt).evalf()), complex(b.subs(pt).evalf())
-            if abs(va - vb) > 1e-7 * max(1.0, abs(va)):
+            if not finite_numeric_agreement(a.subs(pt), b.subs(pt), 1e-7):
                 return False
         return True
     except Exception:  # noqa: BLE001
@@ -405,9 +424,9 @@ class MathOrgan:
         if e.free_symbols:
             return self._simplify(spans, q)
         v = sp.nsimplify(sp.simplify(e)) if not e.is_Float else e
-        if abs(complex(v.evalf()) - complex(e.evalf())) > 1e-9 * max(1, abs(complex(e.evalf()))):
+        if not finite_numeric_agreement(v, e, 1e-9):
             return None
-        return {"answer": sp.sstr(v), "value": v, "check": "recomputed numerically",
+        return {"answer": sp.sstr(v), "value": v, "check": "finite numerical comparison using SymPy",
                 "steps": ["read %s" % sp.sstr(e), "evaluate"]}
 
     # --- calculus -------------------------------------------------------------------------------------------------

root/wander-train/math_organ_v2.py

@@ -1,12 +1,13 @@
 """math_organ_v2 - v1 (admitted in w480, now immutable) + two fixes found on the gate panel: "factorial" is not a
 request to factor, and a request for a PROGRAM is the code organ's, not a mathematical request.
 
-exact mathematics as specified free moves, every result independently checked, the method cited.
+Untrusted SymPy operations with heuristic numerical checks; the method is cited when available.
+These checks share the evaluator and are not independent proofs.
 
 REQUEST    directive (solve / simplify / factor / expand / evaluate / differentiate / integrate / limit / decompose)
            + the expression(s), read from the question or from its exercise set's instruction
 MOVES      SymPy operations legal for that directive and that expression's type
-CHECK      independent of the move that produced the answer:
+CHECK      numerical or symbolic checks, not a theorem about the user question:
              solve      every solution substituted back satisfies every equation / inequality
              factor     the product expands back to the input, and is a product
              simplify   equivalent to the input at random points, and no more complex than the input
@@ -23,6 +24,7 @@ import re
 import sqlite3
 
 import sympy as sp
+from math_organ_v1 import finite_numeric_agreement
 from sympy.parsing.sympy_parser import (convert_xor, implicit_multiplication_application, parse_expr,
                                         split_symbols_custom, standard_transformations)
 
@@ -199,8 +201,7 @@ def equiv(a, b):
             return True
         syms = sorted((a.free_symbols | b.free_symbols), key=str)
         for pt in rand_pts(syms):
-            va, vb = complex(a.subs(pt).evalf()), complex(b.subs(pt).evalf())
-            if abs(va - vb) > 1e-7 * max(1.0, abs(va)):
+            if not finite_numeric_agreement(a.subs(pt), b.subs(pt), 1e-7):
                 return False
         return True
     except Exception:  # noqa: BLE001
@@ -412,9 +413,9 @@ class MathOrgan:
         if e.free_symbols:
             return self._simplify(spans, q)
         v = sp.nsimplify(sp.simplify(e)) if not e.is_Float else e
-        if abs(complex(v.evalf()) - complex(e.evalf())) > 1e-9 * max(1, abs(complex(e.evalf()))):
+        if not finite_numeric_agreement(v, e, 1e-9):
             return None
-        return {"answer": sp.sstr(v), "value": v, "check": "recomputed numerically",
+        return {"answer": sp.sstr(v), "value": v, "check": "finite numerical comparison using SymPy",
                 "steps": ["read %s" % sp.sstr(e), "evaluate"]}
 
     # --- calculus -------------------------------------------------------------------------------------------------

root/wander-train/math_organ_v3.py

@@ -3,12 +3,13 @@ variables (found by the proposer brief: "On what date in 1969 did ..." -> 1969*d
 math_organ_v2 - v1 (admitted in w480, now immutable) + two fixes found on the gate panel: "factorial" is not a
 request to factor, and a request for a PROGRAM is the code organ's, not a mathematical request.
 
-exact mathematics as specified free moves, every result independently checked, the method cited.
+Untrusted SymPy operations with heuristic numerical checks; the method is cited when available.
+These checks share the evaluator and are not independent proofs.
 
 REQUEST    directive (solve / simplify / factor / expand / evaluate / differentiate / integrate / limit / decompose)
            + the expression(s), read from the question or from its exercise set's instruction
 MOVES      SymPy operations legal for that directive and that expression's type
-CHECK      independent of the move that produced the answer:
+CHECK      numerical or symbolic checks, not a theorem about the user question:
              solve      every solution substituted back satisfies every equation / inequality
              factor     the product expands back to the input, and is a product
              simplify   equivalent to the input at random points, and no more complex than the input
@@ -25,6 +26,7 @@ import re
 import sqlite3
 
 import sympy as sp
+from math_organ_v1 import finite_numeric_agreement
 from sympy.parsing.sympy_parser import (convert_xor, implicit_multiplication_application, parse_expr,
                                         split_symbols_custom, standard_transformations)
 
@@ -207,8 +209,7 @@ def equiv(a, b):
             return True
         syms = sorted((a.free_symbols | b.free_symbols), key=str)
         for pt in rand_pts(syms):
-            va, vb = complex(a.subs(pt).evalf()), complex(b.subs(pt).evalf())
-            if abs(va - vb) > 1e-7 * max(1.0, abs(va)):
+            if not finite_numeric_agreement(a.subs(pt), b.subs(pt), 1e-7):
                 return False
         return True
     except Exception:  # noqa: BLE001
@@ -420,9 +421,9 @@ class MathOrgan:
         if e.free_symbols:
             return self._simplify(spans, q)
         v = sp.nsimplify(sp.simplify(e)) if not e.is_Float else e
-        if abs(complex(v.evalf()) - complex(e.evalf())) > 1e-9 * max(1, abs(complex(e.evalf()))):
+        if not finite_numeric_agreement(v, e, 1e-9):
             return None
-        return {"answer": sp.sstr(v), "value": v, "check": "recomputed numerically",
+        return {"answer": sp.sstr(v), "value": v, "check": "finite numerical comparison using SymPy",
                 "steps": ["read %s" % sp.sstr(e), "evaluate"]}
 
     # --- calculus -------------------------------------------------------------------------------------------------

root/wander-train/oracle_operator_specs_v1.py

@@ -198,33 +198,63 @@ def _gcd_ref(a):
 
 
 # ── 3. base conversion ────────────────────────────────────────────────────────
-# fn is repeated divmod; ref is positional expansion of the digits it produced.
-_BASE_RX = re.compile(
-    r'\b(?:convert|write|express)?\s*(-?\d+)\s*(?:from\s*)?(?:base\s*(\d+))?\s*'
-    r'(?:in|to|into)\s*(?:base\s*)?(\d+|binary|hex|hexadecimal|octal|decimal)\b', re.I)
+# The parser binds the original digits and source base. The function decodes
+# with int(); the reference independently expands source digits positionally.
 _BASE_NAME = {'binary': 2, 'hex': 16, 'hexadecimal': 16, 'octal': 8, 'decimal': 10}
+_BASE_ATOM = r'(?:base\s*\d+|binary|hexadecimal|hex|octal|decimal)'
+_BASE_RX = re.compile(
+    r'^\s*(?:(?:convert|write|express|what\s+is)\s+)?'
+    r'(?:(?P<prefix>' + _BASE_ATOM + r')\s+)?'
+    r'(?P<digits>[+-]?[0-9a-z]+)'
+    r'(?:\s+(?:(?:from|in)\s+)?(?P<source>' + _BASE_ATOM + r'))?'
+    r'\s+(?:in|to|into|as)\s+(?P<target>' + _BASE_ATOM + r'|\d+)'
+    r'\s*[.?!]?\s*$', re.I | re.ASCII)
 _DIGITS = '0123456789abcdefghijklmnopqrstuvwxyz'
 
 
 def _base_parse(s):
-    m = _BASE_RX.search(s)
+    m = _BASE_RX.fullmatch(s)
     if not m:
-        raise NotOurs('no number and target base here')
-    n = int(m.group(1))
-    frm = int(m.group(2)) if m.group(2) else 10
-    tgt = m.group(3).lower()
-    to = _BASE_NAME.get(tgt, None)
-    if to is None:
-        to = int(tgt)
-    if not (2 <= to <= 36) or not (2 <= frm <= 36):
-        raise OutOfFragment('I convert between base 2 and base 36 only')
-    if n < 0:
+        raise NotOurs('no complete integer base conversion here')
+
+    def base(token):
+        token = token.lower()
+        value = _BASE_NAME.get(token)
+        if value is None:
+            numeral = re.sub(r'^base\s*', '', token)
+            if len(numeral) > 3:
+                raise OutOfFragment('I convert between base 2 and base 36 only')
+            value = int(numeral)
+        if not 2 <= value <= 36:
+            raise OutOfFragment('I convert between base 2 and base 36 only')
+        return value
+
+    sources = [base(token) for token in (m['prefix'], m['source']) if token]
+    raw = m['digits'].lower()
+    if raw.startswith('-'):
         raise OutOfFragment('I convert non-negative whole numbers only')
-    return {'n': n, 'frm': frm, 'to': to}
+    raw = raw.lstrip('+')
+    # A conventional literal prefix is source evidence, not a digit to discard.
+    # Explicit bases above 16 may use x as a digit; only infer prefixes when no
+    # explicit source is supplied, or that source matches the prefix convention.
+    literal = {'0b': 2, '0o': 8, '0x': 16}.get(raw[:2])
+    if literal is not None and (not sources or all(b == literal for b in sources)):
+        sources.append(literal)
+        raw = raw[2:]
+    elif literal is not None and sources and sources[0] in (2, 8, 10, 16):
+        raise OutOfFragment('the literal prefix conflicts with the stated source base')
+    if len(set(sources)) > 1:
+        raise OutOfFragment('the stated source bases disagree')
+    frm = sources[0] if sources else 10
+    to = base(m['target'])
+    if not raw or len(raw) > 128 or any(_DIGITS.index(c) >= frm for c in raw):
+        raise OutOfFragment('I need 1 to 128 valid digits in the stated source base')
+    n = int(raw, frm)
+    return {'n': n, 'digits': raw, 'frm': frm, 'to': to}
 
 
 def _base_fn(a):
-    n, steps, out = a['n'], [], ''
+    n, steps, out = int(a['digits'], a['frm']), [], ''
     if n == 0:
         return '0', ['0 in any base is 0']
     while n:
@@ -235,8 +265,13 @@ def _base_fn(a):
 
 
 def _base_ref(a):
-    """Independent: build with a positional table, then check by expanding it."""
-    n = a['n']
+    """Expand original source digits, then encode using a positional table.
+
+    This does not share int() source decoding or repeated output division with
+    the primary function. Both still depend on the same untrusted parse.
+    """
+    n = sum(_DIGITS.index(digit) * a['frm'] ** power
+            for power, digit in enumerate(reversed(a['digits'])))
     if n == 0:
         return '0'
     digits, powers = [], []
@@ -418,8 +453,9 @@ SPECS = [
      'parse': _base_parse, 'fn': _base_fn, 'ref': _base_ref,
      'render': lambda a, v, s: '%d in base %d is %s.' % (a['n'], a['to'], v),
      'warrant': 'computation',
-     'independence': 'moderate: repeated division against positional expansion; '
-                     'both walk the same digits, in opposite directions',
+     'independence': 'moderate: int source decoding and repeated output division '
+                     'against positional source expansion and output encoding; '
+                     'both still depend on the same untrusted parse',
      'fragment': 'non-negative whole numbers, bases 2 to 36'},
 
     {'name': 'statistics', 'family': 'measurement',

root/wander-train/oracle_release_runtime_ao.py

@@ -22,6 +22,16 @@ import re
 
 from oracle_release_runtime_an import OracleReleaseRuntimeAN
 
+# Untrusted grammar guard: in "does it take/cost ... to <action>", it
+# may be a grammatical subject rather than an entity from the conversation.
+# Decline substitution for that token; other references remain eligible. The
+# match stays within a clause and accepts decimal amounts before the infinitive.
+DUMMY_IT = re.compile(
+    r"\b(?:does|did|will|would|can|could|should|has|had)\s+(?P<it>it)\s+"
+    r"(?:take|taken|cost)\s+"
+    r"(?:(?:\d+(?:\.\d+)?\s+(?:milliseconds?|seconds?|minutes?|hours?|days?|weeks?|"
+    r"months?|years?|dollars?|euros?|pounds?)|[$€£]\d+(?:\.\d+)?)\s+)?"
+    r"to\s+[a-z]", re.I)
 DEICTIC = re.compile(r"\b(it|there|that|this|its|they|them|those|these|the same)\b", re.I)
 ELLIPSIS = re.compile(r"^(?:and|what about|the same for)\s+(?P<t>.+?)\??$", re.I)
 BARE = re.compile(r"^(?:the\s+)?[a-z][a-z \-']{2,40}$", re.I)
@@ -41,6 +51,17 @@ PREDICATE_OF = {
 }
 
 
+def referential_deictic(text):
+    """First eligible reference, excluding only take/cost-infinitive dummy it.
+
+    This does not claim to parse all English expletives. Skipping an ambiguous
+    token leaves the original question available to the unchanged handler.
+    """
+    dummy_spans = {match.span("it") for match in DUMMY_IT.finditer(text)}
+    return next((match for match in DEICTIC.finditer(text)
+                 if match.span() not in dummy_spans), None)
+
+
 class OracleReleaseRuntimeAO(OracleReleaseRuntimeAN):
     """Conversions are applied ONLY when the unchanged chain would not answer."""
 
@@ -103,10 +124,11 @@ class OracleReleaseRuntimeAO(OracleReleaseRuntimeAN):
             if not CONTINUATION.match(s):
                 return f"Summarize {s.strip()}.", "ELLIPSIS_COMPLETION"
         topic = self._live_topic(session_id)
-        if topic and DEICTIC.search(s):
+        reference = referential_deictic(s)
+        if topic and reference:
             if low in PREDICATE_OF:
                 return PREDICATE_OF[low].format(t=topic), "REFERENT_SUBSTITUTION"
-            return DEICTIC.sub(topic, s, count=1), "REFERENT_SUBSTITUTION"
+            return s[:reference.start()] + topic + s[reference.end():], "REFERENT_SUBSTITUTION"
         return None, None
 
     def chat(self, text: str, session_id: str = "default") -> dict:

root/wander-train/reach_router_v1.py

@@ -17,6 +17,7 @@ identifiers, links and media are never given unless asked for; quantities only w
 quantities without their units). At most 5 stored values, listed; more is declined.
 Refused as in exact_router_v1: yes/no questions, a hidden hop, a quoted title that is not the span, a past-time qualifier on
 a relation that changes over time, blank nodes, an answer that restates the question.
+Untrusted routing policy: stored rows and type ancestry are evidence, not proof of source truth or completeness.
 use: answer(question) -> {"answer", "values", "property", "direction", "subject_qid", "route", "pattern"} or None"""
 import json
 import os
@@ -138,7 +139,7 @@ def fragment(q, span, p):
                     j += step
                 if 0 <= j < len(toks):
                     w = toks[j]
-                    if w not in L.STOP and w not in cues and not w.isdigit() and len(w) >= 3:
+                    if w not in L.STOP and w not in cues and not w.isdigit():
                         return True
             return False
     return False
@@ -368,8 +369,9 @@ def answer(q, pinned=None):
         return None                                       # a value with no English name is not shown
     shown = sorted(shown)
     aw = [w for x in shown for w in L.norm(x).split() if w not in L.STOP]
-    if aw and all(w in set(L.norm(q).split()) for w in aw):
-        return None                                       # the answer restates the question
+    if subj in v or (not all(isinstance(x, int) for x in v)
+                     and aw and all(w in set(L.norm(q).split()) for w in aw)):
+        return None                                       # entity identity, not overlapping labels, is restatement
     text = shown[0] if len(shown) == 1 else ", ".join(shown[:-1]) + " and " + shown[-1]
     return {"answer": text, "values": shown, "raw": sorted(v, key=str), "property": p, "direction": d, "subject_qid": subj,
             "route": route, "pattern": pat}

root/wander-train/reach_router_v2.py

@@ -23,6 +23,7 @@ identifiers, links and media are never given unless asked for; quantities only w
 quantities without their units). At most 5 stored values, listed; more is declined.
 Refused as in exact_router_v1: yes/no questions, a hidden hop, a quoted title that is not the span, a past-time qualifier on
 a relation that changes over time, blank nodes, an answer that restates the question.
+Untrusted routing policy: stored rows and type ancestry are evidence, not proof of source truth or completeness.
 use: answer(question) -> {"answer", "values", "property", "direction", "subject_qid", "route", "pattern"} or None"""
 import json
 import os
@@ -150,7 +151,7 @@ def fragment(q, span, p):
                     j += step
                 if 0 <= j < len(toks):
                     w = toks[j]
-                    if w not in L.STOP and w not in cues and not w.isdigit() and len(w) >= 3:
+                    if w not in L.STOP and w not in cues and not w.isdigit():
                         return True
             return False
     return False
@@ -409,8 +410,9 @@ def answer(q, pinned=None):
         return None                                       # a value with no English name is not shown
     shown = sorted(shown)
     aw = [w for x in shown for w in L.norm(x).split() if w not in L.STOP]
-    if aw and all(w in set(L.norm(q).split()) for w in aw):
-        return None                                       # the answer restates the question
+    if subj in v or (not all(isinstance(x, int) for x in v)
+                     and aw and all(w in set(L.norm(q).split()) for w in aw)):
+        return None                                       # entity identity, not overlapping labels, is restatement
     text = shown[0] if len(shown) == 1 else ", ".join(shown[:-1]) + " and " + shown[-1]
     return {"answer": text, "values": shown, "raw": sorted(v, key=str), "property": p, "direction": d, "subject_qid": subj,
             "route": route, "pattern": pat}

root/wander-train/reach_router_v3.py

@@ -27,6 +27,7 @@ identifiers, links and media are never given unless asked for; quantities only w
 quantities without their units). At most 5 stored values, listed; more is declined.
 Refused as in exact_router_v1: yes/no questions, a hidden hop, a quoted title that is not the span, a past-time qualifier on
 a relation that changes over time, blank nodes, an answer that restates the question.
+Untrusted routing policy: stored rows and type ancestry are evidence, not proof of source truth or completeness.
 use: answer(question) -> {"answer", "values", "property", "direction", "subject_qid", "route", "pattern"} or None"""
 import json
 import os
@@ -144,9 +145,9 @@ def fits(q, p, d, vals):
     return True
 
 
-def fragment(q, span, p):
+def fragment(q, span, p, extra_cues=()):
     """the span is part of a longer name: a word next to it (past name particles) is a content word nothing explains"""
-    cues = _load()["cues"].get(p, set())
+    cues = _load()["cues"].get(p, set()) | set(extra_cues)
     toks, sp = L.norm(q).split(), L.norm(span).split()
     for i in range(len(toks) - len(sp) + 1):
         if toks[i:i + len(sp)] == sp:
@@ -155,7 +156,7 @@ def fragment(q, span, p):
                     j += step
                 if 0 <= j < len(toks):
                     w = toks[j]
-                    if w not in L.STOP and w not in cues and not w.isdigit() and len(w) >= 3:
+                    if w not in L.STOP and w not in cues and not w.isdigit():
                         return True
             return False
     return False
@@ -167,17 +168,17 @@ GENERIC = set(("name names called known located famous kind type sort also exact
 MAX_UNEXPLAINED = int(os.environ.get("REACH_MAX_UNEXPLAINED", "2"))   # development: 2 stopped a Mintaka error, lost nothing
 
 
-def unexplained(q, span, p):
+def unexplained(q, span, p, extra_cues=()):
     """content words of the question that neither the subject, the relation's own words nor ordinary question words explain"""
-    cues = _load()["cues"].get(p, set())
+    cues = _load()["cues"].get(p, set()) | set(extra_cues)
     sp = set(L.norm(span).split())
     return [w for w in L.norm(q).split() if w not in sp and w not in cues and w not in GENERIC and w not in L.STOP
             and not w.isdigit() and len(w) >= 3]
 
 
-def _agree(q, span, cands, p, d):
+def _agree(q, span, cands, p, d, extra_cues=()):
     """the readings of the name that hold the relation must agree; a one-word name answers through its top reading only"""
-    if fragment(q, span, p) or len(unexplained(q, span, p)) > MAX_UNEXPLAINED:
+    if fragment(q, span, p, extra_cues) or len(unexplained(q, span, p, extra_cues)) > MAX_UNEXPLAINED:
         return None, None
     one = len(L.norm(span).split()) == 1
     use = cands[:1] if one else cands[:3]
@@ -310,6 +311,10 @@ def _agent_routes(q):
         return []
     al = _load()["alias"]
     v = m.group("v").lower()
+    if v == "created":
+        # A developer can be a later maintainer, not the original creator.
+        # Designer is admitted only with programming-language type evidence below.
+        return [({170, 287}, m.group("y"), "agent:created")]
     passive, agents = (IRREG[v][0], {IRREG[v][1]}) if v in IRREG else (v, _agent_nouns(v))
     props = set(al.get(passive + " by", set()))
     for a in agents:
@@ -317,6 +322,43 @@ def _agent_routes(q):
     return [(props, m.group("y"), "agent:" + v)] if props else []
 
 
+def _programming_language(qid):
+    """Positive bounded P31/P279 evidence only; missing ancestry is not a negative fact."""
+    db = _load()["db"]
+    frontier, seen = {qid}, set()
+    for depth in range(5):
+        if 9143 in frontier and depth > 0:
+            return True
+        next_frontier = set()
+        for item in frontier - seen:
+            rows = db.execute("SELECT o FROM fact INDEXED BY fact_sp WHERE s=? AND p=? LIMIT 33",
+                              (item, 31 if depth == 0 else 279)).fetchall()
+            if len(rows) > 32:
+                return False
+            next_frontier.update(o for (o,) in rows if o is not None)
+        seen.update(frontier)
+        if len(seen | next_frontier) > 64:
+            return False
+        frontier = next_frontier - seen
+        if not frontier:
+            return False
+    return False
+
+
+def _creation_property_allowed(p, cands):
+    """Creator means P170; a language's original designer may also answer creation.
+
+    Every candidate with a designer row must have positive language ancestry.
+    Never select a language merely because another reading lacks that type.
+    """
+    if p == 170:
+        return True
+    if p != 287:
+        return False
+    holders = [qid for qid, _, _ in cands[:3] if has(qid, p)]
+    return bool(holders) and all(_programming_language(qid) for qid in holders)
+
+
 def _label_routes(q):
     """the question names the relation: (relation, subject text, the asked phrase)"""
     al = _load()["alias"]
@@ -408,14 +450,18 @@ def answer(q, pinned=None):
     sp = L.link(q, 3)[:3]
     if pinned:
         sp = [(pinned[0], [(pinned[1], 10 ** 6, label(pinned[1]))])] + [x for x in sp if L.norm(x[0]) != L.norm(pinned[0])]
+    agent = AGENT.match(q)
+    asks_creation = bool(agent and agent.group("v").lower() == "created")
     found = []
     for span, cands in sp:                                # PATTERN route: the first span whose reading holds the relation
         if XR.hop(q, span) or not XR.subject_ok(q, span):
             continue
         for (p, d), route, pat in _routes(q, span, cands):
+            if asks_creation and (d != "fwd" or not _creation_property_allowed(p, cands)):
+                continue
             if p in XR.TIME_VARIANT and XR.PAST.search(q):
                 continue
-            v, subj = _agree(q, span, cands, p, d)
+            v, subj = _agree(q, span, cands, p, d, {"created"} if asks_creation and p == 287 else ())
             if v is not None and fits(q, p, d, v):
                 found.append((p, d, v, subj, route, pat))
                 break
@@ -429,9 +475,11 @@ def answer(q, pinned=None):
             span, cands = ysp[0]
             hits = []
             for p in sorted(props):
+                if asks_creation and not _creation_property_allowed(p, cands):
+                    continue
                 if p in XR.TIME_VARIANT and XR.PAST.search(q):
                     continue
-                v, subj = _agree(q, span, cands, p, "fwd")
+                v, subj = _agree(q, span, cands, p, "fwd", {"created"} if asks_creation and p == 287 else ())
                 if v is not None and fits(q, p, "fwd", v):
                     hits.append((p, "fwd", v, subj, "when" if asked.startswith("when:") else "count" if asked.startswith("count:") else "agent" if asked.startswith("agent:") else "label", asked))
             if len({h[2] for h in hits}) == 1:
@@ -445,8 +493,9 @@ def answer(q, pinned=None):
         return None                                       # a value with no English name is not shown
     shown = sorted(shown)
     aw = [w for x in shown for w in L.norm(x).split() if w not in L.STOP]
-    if aw and all(w in set(L.norm(q).split()) for w in aw):
-        return None                                       # the answer restates the question
+    if subj in v or (not all(isinstance(x, int) for x in v)
+                     and aw and all(w in set(L.norm(q).split()) for w in aw)):
+        return None                                       # entity identity, not overlapping labels, is restatement
     text = shown[0] if len(shown) == 1 else ", ".join(shown[:-1]) + " and " + shown[-1]
     return {"answer": text, "values": shown, "raw": sorted(v, key=str), "property": p, "direction": d, "subject_qid": subj,
             "route": route, "pattern": pat}

root/wander-train/relation_spec_v1.py

@@ -11,6 +11,7 @@ A question is linked ONCE per turn however many relation specialists look at it
 import collections
 import functools
 import json
+import re
 
 import exact_router_v1 as X
 
@@ -21,6 +22,11 @@ _anc, _cls, _props = {}, {}, {}
 
 
 def prop_label(p):
+    # The shipped label dump includes aliases ("wives", "written by", "wrote")
+    # for these properties. Those aliases can misstate the role in a receipt.
+    canonical = {26: "spouse", 86: "composer", 800: "notable work"}
+    if p in canonical:
+        return canonical[p]
     if not _PL:
         try:
             with open(PROP_LABELS, encoding="utf-8") as f:
@@ -128,8 +134,64 @@ def kind_conflict(q, did):
     return bool(named) and did in KIND_NOUNS and did not in named
 
 
+_COMPOSER_REQUEST = re.compile(
+    r"^(?:who composed(?: the (?:music|score|soundtrack) (?:for|of|to))?"
+    r"|who (?:is|was) the composer of"
+    r"|who wrote the (?:music|score|soundtrack) (?:for|of|to)"
+    r"|which composer wrote)\s+(?P<title>.+?)$", re.I)
+
+
+def _composer_request(q):
+    """Untrusted, whole-question recognizer: musical composition means P86.
+
+    A mined correlation with P800 (notable work) cannot establish the role.
+    Keep the entire title; do not silently fall back to a linked title fragment.
+    """
+    text = " ".join(str(q).split()).rstrip("?.! ")
+    text = re.sub(r"^(?:please tell me|(?:can|could) you (?:please )?tell me)\s+", "", text, flags=re.I)
+    match = _COMPOSER_REQUEST.fullmatch(text)
+    if not match:
+        return None
+    title = match.group("title").strip()
+    title = re.sub(r"^the (?:film|movie)\s+", "", title, flags=re.I)
+    dated = re.fullmatch(r"(.+?)\s*\((\d{4})\)", title)
+    year = dated.group(2) if dated else None
+    title = (dated.group(1) if dated else title).strip(" \"'“”‘’")
+    return title, year
+
+
+def _composer_answer(q, did, request):
+    title, year = request
+    # Fetch one extra candidate so a capped name lookup is not mistaken for full
+    # coverage. Domain and optional publication year must select agreeing rows.
+    candidates = list(X.L.candidates(X.norm(title), 65)) if title else []
+    if not candidates and title.lower().startswith("the "):
+        candidates = list(X.L.candidates(X.norm(title[4:]), 65))
+    if not candidates or len(candidates) > 64:
+        return None
+    mine = [c[0] for c in candidates if in_domain(c[0], did)]
+    if year:
+        mine = [qid for qid in mine if any(
+            re.fullmatch(r"\+?" + year + r"(?:-\d{2}-\d{2}(?:T[^\s]+)?)?", str(value))
+            for value in values(qid, 577))]
+    sets = [values(qid, 86) for qid in mine]
+    if not mine or any(not found for found in sets) or len(set(sets)) != 1 or len(sets[0]) != 1:
+        return None
+    val = next(iter(sets[0]))
+    if _restates(q, val):
+        return None
+    return {"answer": X._show(val, q), "property": 86, "subject_qid": mine[0],
+            "direction": "fwd", "pattern": "explicit|composer|P86",
+            "linked_qid": mine[0]}
+
+
 def answer(q, did, patterns):
     """patterns: {"fwd|key|word": [p, ...], "inv|key|word": [p, ...]} -> {answer, property, subject_qid, direction, pattern} or None"""
+    request = _composer_request(q)
+    if request is not None:
+        if kind_conflict(str(q), did):
+            return None
+        return _composer_answer(q, did, request)
     a = analyse(str(q))
     if a is None or kind_conflict(str(q), did):
         return None

root/wander-train/word_problems_v1.py

@@ -1,5 +1,7 @@
 """word_problems_v1 - prose to equations for the recurring shapes of textbook word problems.
 
+This Python recognizer is untrusted; its checks are not proof or admission authority.
+
 Each SCHEMA is a stored form: trigger words, the TYPED quantities it needs (money, percent, time, length ...), and a
 formula. A schema fires only when every quantity it needs is found with the right type AND the question asks for the
 kind of quantity the formula produces (the CHECK: units must compose - money x rate x years -> money). Quantities are
@@ -178,38 +180,158 @@ def s_convert(t, q, qs):
                                                                            tab[src[0][2]], tab[to], to)]}
 
 
+def _geometry_dimensions(t, qs):
+    """Untrusted complete binding for explicit geometry roles; no proof authority.
+
+    Return (bindings, conflict). Unknown syntax/units return (None, None).
+    Prefix roles and postfix long/wide/tall share coverage and uniqueness checks.
+    """
+    tl = t.lower().replace("−", "-")
+    lengths = [x for x in qs if x[0] == "length"]
+    mentions = {}
+    for mention in re.finditer(r"\b(length|width|radius|diameter|height)\b", tl):
+        match = re.match(r"\s*(?:(?:is|of|exactly|equals|measures|=|:)\s*)*"
+                         + NUM + r"\s*([a-z]+)\b", tl[mention.end():])
+        if not match:
+            return None, None
+        # "in" is also a preposition. Accept the inch abbreviation only at
+        # a measurement boundary; "length 3 in the diagram" supplies no unit.
+        tail = tl[mention.end() + match.end():].lstrip()
+        if match.group(2) == "in" and tail and not re.match(r"[.,;:?!)]|(?:and|long|wide|tall|high)\b", tail):
+            return None, None
+        mentions[mention.end() + match.start(1)] = (mention.group(1), match.group(1), match.group(2))
+    for match in re.finditer(r"(?<![\w.+-])" + NUM + r"\s*([a-z]+)\s+(long|wide|tall|high)\b", tl):
+        role = {"long": "length", "wide": "width", "tall": "height", "high": "height"}[match.group(3)]
+        binding = (role, match.group(1), match.group(2))
+        if match.start(1) in mentions and mentions[match.start(1)] != binding:
+            return None, None
+        mentions[match.start(1)] = binding
+    # Every typed length must be bound, including repeats. Apartment IDs are
+    # unitless, so they do not masquerade as dimensions or block a valid room.
+    if len(mentions) != len(lengths):
+        return None, None
+    bindings, unit_scales, records = {}, set(), {}
+    conflict = None
+    for _, (role, raw, unit_word) in sorted(mentions.items()):
+        unit = unit_of(unit_word)
+        if unit is None or unit[0] != "length":
+            return None, None
+        value, scale = num(raw), LENGTH[unit[1]]
+        current = {"value": value, "unit": unit_word}
+        if role in bindings and bindings[role] != (value, scale):
+            if bindings[role][0] * bindings[role][1] != value * scale:
+                conflict = conflict or {"role": role, "values": [records[role], current]}
+        bindings[role] = (value, scale)
+        records[role] = current
+        unit_scales.add(scale)
+    if conflict:
+        return None, conflict
+    # Conversion between mixed units needs an output-unit contract first.
+    if len(unit_scales) > 1:
+        return None, None
+    if "radius" in bindings and "diameter" in bindings:
+        if bindings["radius"][0] * 2 != bindings["diameter"][0]:
+            return None, {"role": "radius/diameter", "values": [records["radius"], records["diameter"]]}
+    return bindings, None
+
+
+def _geometry_request_issue(t, q):
+    """Bound the subject, requested measure and output unit before calculating."""
+    shapes = re.findall(r"\b(?:rectangles?|rectangular|circles?|circular|cones?|cylinders?|spheres?)\b", t, re.I)
+    if not shapes:
+        return None
+    measures = set(re.findall(r"\b(?:area|perimeter|circumference|volume)\b", q))
+    if not measures:
+        return None
+    if len(measures) > 1:
+        return "I can calculate one geometry measure per question. Please ask for each requested measure separately."
+    # These are subject multiplicity markers, not arbitrary numbers: an
+    # apartment identifier is not a count of rectangles or a dimension.
+    plural = re.search(r"\b(?:rectangles|circles|cones|cylinders|spheres|rooms|boxes)\b", t, re.I)
+    counted = re.search(r"\b(?:" + "|".join(w for w, v in WORDNUM.items() if v != 1)
+                        + r"|[2-9]\d*|1\d+)\s+(?:(?:identical|rectangular|circular)\s+)*"
+                          r"(?:room|box|rectangle|circle|cone|cylinder|sphere)\b", t, re.I)
+    if len(shapes) > 1 or plural or counted or re.search(r"\b(?:their|both)\b", q):
+        return "I can calculate one shape at a time; this question refers to multiple shapes."
+    for requested in re.finditer(r"\b(?:in|into|to)\s+(?:(square|cubic|sq\.?|cu\.?)\s+|(units?\s+of)\s+)?"
+                                  r"([a-z]+)(?:\^?[23]|[²³])?\b", q):
+        unit = unit_of(requested.group(3))
+        if requested.group(1) or requested.group(2) or (unit and unit[0] == "length"):
+            return "I cannot yet bind the requested output unit for this geometry question."
+    return None
+
+
+def explain_refusal(text):
+    """Explain a bounded geometry conflict, without certifying an English parse."""
+    t = " ".join(str(text).split())
+    q = question_part(t)
+    issue = _geometry_request_issue(t, q)
+    if issue:
+        return {"reason": "unsupported_geometry_request", "schema": "geometry", "conflict": None, "response": issue}
+    # Do not conflate dimensions belonging to two explicitly named shapes.
+    shapes = re.findall(r"\b(?:rectangle|rectangular|circle|circular|cone|cylinder|sphere)\b", t, re.I)
+    if len(shapes) != 1 or MULTISTEP.search(t) or not re.search(r"\b(?:area|perimeter|circumference|volume)\b", q):
+        return None
+    _, conflict = _geometry_dimensions(t, quantities(t))
+    if not conflict:
+        return None
+    values = conflict["values"]
+    if conflict["role"] == "radius/diameter":
+        message = ("The supplied radius (%g %s) and diameter (%g %s) disagree: "
+                   "the diameter must be twice the radius. Which measurement should I use?" %
+                   (values[0]["value"], values[0]["unit"], values[1]["value"], values[1]["unit"]))
+    else:
+        message = ("The supplied %s values disagree (%g %s and %g %s). Which %s should I use?" %
+                   (conflict["role"], values[0]["value"], values[0]["unit"],
+                    values[1]["value"], values[1]["unit"], conflict["role"]))
+    return {"reason": "conflicting_dimension", "schema": "geometry", "conflict": conflict, "response": message}
+
+
 def s_geometry(t, q, qs):
-    L = [x for x in qs if x[0] == "length"]
+    if _geometry_request_issue(t, q):
+        return None
     tl = t.lower()
+    bindings, conflict = _geometry_dimensions(t, qs)
+    if bindings is None:
+        return None
+
+    # Every binding has the same checked length scale. Keep that unit and
+    # raise its dimension with the formula; never relabel raw cm as meters.
+    units_by_scale = {LENGTH[u]: u for u in ("mm", "cm", "m", "km", "in", "ft", "yd", "mi")}
+    base_unit = units_by_scale.get(next(iter(bindings.values()))[1]) if bindings else None
+    if base_unit is None:
+        return None
+
+    def result(value, power, steps):
+        return {"value": value, "unit": base_unit if power == 1 else "%s^%d" % (base_unit, power), "steps": steps}
 
     def near(word):
-        m = re.search(r"%s[^.]{0,40}?%s\s*([a-z]+)" % (word, NUM), tl)
-        return num(m.group(1)) if m else None
+        return bindings[word][0] if word in bindings else None
     if "rectangle" in tl or "rectangular" in tl:
         ln, wd = near("length"), near("width")
         if ln is not None and wd is not None:
             if re.search(r"\barea\b", q):
-                return {"value": ln * wd, "unit": "sq", "steps": ["A = L x W = %g x %g" % (ln, wd)]}
+                return result(ln * wd, 2, ["A = L x W = %g x %g" % (ln, wd)])
             if re.search(r"perimeter", q):
-                return {"value": 2 * (ln + wd), "unit": "", "steps": ["P = 2(L + W) = 2(%g + %g)" % (ln, wd)]}
+                return result(2 * (ln + wd), 1, ["P = 2(L + W) = 2(%g + %g)" % (ln, wd)])
     if "circle" in tl or "circular" in tl:
         r, d = near("radius"), near("diameter")
         r = r if r is not None else (d / 2 if d is not None else None)
         if r is not None:
             pi = 3.14 if "3.14" in tl else math.pi
             if re.search(r"\barea\b", q):
-                return {"value": pi * r * r, "unit": "sq", "steps": ["A = pi r^2, r = %g" % r]}
+                return result(pi * r * r, 2, ["A = pi r^2, r = %g" % r])
             if re.search(r"circumference", q):
-                return {"value": 2 * pi * r, "unit": "", "steps": ["C = 2 pi r, r = %g" % r]}
+                return result(2 * pi * r, 1, ["C = 2 pi r, r = %g" % r])
     if re.search(r"\bvolume\b", q):
         r, h = near("radius"), near("height")
         pi = 3.14 if "3.14" in tl else math.pi
         if "cone" in tl and r is not None and h is not None:
-            return {"value": pi * r * r * h / 3, "unit": "cu", "steps": ["V = (1/3) pi r^2 h, r = %g, h = %g" % (r, h)]}
+            return result(pi * r * r * h / 3, 3, ["V = (1/3) pi r^2 h, r = %g, h = %g" % (r, h)])
         if "cylinder" in tl and r is not None and h is not None:
-            return {"value": pi * r * r * h, "unit": "cu", "steps": ["V = pi r^2 h, r = %g, h = %g" % (r, h)]}
+            return result(pi * r * r * h, 3, ["V = pi r^2 h, r = %g, h = %g" % (r, h)])
         if "sphere" in tl and r is not None:
-            return {"value": 4 / 3 * pi * r ** 3, "unit": "cu", "steps": ["V = (4/3) pi r^3, r = %g" % r]}
+            return result(4 / 3 * pi * r ** 3, 3, ["V = (4/3) pi r^3, r = %g" % r])
     return None
 
 

tests/conversation_grammar/test_m53_dummy_it.py

@@ -0,0 +1,126 @@
+"""Untrusted handler tests: real AO conversion and AN recording, controlled AM replies.
+
+No full Engine or source stores are loaded. These tests establish conversion
+behavior, not whether the full engine can compute the requested duration/cost.
+"""
+from copy import deepcopy
+import importlib.util
+from pathlib import Path
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[2]
+WANDER = ROOT / 'root/wander-train'
+MIRROR = ROOT / 'root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_release_runtime_ao.py'
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def answer(body):
+    return {'status': 'answered', 'path': 'verified:test', 'response': body}
+
+
+def withheld():
+    return {'status': 'withheld', 'path': 'missing:test', 'response': 'No answer for that question.'}
+
+
+class Plain:
+    def __init__(self):
+        self.dialogue = {}
+        self.calls = []
+        self.routes = {}
+
+    def chat(self, text, session_id='default'):
+        self.calls.append((text, session_id))
+        result = deepcopy(self.routes.get(text, withheld()))
+        self.dialogue.setdefault(session_id, {})['last_result'] = deepcopy(result)
+        return result
+
+
+class DummyItTests(unittest.TestCase):
+    def setUp(self):
+        self.modules = patch.dict(sys.modules, {'oracle_release_runtime_am':
+            types.SimpleNamespace(OracleReleaseRuntimeAM=Plain)})
+        self.modules.start()
+        load('oracle_release_runtime_an', WANDER / 'oracle_release_runtime_an.py')
+        self.ao = load('oracle_release_runtime_ao', WANDER / 'oracle_release_runtime_ao.py')
+        self.rt = self.ao.OracleReleaseRuntimeAO()
+        self.rt.dialogue['s'] = {'last_topic': 'that times 2'}
+        self.rt.routes['Summarize that times 2.'] = answer('A summary unrelated to transfer duration.')
+
+    def tearDown(self):
+        self.modules.stop()
+
+    def test_recorded_transfer_failure_does_not_become_old_topic_summary(self):
+        question = 'How long does it take to transfer 1GB at100Mbps?'
+        reply = self.rt.chat(question, 's')
+        self.assertEqual(reply, withheld())
+        self.assertEqual(self.rt.calls, [(question, 's'), (question, 's')])
+        self.assertEqual(len(self.rt.path('s')), 1)
+        self.assertEqual(self.rt.path('s')[0]['in_surface'], question)
+        self.assertNotIn('conversion', self.rt.path('s')[0])
+
+    def test_duration_and_cost_grammar_generalizes_beyond_transfer_wording(self):
+        questions = ['How long will it take to boil 2 litres of water?',
+                     'How much does it cost to run a 2 kW heater for 3 hours?',
+                     'What would it take to build a bridge?',
+                     'Does it take 1.5 hours to charge a battery?',
+                     'Would it cost $2.50 to run the heater?',
+                     'How much time has it taken to compile the program?',
+                     'HOW LONG COULD IT TAKE TO WALK 10 KM?']
+        for question in questions:
+            with self.subTest(question=question):
+                self.assertEqual(self.rt._convert(question, 's'), (None, None))
+
+    def test_real_referential_it_and_other_pronouns_still_resolve(self):
+        self.rt.dialogue['s']['last_topic'] = 'Moon'
+        for question, expected in [('Who discovered it?', 'Who discovered Moon?'),
+                                   ('What is it made of?', 'What is Moon made of?'),
+                                   ('What lives there?', 'What lives in Moon?'),
+                                   ('How long does it take?', 'How long does Moon take?'),
+                                   ('Does it take photos?', 'Does Moon take photos?'),
+                                   ('Does it take photos to upload?', 'Does Moon take photos to upload?'),
+                                   ('Does it take me to London?', 'Does Moon take me to London?')]:
+            with self.subTest(question=question):
+                self.assertEqual(self.rt._convert(question, 's'), (expected, 'REFERENT_SUBSTITUTION'))
+
+    def test_dummy_it_does_not_hide_a_later_real_reference(self):
+        self.rt.dialogue['s']['last_topic'] = 'the battery'
+        question = 'How long does it take to charge that?'
+        rewritten = 'How long does it take to charge the battery?'
+        self.assertEqual(self.rt._convert(question, 's'), (rewritten, 'REFERENT_SUBSTITUTION'))
+        self.rt.routes[rewritten] = answer('Two hours. [source:test]')
+        reply = self.rt.chat(question, 's')
+        self.assertEqual(reply['response'], 'Two hours. [source:test]')
+        self.assertEqual(reply['conversion']['to'], rewritten)
+        self.assertEqual(len(self.rt.path('s')), 1)
+
+    def test_known_answer_and_conversation_moves_are_preserved(self):
+        question = 'How long does it take to transfer 1 GB at 100 Mbps?'
+        self.rt.routes[question] = answer('80 seconds. [source:test]')
+        self.assertEqual(self.rt.chat(question, 's'), self.rt.routes[question])
+        self.assertEqual(len(self.rt.path('s')), 1)
+        self.assertEqual(self.rt._convert('I meant the Pacific Ocean', 's'),
+                         ('Summarize the Pacific Ocean.', 'REPAIR_ACCEPT'))
+        self.assertEqual(self.rt._convert('What about Venus?', 's'),
+                         ('Summarize Venus.', 'ELLIPSIS_COMPLETION'))
+        self.assertEqual(self.rt._convert('Go on', 's'), (None, None))
+
+    def test_absent_topic_and_other_session_never_borrow_referents(self):
+        self.assertEqual(self.rt._convert('Who discovered it?', 'other'), (None, None))
+        self.assertEqual(self.rt._convert('How long does it take to charge that?', 'other'), (None, None))
+        self.assertEqual(self.rt.dialogue['s']['last_topic'], 'that times 2')
+
+    def test_source_mirror_matches(self):
+        self.assertEqual((WANDER / 'oracle_release_runtime_ao.py').read_bytes(), MIRROR.read_bytes())
+
+if __name__ == '__main__':
+    unittest.main()

tests/conversation_grammar_r468/test_door_dummy_it.py

@@ -0,0 +1,142 @@
+"""Untrusted tests of real r468 and its real obligation compiler, without an Engine.
+
+The controlled parent supplies explicit replies. No real transfer-duration
+answer or privacy-guard implementation is claimed by these component tests.
+"""
+import ast
+from copy import deepcopy
+import importlib.util
+from pathlib import Path
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[2]
+WANDER = ROOT / 'root/wander-train'
+ADMITTED = ROOT / 'root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted'
+QUESTION = 'How long does it take to transfer 1GB at100Mbps?'
+GENERIC = {'status':'clarification', 'path':'act:clarify', 'response':"I didn't fully parse that, so I won't guess.",
+           'provenance':{'kind':'dialogue_state'}}
+PRIVATE = {'status':'withheld', 'path':'precision_guard:G2_private_state',
+           'response':'That depends on something only you know; my records cannot tell me.',
+           'provenance':{'kind':'precision_guard','rule':'G2_private_state'}}
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+class Parent:
+    def __init__(self):
+        self.routes = {}
+        self.calls = []
+
+    def chat(self, text, session_id='default'):
+        self.calls.append((text, session_id))
+        return deepcopy(self.routes.get(text, GENERIC))
+
+
+class DoorGrammarTests(unittest.TestCase):
+    def setUp(self):
+        self.modules = patch.dict(sys.modules, {'oracle_release_runtime_w313':
+            types.SimpleNamespace(OracleReleaseRuntimeW313=Parent)})
+        self.modules.start()
+        load('oracle_program_ir_v1', WANDER / 'oracle_program_ir_v1.py')
+        self.module = load('oracle_release_runtime_w468', ADMITTED / 'oracle_release_runtime_w468.py')
+        self.rt = self.module.OracleReleaseRuntimeW468()
+
+    def tearDown(self):
+        self.modules.stop()
+
+    def seed_arithmetic(self):
+        for question, result in [('What is 6 multiplied by 7?', '42'), ('that times 2', '84')]:
+            self.rt.routes[question] = {'status':'answered','path':'compute:verified','response':result}
+            self.rt.chat(question, 'arithmetic')
+        self.assertEqual(self.rt._r468_thread('arithmetic'), ['multiplied', 'times'])
+        self.rt.calls.clear()
+
+    def test_actual_arithmetic_thread_does_not_ask_dummy_it_to_choose_old_words(self):
+        self.seed_arithmetic()
+        actual = self.rt.chat(QUESTION, 'arithmetic')
+        self.assertEqual(actual, GENERIC)
+        self.assertEqual(self.rt.calls, [(QUESTION, 'arithmetic')])
+        self.assertNotIn('r468_door', actual['provenance'])
+
+    def test_same_exclusion_applies_to_binding_and_clarification(self):
+        self.seed_arithmetic()
+        questions = [QUESTION, 'How much does it cost to run a heater?',
+                     'What would it take to build a bridge?',
+                     'Does it take 1.5 hours to charge a battery?',
+                     'Would it cost $2.50 to run the heater?',
+                     'How much time has it taken to compile the program?']
+        for question in questions:
+            with self.subTest(question=question):
+                self.assertIsNone(self.rt._r468_bind(question, 'times'))
+                self.assertIsNone(self.rt._r468_door(question, 'arithmetic', deepcopy(GENERIC)))
+
+    def test_later_genuine_reference_is_bound_or_asked_about_instead(self):
+        self.rt._r468_thread('s').append('battery')
+        question = 'How long does it take to charge that?'
+        self.assertEqual(self.rt._r468_bind(question, 'battery'),
+                         'How long does it take to charge battery?')
+        actual = self.rt.chat(question, 's')
+        self.assertEqual(actual['provenance']['r468_door']['phrase'], 'that')
+        self.assertEqual(actual['provenance']['r468_door']['offered'], ['battery'])
+        self.assertEqual(self.rt._r468_bind('How long does it take to cool its contents?', 'battery'),
+                         "How long does it take to cool battery's contents?")
+
+    def test_real_reference_binds_and_preserves_evidence_from_same_session(self):
+        self.rt._r468_thread('s').append('Eiffel Tower')
+        source = {'status':'answered', 'path':'verified:place', 'response':'It is in Paris, France. [source:place]',
+                  'references':['source:place']}
+        self.rt.routes['Where is Eiffel Tower?'] = source
+        actual = self.rt.chat('Where is it?', 's')
+        self.assertEqual(actual['provenance']['r468_door']['act'], 'bound')
+        self.assertEqual(actual['references'], ['source:place'])
+        self.assertEqual(self.rt.calls, [('Where is it?', 's'), ('Where is Eiffel Tower?', 's::r468')])
+
+    def test_direct_object_it_and_non_dummy_possessives_are_unchanged(self):
+        for question, expected in [('Does it take me to London?', 'Does train take me to London?'),
+                                   ('Does it take photos to upload?', 'Does train take photos to upload?'),
+                                   ('How long does it take?', 'How long does train take?'),
+                                   ('What is its speed?', "What is train's speed?")]:
+            with self.subTest(question=question):
+                self.assertEqual(self.rt._r468_bind(question, 'train'), expected)
+
+    def test_private_refusal_is_never_rebound_or_replaced(self):
+        self.seed_arithmetic()
+        for question in ['What is my password?',
+                         'How long does it take to recover my password?',
+                         'How long does it take to read that in another conversation?']:
+            with self.subTest(question=question):
+                self.rt.routes[question] = deepcopy(PRIVATE)
+                self.rt.calls.clear()
+                self.assertEqual(self.rt.chat(question, 'arithmetic'), PRIVATE)
+                self.assertEqual(self.rt.calls, [(question, 'arithmetic')])
+
+    def test_empty_session_does_not_offer_other_sessions_subjects(self):
+        self.seed_arithmetic()
+        actual = self.rt.chat('Where is it?', 'empty')
+        self.assertEqual(actual['provenance']['r468_door']['offered'], [])
+        self.assertNotIn('times', actual['response'])
+        self.assertNotIn('multiplied', actual['response'])
+        self.assertEqual(self.rt._r468_thread('arithmetic'), ['multiplied', 'times'])
+
+    def test_answered_parent_still_passes_through(self):
+        self.rt.routes[QUESTION] = {'status':'answered','path':'specialist:transfer','response':'80 seconds.'}
+        self.assertEqual(self.rt.chat(QUESTION, 's'), self.rt.routes[QUESTION])
+        self.assertEqual(self.rt.calls, [(QUESTION, 's')])
+
+    def test_dummy_it_grammar_matches_existing_ao_without_importing_its_chain(self):
+        tree = ast.parse((WANDER / 'oracle_release_runtime_ao.py').read_text())
+        node = next(n for n in tree.body if isinstance(n, ast.Assign) and
+                    any(isinstance(t, ast.Name) and t.id == 'DUMMY_IT' for t in n.targets))
+        self.assertEqual(self.module.DUMMY_IT.pattern, ast.literal_eval(node.value.args[0]))
+
+if __name__ == '__main__':
+    unittest.main()

tests/conversation_guard/test_last_question.py

@@ -0,0 +1,152 @@
+"""G2 regression using real dialogue production and guard methods, without a head."""
+import ast
+from copy import deepcopy
+import importlib.util
+from pathlib import Path
+import sys
+from types import ModuleType
+import unittest
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[2]
+ADMITTED = ROOT / "root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted"
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name,path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+DIALOGUE = load("actual_dialogue",ROOT / "root/wander-train/organ_dialogue_v1.py")
+# Only the actual envelope builder is needed from w480; its module imports the
+# head and unrelated math/relation stores. Compile this unchanged method alone.
+source = ast.parse((ADMITTED / "oracle_release_runtime_w480.py").read_text())
+cls = next(node for node in source.body if isinstance(node,ast.ClassDef))
+method = next(node for node in cls.body if isinstance(node,ast.FunctionDef) and node.name == "_c480_dialogue_reply")
+namespace = {}
+exec(compile(ast.Module(body=[method],type_ignores=[]),"actual_w480_reply", "exec"),namespace)
+reply_builder = namespace["_c480_dialogue_reply"]
+
+
+class Parent:
+    def _c480_dialogue(self):
+        if not hasattr(self,"_c480_d"):
+            self._c480_d = DIALOGUE.DialogueOrgan()
+        return self._c480_d
+
+    def chat(self, text, session_id="default"):
+        dialogue = self._c480_dialogue()
+        if getattr(self,"forced_reply",None) is not None:
+            reply = deepcopy(self.forced_reply)
+        else:
+            answer = dialogue.answer(text,session_id)
+            reply = reply_builder(self,{"status":"clarification","path":"act:clarify"},answer)
+        dialogue.log(session_id,text,reply)
+        return reply
+
+
+parent_module = ModuleType("oracle_release_runtime_w533")
+parent_module.OracleReleaseRuntimeW533 = Parent
+with patch.dict(sys.modules,{"oracle_release_runtime_w533":parent_module,
+                            "chat_context_v2":None,"entity_linker_v2":None,"relation_spec_v1":None}):
+    GUARD = load("actual_w534",ADMITTED / "oracle_release_runtime_w534.py")
+
+
+QUESTION = "What is 6 multiplied by 7?"
+ANSWER = "In steps: 6 x 7 = 42. The answer is 42."
+
+
+class ConversationGuard(unittest.TestCase):
+    def setUp(self):
+        self.runtime = GUARD.OracleReleaseRuntimeW534()
+        self.dialogue = self.runtime._c480_dialogue()
+        self.dialogue.log("a",QUESTION,dict(status="answered",path="compute:verified",response=ANSWER))
+
+    def history_reply(self, session="a", question="What did I just ask?"):
+        return reply_builder(self.runtime,{"status":"clarification","path":"act:clarify"},
+                             self.dialogue.answer(question,session))
+
+    def test_recorded_real_repro_passes_with_exact_turn_evidence(self):
+        expected = self.history_reply()
+        self.assertTrue(GUARD.private_state("What did I just ask?"))
+        self.assertEqual(GUARD.final_guards("What did I just ask?",expected)["status"],"withheld")
+        actual = self.runtime.chat("What did I just ask?","a")
+        self.assertEqual(actual,expected)
+        self.assertEqual(actual["response"],f'You asked: "{QUESTION}" [session:turn 1]. I answered: "{ANSWER}".')
+        self.assertEqual(actual["provenance"]["turns"],[1])
+        self.assertEqual(len(self.dialogue.logs["a"]),2)  # guard read added no turn
+
+    def test_empty_session_does_not_recall_another_session(self):
+        actual = self.runtime.chat("What did I just ask?","empty")
+        self.assertEqual(actual["status"],"answered")
+        self.assertIn("first thing",actual["response"])
+        self.assertEqual(actual["references"],[])
+        self.assertNotIn(QUESTION,actual["response"])
+        self.assertEqual(len(self.dialogue.logs["empty"]),1)
+        self.assertEqual(len(self.dialogue.logs["a"]),1)
+
+    def test_repeat_recall_and_supported_variants_do_not_recall_themselves(self):
+        for question in ("What did I just ask?","What was my previous question?","What did I last say?"):
+            actual = self.runtime.chat(question,"a")
+            self.assertEqual(actual["status"],"answered")
+            self.assertIn(QUESTION,actual["response"])
+            self.assertEqual(actual["provenance"]["turns"],[1])
+        self.assertEqual(len(self.dialogue.logs["a"]),4)
+
+    def test_withheld_turn_is_recalled_as_a_request_not_as_a_true_answer(self):
+        self.dialogue.log("a","What is my bank balance?",dict(status="withheld",path="precision_guard:G2_private_state",
+                                                           response="I do not know your balance."))
+        actual = self.runtime.chat("What did I just ask?","a")
+        self.assertEqual(actual["status"],"answered")
+        self.assertIn('You asked: "What is my bank balance?"',actual["response"])
+        self.assertIn("I did not answer it",actual["response"])
+        self.assertEqual(actual["provenance"]["turns"],[2])
+
+    def test_private_and_compound_questions_are_still_withheld(self):
+        for question in ("What is my bank account balance?","What is my password?",
+                         "What did I dream about last night?","What number am I thinking of?",
+                         "What did I just ask? And what is my PIN?",
+                         "What did I just ask and what is my password?",
+                         "What did I just ask in another conversation?"):
+            with self.subTest(question=question):
+                self.runtime.forced_reply = self.history_reply()
+                actual = self.runtime.chat(question,"a")
+                self.assertEqual(actual["status"],"withheld")
+                self.assertIn("G2_private_state",actual["path"])
+
+    def test_route_or_turn_labels_do_not_license_fabricated_content(self):
+        for field, altered in (("response","Your password is swordfish."),
+                               ("references",[]),
+                               ("provenance",dict(kind="organ_dialogue",move="discourse:asked_last",turns=[99]))):
+            with self.subTest(field=field):
+                self.runtime.forced_reply = self.history_reply()
+                self.runtime.forced_reply[field] = altered
+                self.assertEqual(self.runtime.chat("What did I just ask?","a")["status"],"withheld")
+
+    def test_stale_reply_and_other_session_reply_are_withheld(self):
+        stale = self.history_reply()
+        self.dialogue.log("a","What is 9 multiplied by 9?",dict(status="answered",path="compute:verified",response="81."))
+        self.runtime.forced_reply = stale
+        self.assertEqual(self.runtime.chat("What did I just ask?","a")["status"],"withheld")
+        self.runtime.forced_reply = self.history_reply("a")
+        self.assertEqual(self.runtime.chat("What did I just ask?","b")["status"],"withheld")
+
+    def test_missing_history_handler_fails_closed(self):
+        self.runtime.forced_reply = self.history_reply()
+        self.runtime._c480_dialogue = lambda: None
+        # Invoke the real guard with a controlled parent that does not need its log.
+        with patch.object(Parent,"chat",return_value=self.runtime.forced_reply):
+            self.assertEqual(self.runtime.chat("What did I just ask?","a")["status"],"withheld")
+
+    def test_other_guards_and_quantity_computations_remain_active(self):
+        reply = dict(status="answered",path="specialist_call>x",response="The speed is 3 m/s.")
+        self.assertIn("G1_sign_kept",GUARD.final_guards("Compute speed for -3 m/s",reply)["path"])
+        self.assertIs(GUARD.final_guards("My car does 30 mpg; how far for 2 gallons?",reply),reply)
+        with patch.object(GUARD,"premise_years",return_value=("Painting",1990,[1889])):
+            self.assertIn("G3_date_premise",GUARD.final_guards("Who painted Painting in 1990?",reply)["path"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/usage/README.md

@@ -0,0 +1,26 @@
+# Focused usage regressions
+
+These tests exercise the changed runtime functions and actual specialist/family
+consumers with controlled expensive parents. They do not start the full Engine,
+download stores, rerun release admission or make theorem claims. Source defaults
+to this checkout; use the upstream Python requirements for the SymPy tests.
+
+From the repository root, run these selected directories individually:
+
+```sh
+for group in computing conversation composition evidence documents engineering research reliability reliability_route; do
+  python -B -m unittest discover -s tests/usage/$group -v || exit 1
+done
+for group in conversation_guard conversation_grammar conversation_grammar_r468; do
+  python -B -m unittest discover -s tests/$group -v || exit 1
+done
+for version in 2 3; do
+  MATH_ORGAN_SOURCE="$PWD/root/wander-train/math_organ_v$version.py" \
+    python -B -m unittest discover -s tests/usage/evidence -v || exit 1
+done
+```
+
+The fixtures contain bounded synthetic questions, their independent expectations,
+and selected public-fact reply shapes. Tests of the local appliance HTTP adapter,
+Mini authority, workflow tools and data-transfer extension are not part of this
+source contribution. No historical verdict or release hash is rewritten.

tests/usage/composition/test_energy_repair.py

@@ -0,0 +1,131 @@
+"""Independent requested-quantity checks for the actual v3 organ chain."""
+import importlib
+import json
+import math
+import os
+from pathlib import Path
+import sys
+import unittest
+
+ROOT = Path(__file__).resolve().parents[3]
+DIRECTORY = Path(os.environ.get('ENERGY_ORGAN_DIRECTORY', ROOT / 'root/specialists/energy-v3'))
+sys.path.insert(0, str(DIRECTORY))
+from organ_energy_v3 import EnergyOrganV3
+
+
+class EnergyRepairTests(unittest.TestCase):
+    def setUp(self):
+        self.organ = EnergyOrganV3()
+
+    def value(self, q, expected, kind=None):
+        reply = self.organ.answer(q)
+        self.assertIsNotNone(reply, q)
+        self.assertEqual(reply['status'], 'answered', reply)
+        self.assertAlmostEqual(reply['value'], expected, msg=reply)
+        self.assertTrue(math.isfinite(reply['value']))
+        if kind: self.assertEqual(reply['kind'],kind)
+        return reply
+
+    def refusal(self, q):
+        reply = self.organ.answer(q)
+        self.assertTrue(reply is None or reply['status'] != 'answered', reply)
+        return reply
+
+    def test_original_six_energy_failures(self):
+        results = {'solar_useful':1.6, 'net_energy':3.5, 'battery_roles':7.2,
+                   'battery_plain':7.2, 'battery_rating_first':7.2, 'battery_invalid':None}
+        for file in ['composition/cases.json','engineering/cases.json','engineering/followup_cases.json']:
+            for c in json.loads((ROOT/'tests/usage/fixtures'/file).read_text()):
+                if c['id'] in results:
+                    with self.subTest(case=c['id']):
+                        value=results[c['id']]
+                        if value is None: self.refusal(c['text'])
+                        else: self.value(c['text'],value)
+
+    def test_runtime_role_permutations_and_kw_units(self):
+        for detail in ['with a 500 W rated inverter run a 100 W load',
+                       'run a 100 W load through a 500 W rated inverter',
+                       'with an inverter rated at 0.5 kW run a 0.1 kW load']:
+            self.value('How long can a 1000 Wh battery '+detail+' with 90% inverter efficiency and 80% depth of discharge?',7.2,'runtime')
+        self.value('How long can a 24 V 50 Ah battery run a 200 W load with efficiency 0.9 and usable fraction 0.8?',4.32)
+
+    def test_zero_and_full_factors(self):
+        for eff,depth,value in [(0,80,0),(90,0,0),(100,100,10)]:
+            self.value(f'How long can a 1000 Wh battery run a 100 W load with {eff}% efficiency and {depth}% depth of discharge?',value)
+
+    def test_bad_factor_ranges_and_unbound_conditions(self):
+        for adjustment in ['120% efficiency','-10% efficiency','110% depth of discharge',
+                           '90% charging efficiency','90% motor efficiency','20% reserve',
+                           'inverter efficiency unspecified','temperature derate 0.8',
+                           'half full','a variable load','0.8 state of charge']:
+            with self.subTest(adjustment=adjustment):
+                self.refusal('How long can a 1000 Wh battery run a 100 W load with '+adjustment+'?')
+
+    def test_loss_is_not_multiplied_twice(self):
+        self.value('How long can a 1000 Wh battery run a 100 W load with 10% inverter losses and 80% depth of discharge?',7.2)
+        self.value('How long can a 1000 Wh battery run a 100 W load with 90% efficiency and 10% losses?',9)
+        self.refusal('How long can a 1000 Wh battery run a 100 W load with 90% efficiency and 20% losses?')
+        self.refusal('How long can a 1000 Wh battery run a 100 W load with 90% efficiency and 80% efficiency?')
+
+    def test_power_constraints_and_ambiguity(self):
+        for q in ['How long can a 1000 Wh battery run a 600 W load through a 500 W inverter?',
+                  'How long can a 1000 Wh battery run a 0 W load?',
+                  'How long can a 1000 Wh battery run a -100 W load?',
+                  'How long can a 1000 Wh battery run a 100 W fan and a 200 W heater?',
+                  'How long can a 1000 Wh battery with a 500 W inverter run?',
+                  'How long can a 1000 Wh battery run a 100 W load with a 5 W standby draw?']:
+            self.refusal(q)
+
+    def test_conflicting_capacity_and_negative_values(self):
+        self.refusal('How long can a 1000 Wh battery with 12 V and 10 Ah run a 100 W load?')
+        self.refusal('How long can a -1000 Wh battery run a 100 W load?')
+        self.value('How long can a 120 Wh battery with 12 V and 10 Ah run a 100 W load?',1.2)
+
+    def test_remaining_uses_battery_side_withdrawal(self):
+        r=self.value('A battery initially stores 5 kWh. A 500 W load runs for 3 hours with 90% inverter efficiency. How much energy remains in the battery?',5-1.5/0.9)
+        self.assertIn('remaining energy',r['response'])
+        r=self.value('A battery initially stores 5 kWh. A 500 W load runs for 5 hours with 80% depth of discharge. How much usable energy remains?',1.5)
+        self.assertIn('usable remaining',r['response'])
+
+    def test_remaining_requires_initial_and_feasible_duration(self):
+        for q in ['A 5 kWh battery supplies a 500 W load for 3 hours. How much energy remains?',
+                  'A battery initially stores 1 kWh. A 500 W load runs for 3 hours. How much energy remains?',
+                  'A battery initially stores 1 kWh. A 500 W load runs for -1 hours. How much energy remains?',
+                  'A battery initially stores 1 kWh. A 500 W load runs for 1 hours with 0% efficiency. How much energy remains?',
+                  'A battery initially stores 1 kWh. A 500 W load runs for 1 hours and then 2 hours. How much energy remains?']:
+            self.refusal(q)
+
+    def test_storage_from_power_or_energy(self):
+        self.value('A 400 W solar panel produces power for 5 hours with 80% charging efficiency. How much energy is stored?',1.6)
+        self.value('A solar panel produces 2 kWh. A battery stores 80% of this energy. What is the stored energy?',1.6)
+        self.value('A 400 W solar panel gets 5 peak sun hours. A battery stores 80% of this energy. What is the stored energy?',1.6)
+        self.value('3 panels each produce 400 W for 5 hours. A battery stores 80% of this energy. What is the stored energy?',4.8)
+        self.value('A 400 W solar panel produces power for 5 hours. Ignoring losses, how much energy is stored?',2)
+
+    def test_storage_unbound_and_conflicting_conditions(self):
+        for q in ['A 400 W solar panel runs for 5 hours. What is the stored energy?',
+                  'A 400 W solar panel runs for 5 hours. A battery stores 120% of this energy. What is the stored energy?',
+                  'A 400 W solar panel runs for 5 hours. A battery stores 80% of this energy with 50% depth of discharge. What is the stored energy?',
+                  '3 panels produce 400 W for 5 hours. A battery stores 80% of this energy. What is the stored energy?',
+                  'A 400 W solar panel runs for -5 hours. A battery stores 80% of this energy. What is the stored energy?',
+                  'A 400 W solar panel runs for 5 hours. A battery stores 80% of this energy at 90% storage efficiency. What is the stored energy?']:
+            self.refusal(q)
+
+    def test_changed_numbers_check_arithmetic_independently(self):
+        # Independent arithmetic, outside the shipped examples/templates.
+        for cap,load,eff,depth in [(1630,270,86,70),(300,50,75,40),(4200,350,95,90)]:
+            self.value(f'How long can a {cap} Wh battery run a {load} W load with {eff}% inverter efficiency and {depth}% depth of discharge?', cap*eff*depth/(10000*load))
+
+    def test_malformed_groups_and_multiple_sources_do_not_salvage_a_number(self):
+        for q in ['A battery initially stores 1,2 kWh. A 100 W load runs for 1 hour. How much energy remains?',
+                  'How long can a 1,2 kWh battery run a 100 W load?',
+                  'How long can a 1000 Wh battery run a 1,00 W load?',
+                  'How long can a 1000 Wh battery run a 100 W load with 90,5% efficiency?',
+                  'How long can two 1000 Wh batteries run a 100 W load?',
+                  'How long can 2 batteries each 1000 Wh run a 100 W load?',
+                  'How long can a 1000 Wh battery run two 100 W fans?']:
+            self.refusal(q)
+        self.value('How long can a 1,000 Wh battery run a 100 W load?',10)
+
+
+if __name__ == '__main__': unittest.main()

tests/usage/computing/test_base_conversion.py

@@ -0,0 +1,88 @@
+"""Narrow regression checks; no engine startup or specialist panel claim."""
+import importlib.util
+import os
+from pathlib import Path
+import unittest
+
+ROOT = Path(__file__).resolve().parents[3]
+MODULE = Path(os.environ.get('ORACLE_OPERATOR_SPECS', ROOT / 'root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/oracle_operator_specs_v1.py'))
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+op = load('computing_test_operator', MODULE)
+
+
+class BaseConversionRepair(unittest.TestCase):
+    def check(self, prompt, expected, value, source):
+        args = op._base_parse(prompt)
+        self.assertEqual((args['n'], args['frm']), (value, source))
+        actual, _ = op._base_fn(args)
+        self.assertEqual(actual, expected)
+        self.assertEqual(op._base_ref(args), expected)
+
+    def test_real_wrong_answer_and_explicit_source(self):
+        self.check('Convert binary 11111111 to decimal.', '255', 255, 2)
+        self.check('Convert 11111111 from base 2 to base 10.', '255', 255, 2)
+        self.check('Convert 17 from base 8 to base 10.', '15', 15, 8)
+        self.check('Convert 0010 from base 2 to base 10.', '2', 2, 2)
+
+    def test_hexadecimal_words_and_prefix(self):
+        for text in ('Convert hex ff to binary.', 'Convert ff from hexadecimal to binary.',
+                     'What is 0xff in binary?', 'Convert +0xff to binary.'):
+            self.check(text, '11111111', 255, 16)
+        self.check('Convert 0b1010 to decimal.', '10', 10, 2)
+        self.check('Convert 0o17 to decimal.', '15', 15, 8)
+        self.check('Convert 1010 in binary to decimal.', '10', 10, 2)
+
+    def test_decimal_control_and_zero(self):
+        self.check('Convert 255 to hexadecimal.', 'ff', 255, 10)
+        self.check('Write 0 in binary.', '0', 0, 10)
+        self.check('Express +15 as hex.', 'f', 15, 10)
+        self.check('Convert decimal 255 to hex.', 'ff', 255, 10)
+
+    def test_declines_invalid_digits_signs_and_conflicting_bases(self):
+        for text in ('Convert 102 from base 2 to base 10.', 'Convert binary 102 to decimal.',
+                     'Convert -10 to binary.', 'Convert -0xff to binary.',
+                     'Convert 0x to decimal.', 'Convert 19 from base 8 to decimal.',
+                     'Convert 10 from base 1 to decimal.', 'Convert 10 to base 37.',
+                     'Convert binary 11 from base 8 to decimal.',
+                     'Convert decimal 0xff to binary.'):
+            with self.subTest(text=text), self.assertRaises(op.OutOfFragment):
+                op._base_parse(text)
+
+    def test_never_takes_a_suffix_of_malformed_or_compound_input(self):
+        for text in ('Convert - 10 to binary.', 'Convert 12.5 to binary.',
+                     'Convert 10 to binary and 20 to hexadecimal.',
+                     'Convert 1011/2 to decimal.', 'Convert 0b102 to decimal.',
+                     'Convert --10 to binary.', 'Convert ++10 to binary.'):
+            with self.subTest(text=text), self.assertRaises(op.OutOfFragment):
+                op._base_parse(text)
+
+    def test_every_source_target_base_with_independent_integer_values(self):
+        # 35*35*5 known source values; output decoding is stdlib int rather
+        # than either target-encoding implementation under test.
+        for source in range(2, 37):
+            for target in range(2, 37):
+                for digits in ('0', '1', '10', '11', '101'):
+                    args = op._base_parse(f'Convert {digits} from base {source} to base {target}.')
+                    expected = {'0': 0, '1': 1, '10': source,
+                                '11': source+1, '101': source*source+1}[digits]
+                    output, _ = op._base_fn(args)
+                    self.assertEqual(int(output, target), expected)
+                    self.assertEqual(op._base_ref(args), output)
+
+    def test_arithmetic_does_not_reuse_a_corrupted_decimal_binding(self):
+        args = op._base_parse('Convert binary 11111111 to decimal.')
+        args['n'] = 11111111
+        self.assertEqual(op._base_fn(args)[0], '255')
+        self.assertEqual(op._base_ref(args), '255')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/usage/conversation/birth-replies.json

@@ -0,0 +1,69 @@
+[
+  {
+    "text": "When was Albert Einstein born?",
+    "reply": {
+      "status": "answered",
+      "path": "family_precedence>specialist_call>specialist:rel-engineers>engineers",
+      "response": "14 March 1879. From the Wikidata relation store: Albert Einstein (Q937) - year of birth (P569) - 14 March 1879. [rel-engineers]",
+      "provenance": {
+        "kind": "family_precedence",
+        "replaced_route": "capability:when_did",
+        "replaced_response": "[ev:direct] According to Albert Einstein, Albert Einstein (14 March 1879 – 18 April 1955) was a German-born Jewish scientist. [simplewiki_a9a88ffc711143a397966482] Albert Einstein also records: Einstein was born in Ulm, Württemberg, Germany, on 14 March 1879. [simplewiki_e131399c5b98026c642abcac]",
+        "specialist": "rel-engineers",
+        "chat_resolved": null
+      },
+      "latency_ms": 0.2,
+      "zero_model_gate": {
+        "lm_calls": 0,
+        "transformer_calls": 0
+      },
+      "evidential": {
+        "input_marked": null,
+        "answer_licensed": "direct"
+      },
+      "continuation": {
+        "doors": [
+          "germany",
+          "scientist"
+        ],
+        "offer": "from here, germany or scientist stand open"
+      },
+      "references": []
+    },
+    "receipt": "var/usage-20261026/evidence/run-1/results.jsonl"
+  },
+  {
+    "text": "When was John Williams born?",
+    "reply": {
+      "status": "answered",
+      "path": "family_precedence>specialist_call>specialist:rel-composers>composers",
+      "response": "8 February 1932. From the Wikidata relation store: John Williams (Q131285) - year of birth (P569) - 8 February 1932. [rel-composers]",
+      "provenance": {
+        "kind": "family_precedence",
+        "replaced_route": "capability:when_did",
+        "replaced_response": "[ev:direct] According to John Williams, John Towner Williams (born February 8, 1932) is an American composer and conductor. [simplewiki_8cb1cf64a055db807a2b8983] John Williams also records: John Towner Williams was born in Queens, New York City, New York on February 8, 1932. [simplewiki_26349c5d4659",
+        "specialist": "rel-composers",
+        "chat_resolved": null
+      },
+      "latency_ms": 0.1,
+      "zero_model_gate": {
+        "lm_calls": 0,
+        "transformer_calls": 0
+      },
+      "evidential": {
+        "input_marked": null,
+        "answer_licensed": "direct"
+      },
+      "continuation": {
+        "doors": [
+          "city",
+          "composer",
+          "conductor"
+        ],
+        "offer": "from here, city or composer stand open"
+      },
+      "references": []
+    },
+    "receipt": "var/usage-20261026/research/run-1/results.jsonl"
+  }
+]

tests/usage/conversation/test_state.py

@@ -0,0 +1,126 @@
+"""Scoped legacy-state regressions; no engine, corpus writes, or proof claims."""
+import importlib.util
+import json
+from pathlib import Path
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[3]
+spec = importlib.util.spec_from_file_location('conversation_reconciliation', ROOT/'root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted/runtime_conversation_state.py')
+helper = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(helper)
+
+
+class ConversationTests(unittest.TestCase):
+    def setUp(self):
+        self.modules = patch.dict(sys.modules, {'relation_spec_v1': types.SimpleNamespace()})
+        self.modules.start()
+        path = ROOT/'root/wander-train/chat_context_v2.py'
+        spec = importlib.util.spec_from_file_location('chat_context_v2', path)
+        self.cc = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(self.cc)
+        sys.modules['chat_context_v2'] = self.cc
+        self.cc.recognised = lambda q: q.startswith(('Who', 'When', 'What'))
+        self.cc._entity_of_question = lambda q: None
+        self.cc._entity_of_reply = lambda reply, prefer_person=False: (1, 'Jane Austen', True) if reply.startswith('Jane Austen') else None
+        self.rt = types.SimpleNamespace(_last_value={}, _v4_disc={})
+
+    def tearDown(self):
+        self.modules.stop()
+
+    def turn(self, text, reply, sid='s', supported=True, mutate=None, runtime=None):
+        rt = runtime or self.rt
+        frame = helper.begin(rt, text, sid)
+        if mutate:
+            mutate(rt, self.cc.state(sid))
+        helper.finish(rt, text, reply, frame, supported)
+        helper.release(frame)
+        return rt._conversation_contexts[sid]
+
+    def test_final_author_supports_pronoun(self):
+        self.turn('Who wrote Emma?', {'status':'answered','path':'organ:relation>form:author','response':'Jane Austen.'})
+        frame = helper.begin(self.rt, 'When was she born?', 's')
+        self.assertEqual(self.cc._person(self.cc.state('s')), 'Jane Austen')
+        helper.release(frame)
+        self.assertNotIn('s', self.cc._STATES)
+
+    def test_unknown_new_topic_discards_previous_person_and_number(self):
+        self.turn('Who wrote Emma?', {'status':'answered','path':'specialist_call','response':'Jane Austen.'})
+        self.rt._last_value['s'] = 12
+        self.rt._v4_disc['s'] = {'entity':'Jane Austen'}
+        state = self.turn('New topic: who wrote Zeralune?', {'status':'withheld','path':'factoid:withheld'}, supported=False)
+        self.assertIsNone(self.cc._person(state))
+        self.assertNotIn('s', self.rt._last_value)
+        self.assertNotIn('s', self.rt._v4_disc)
+
+    def test_final_scalar_replaces_stale_number(self):
+        self.rt._last_value['s'] = 12
+        r={'status':'answered','path':'organ:math>evaluate','response':'[ev:derived] 126. In steps: read 126; then evaluate.',
+           'provenance':{'kind':'organ_math','directive':'evaluate'}}
+        state=self.turn('Correction: calculate 21 * 6 instead.',r)
+        self.assertEqual(self.rt._last_value['s'],126)
+        self.assertEqual(state.result,(126,''))
+
+    def test_quantity_keeps_unit_without_becoming_dimensionless_scalar(self):
+        r={'status':'answered','path':'specialist_call','response':'The answer is 300 kWh.'}
+        state=self.turn('What is the energy for 10 hours?',r)
+        self.assertEqual(state.result,(300,'kwh'))
+        self.assertNotIn('s', self.rt._last_value)
+
+    def test_acknowledgement_preserves_context(self):
+        self.turn('Who wrote Emma?', {'status':'answered','path':'specialist_call','response':'Jane Austen.'})
+        state=self.turn('Thanks', {'status':'answered','path':'act:acknowledge','response':'You are welcome.'})
+        self.assertEqual(self.cc._person(state),'Jane Austen')
+
+    def test_clarification_does_not_learn_speculative_person(self):
+        def speculate(rt,state): state.ans=(2,'Wrong Person',True)
+        state=self.turn('Who wrote unknown?',{'status':'clarification','path':'act:clarify'},supported=False,mutate=speculate)
+        self.assertIsNone(state.ans)
+
+    def test_same_session_id_in_two_instances_is_isolated(self):
+        self.turn('Who wrote Emma?', {'status':'answered','path':'specialist_call','response':'Jane Austen.'})
+        other=types.SimpleNamespace(_last_value={},_v4_disc={})
+        outer=helper.begin(self.rt,'When was she born?','s')
+        nested=helper.begin(other,'When was she born?','s')
+        self.assertIsNone(self.cc._person(self.cc.state('s')))
+        helper.release(nested)
+        self.assertEqual(self.cc._person(self.cc.state('s')),'Jane Austen')
+        helper.release(outer)
+
+    def test_different_sessions_and_nested_turn_restore_ambient_context(self):
+        self.turn('Who wrote Emma?', {'status':'answered','path':'specialist_call','response':'Jane Austen.'},sid='a')
+        a=helper.begin(self.rt,'When was she born?','a')
+        b=helper.begin(self.rt,'When was she born?','b')
+        self.assertIsNone(self.cc._person(self.cc.state('b')))
+        helper.release(b)
+        self.assertEqual(self.cc._person(self.cc.state('a')),'Jane Austen')
+        helper.release(a)
+        self.assertEqual(self.cc._STATES,{})
+
+    def test_real_direct_birth_replies_with_null_chat_resolution(self):
+        rows = json.loads((Path(__file__).with_name('birth-replies.json')).read_text())
+        for row in rows:
+            with self.subTest(question=row['text']):
+                self.assertIsNone(row['reply']['provenance']['chat_resolved'])
+                state = self.turn(row['text'], row['reply'])
+                self.assertEqual(state.q, row['text'])
+                self.assertNotIn('s', self.cc._STATES)
+
+    def test_optional_rewrite_metadata_is_typed_and_nonempty(self):
+        for prov in (None, [], 'none', {'chat_resolved': None}, {'chat_resolved': []},
+                     {'chat_resolved': {'read_as': None}}, {'chat_resolved': {'read_as': ''}}):
+            with self.subTest(provenance=prov):
+                state = self.turn('When was Jane Austen born?',
+                    {'status':'answered','path':'specialist_call','response':'16 December 1775.', 'provenance':prov})
+                self.assertEqual(state.q, 'When was Jane Austen born?')
+
+    def test_not_a_scalar_route_and_nonfinite_or_unit_answer_never_become_number(self):
+        for path,body in [('pretend-compute:verified','The answer is 7.'),('organ:math>evaluate','[ev:derived] 1e999. In steps:'),('organ:math>evaluate','[ev:derived] 3 kg. In steps:')]:
+            r={'status':'answered','path':path,'response':body,'provenance':{'kind':'organ_math','directive':'evaluate'}}
+            self.rt._last_value['s']=12
+            self.turn('Calculate 3',r)
+            self.assertNotIn('s',self.rt._last_value)
+
+if __name__=='__main__': unittest.main()

tests/usage/documents/test_conflict_repair.py

@@ -0,0 +1,82 @@
+"""Untrusted isolated-method regression, not a full-engine or panel test.
+
+Load actual passage helpers using AST, without importing the heavyweight engine.
+WordNet aliases are disabled: these regressions all use literal matching terms.
+Reads the current checkout; no source mutation.
+"""
+import ast
+from pathlib import Path
+import re
+import time
+import types
+import unittest
+
+ROOT = Path(__file__).resolve().parents[3]
+REL = Path('root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted')
+CANDIDATE = ROOT
+
+
+def definitions(source, names, namespace):
+    nodes = []
+    for node in ast.parse(source).body:
+        if isinstance(node, (ast.FunctionDef, ast.ClassDef)) and node.name in names:
+            nodes.append(node)
+        elif isinstance(node, ast.Assign) and any(isinstance(t, ast.Name) and t.id in names for t in node.targets):
+            nodes.append(node)
+    exec(compile(ast.Module(nodes, type_ignores=[]), '<isolated-source>', 'exec'), namespace)
+
+
+def reader(source):
+    ns420 = {'re': re}
+    definitions((CANDIDATE / REL / 'oracle_release_runtime_w420.py').read_text(), {'IRREGULAR', '_stem', '_toks'}, ns420)
+    ns434 = {'re': re, '_w420': types.SimpleNamespace(_toks=ns420['_toks'])}
+    names = {'_stem', '_in_order', 'NEG', 'NEG_TOK', 'MODAL', 'PRESENT_Q', 'PAST', 'PRESENT', 'CMP_Q', 'IDENTITY', 'OB_Q', 'OB_S', 'TEMP_Q', 'TEMP_S', 'SUP_Q', 'HEDGE_S', 'USE_ORDER', 'USE_TEMPORAL', 'USE_SUPERL'}
+    text434 = (CANDIDATE / REL / 'oracle_release_runtime_w434.py').read_text()
+    definitions(text434, names, ns434)
+    cls434 = next(n for n in ast.parse(text434).body if isinstance(n, ast.ClassDef))
+    method = next(n for n in cls434.body if isinstance(n, ast.FunctionDef) and n.name == '_r434_verdict')
+    exec(compile(ast.Module([method], type_ignores=[]), '<actual-verdict>', 'exec'), ns434)
+    class Base:
+        _r434_verdict = ns434['_r434_verdict']
+        def _r434_receipt(self, out, res, text, reason):
+            return {'status': 'withheld', 'response': text, 'reason': reason}
+    ns = {'re': re, 'time': time, '_Base': Base}
+    definitions(source, {'PASSAGE', 'YESNO_HEAD', 'STOP', 'REQUIRED', '_toks', '_stem', '_sentences', '_qterms', 'OracleReleaseRuntimeW442'}, ns)
+    instance = ns['OracleReleaseRuntimeW442']()
+    instance._r436_aliases = lambda term: {}
+    return instance
+
+
+class ConflictTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.after = reader((CANDIDATE / REL / 'oracle_release_runtime_w442.py').read_text())
+
+    def ask(self, engine, text):
+        return engine._r434_passage('Passage: '+text+' Question: Is the Lumen Archive open on Sunday?', {}, time.time())
+
+    def test_reproduces_and_repairs_both_orders(self):
+        yes = 'Version one says the Lumen Archive is open on Sunday.'
+        no = 'Version two says the Lumen Archive is not open on Sunday.'
+        for text in (yes+' '+no, no+' '+yes):
+            result = self.ask(self.after, text)
+            self.assertEqual(result['status'], 'withheld')
+            self.assertEqual(result['reason'], 'conflicting_covering_sentences')
+            self.assertEqual({r['text'] for r in result['references']}, {yes, no})
+
+    def test_preserves_nonconflicting_answers(self):
+        for text, expected in (
+            ('The Lumen Archive is open on Sunday.', 'Yes.'),
+            ('The Lumen Archive is not open on Sunday.', 'No.'),
+            ('The Lumen Archive is open on Sunday. The Cedar Archive is not open on Sunday.', 'Yes.'),
+            ('The Lumen Archive is open on Sunday. The Lumen Archive is open on Sunday.', 'Yes.'),
+        ):
+            self.assertTrue(self.ask(self.after, text)['response'].startswith(expected))
+
+    def test_preserves_missing_and_modal_refusals(self):
+        for text in ('The Lumen Archive is in Alderport.', 'The Lumen Archive will open on Sunday.'):
+            self.assertEqual(self.ask(self.after, text)['status'], 'withheld')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/usage/engineering/test_condition_attachment.py

@@ -0,0 +1,142 @@
+"""Narrow source regression: trailing physical assumptions remain with their question."""
+import importlib.util
+import json
+import os
+from pathlib import Path
+import unittest
+
+ROOT = Path(__file__).resolve().parents[3]
+SLIM = Path(os.environ.get("ENGINEERING_SLIM_ROOT", ROOT))
+SOURCE = SLIM / "root/specialists/_gate/combo_runtime_v1.py"
+
+
+def load_source():
+    spec = importlib.util.spec_from_file_location("engineering_condition_combo", SOURCE)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+@unittest.skipUnless(SOURCE.is_file(), "requires private Slim source (set ENGINEERING_SLIM_ROOT)")
+class ConditionAttachmentTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.combo = load_source()
+        cases = json.loads((ROOT / "tests/usage/fixtures/engineering/cases.json").read_text())
+        cls.heat = next(case["text"] for case in cases if case["id"] == "heat_endpoints")
+
+    def test_exact_observed_heat_failure_through_real_thermo(self):
+        directory = SLIM / "root/specialists/thermo"
+        combo = self.combo.Combo([str(directory / "manifest.json")], [str(directory)])
+        reply = combo.reply(self.heat)
+        self.assertEqual(reply["status"], "answered")
+        self.assertEqual(reply["path"], "specialist:thermo>sensible_heat")
+        self.assertIn("5.016e+05 J", reply["response"])
+        self.assertIn("4180", reply["response"])
+        self.assertNotIn("4186", reply["response"])
+        self.assertNotIn("I need", reply["response"])
+
+    def test_real_combo_keeps_independent_second_task_visible(self):
+        directory = SLIM / "root/specialists/thermo"
+        combo = self.combo.Combo([str(directory / "manifest.json")], [str(directory)])
+        reply = combo.reply(self.heat + " What is 2+3?")
+        parts = reply["provenance"]["parts"]
+        self.assertEqual(len(parts), 2)
+        self.assertIn("4180", parts[0]["response"])
+        self.assertEqual(parts[1]["part"], "What is 2+3?")
+        self.assertIn("What is 2+3?", reply["response"])
+
+    def test_real_combo_retains_elliptical_followup(self):
+        directory = SLIM / "root/specialists/thermo"
+        combo = self.combo.Combo([str(directory / "manifest.json")], [str(directory)])
+        reply = combo.reply(self.heat + " How much?")
+        self.assertEqual(reply["path"], "specialist:thermo>sensible_heat")
+        self.assertIn("5.016e+05 J", reply["response"])
+
+    def test_full_short_question_before_thermo_not_swallowed(self):
+        directory = SLIM / "root/specialists/thermo"
+        combo = self.combo.Combo([str(directory / "manifest.json")], [str(directory)])
+        reply = combo.reply("Who wrote Hamlet? " + self.heat)
+        parts = reply["provenance"]["parts"]
+        self.assertEqual(len(parts), 2)
+        self.assertEqual(parts[0]["part"], "Who wrote Hamlet?")
+        self.assertIn("5.016e+05 J", parts[1]["response"])
+
+    def test_constant_load_request_through_real_energy(self):
+        cases = json.loads((ROOT / "tests/usage/fixtures/engineering/cases.json").read_text())
+        question = next(case["text"] for case in cases if case["id"] == "battery_roles")
+        directory = SLIM / "root/specialists/energy-v3"
+        combo = self.combo.Combo([str(directory / "manifest.json")], [str(directory)])
+        reply = combo.reply(question)
+        self.assertEqual(reply["path"], "specialist:energy-v3>runtime")
+        self.assertIn("7.2 hours", reply["response"])
+        self.assertIn("100 W load", reply["response"])
+        self.assertIn("500 W inverter rating", reply["response"])
+
+    def test_named_constant_conditions_attach(self):
+        for condition in ("The load is constant.", "The specific heat remains fixed.",
+                          "Flow rate stays steady throughout.", "The gravity is constant."):
+            with self.subTest(condition=condition):
+                q = "How long can the battery run? " + condition
+                self.assertEqual(self.combo._split_parts(q), [q])
+
+    def test_declarative_condition_does_not_absorb_second_task(self):
+        first = "How long can the battery run? The load is constant."
+        second = "What is 2+3?"
+        self.assertEqual(self.combo._split_parts(first + " " + second), [first, second])
+        for other in ("The load is constant; calculate its current.", "The load is a tree.",
+                      "The capital is Constant.", "The temperature is rising.",
+                      "The load is constant and what is its current?"):
+            with self.subTest(other=other):
+                self.assertEqual(self.combo._split_parts("How long? " + other), ["How long?", other])
+
+    def test_condition_forms_attach(self):
+        for condition in ("Use c=4180.", "Using c=4180.", "Assume no losses.",
+                          "Assuming no losses.", "Take gravity as 9.81.", "Given c=4180.",
+                          "With no phase change.", "Without friction.", "Ignore heat loss.",
+                          "Neglect pipe friction.", "Please use c=4180."):
+            q = "How much heat? " + condition
+            with self.subTest(condition=condition):
+                self.assertEqual(self.combo._split_parts(q), [q])
+
+    def test_multiple_conditions_and_second_question_preserved(self):
+        first = "How much heat? Use c=4180. Ignore heat loss."
+        second = "What is 2 + 3?"
+        self.assertEqual(self.combo._split_parts(first + " " + second), [first, second])
+
+    def test_second_question_with_its_own_premise_not_absorbed(self):
+        first = "What is 2 + 3?"
+        second = "Given 2 kg of water. How much heat raises it by 10 K?"
+        self.assertEqual(self.combo._split_parts(first + " " + second), [first, second])
+
+    def test_new_task_disguised_as_condition_not_absorbed(self):
+        for second in ("Use a calculator to compute 2+3.", "Use c=4180 and convert 2 m to cm.",
+                       "Assume no losses and find the motor power.", "Use c=4180; what is its unit?",
+                       "Take the square root of 9.", "Take a derivative of sin(x).",
+                       "Assume x=2 and evaluate x+1.", "Use a dictionary."):
+            with self.subTest(second=second):
+                self.assertEqual(self.combo._split_parts("How much heat? " + second), ["How much heat?", second])
+
+    def test_plain_independent_questions_still_split(self):
+        self.assertEqual(self.combo._split_parts("What is 2+3? What is 4+5?"), ["What is 2+3?", "What is 4+5?"])
+
+    def test_quoted_and_code_questions_not_boundaries(self):
+        for quote in ('"why? use c=1."', "`why? use c=1.`", "'why? use c=1.'"):
+            first = "What does " + quote + " mean?"
+            self.assertEqual(self.combo._split_parts(first + " What is 2+3?"), [first, "What is 2+3?"])
+
+    def test_quoted_question_inside_condition_retained(self):
+        q = 'How much heat? Use c=4180 with label "why? answer." for the sample.'
+        self.assertEqual(self.combo._split_parts(q), [q])
+
+    def test_decimal_and_semicolon_conditions_retained(self):
+        q = "How much heat? Use specific heat 4.18 kJ/(kg K); ignore losses."
+        self.assertEqual(self.combo._split_parts(q), [q])
+
+    def test_unrelated_declarative_tail_stays_visible(self):
+        self.assertEqual(self.combo._split_parts("How much heat? Copper has atomic number 29."),
+                         ["How much heat?", "Copper has atomic number 29."])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/usage/evidence/test_math_finite.py

@@ -0,0 +1,71 @@
+"""Focused source repair regression; no corpus, native build or specialist panel.
+
+Set MATH_ORGAN_SOURCE to test a provisioned copy. The default is this checkout. This file does not mutate or import the full engine.
+"""
+import importlib.util
+import os
+import sys
+from pathlib import Path
+import unittest
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[3]
+SOURCE = Path(os.environ.get('MATH_ORGAN_SOURCE', ROOT / 'root/wander-train/math_organ_v1.py'))
+
+
+@unittest.skipUnless(SOURCE.is_file(), 'optional appliance source not provisioned')
+class FiniteMathTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        helper_spec = importlib.util.spec_from_file_location('finite_math_helper', SOURCE.parent / 'math_organ_v1.py')
+        helper = importlib.util.module_from_spec(helper_spec)
+        helper_spec.loader.exec_module(helper)
+        spec = importlib.util.spec_from_file_location('finite_math_organ', SOURCE)
+        cls.module = importlib.util.module_from_spec(spec)
+        # v2/v3 share the helper from their own provisioned source directory.
+        with patch.dict(sys.modules, {'math_organ_v1': helper}):
+            spec.loader.exec_module(cls.module)
+        # No corpus opening: exercise the answer pipeline with method lookup absent.
+        cls.organ = cls.module.MathOrgan.__new__(cls.module.MathOrgan)
+        cls.organ.db = None
+        cls.organ.why = ''
+
+    def test_nonfinite_direct_evaluation_declined(self):
+        for expression in ('1/0', '0/0', 'oo', '-oo', 'oo-oo', '0*oo', 'log(0)'):
+            with self.subTest(expression=expression):
+                self.assertIsNone(self.organ._evaluate([expression], 'Evaluate ' + expression))
+
+    def test_real_question_route_declines_undefined(self):
+        for question in ('What is 1 / 0?', 'What is 0 / 0?', 'Evaluate log(0).'):
+            with self.subTest(question=question):
+                self.assertIsNone(self.organ.answer(question))
+
+    def test_finite_real_and_complex_results_preserved(self):
+        for expression, expected in (('17*23', '391'), ('1/3', '1/3'), ('sqrt(-1)', 'I'),
+                                     ('(1+I)*(1-I)', '2'), ('sqrt(2)', 'sqrt(2)')):
+            with self.subTest(expression=expression):
+                result = self.organ._evaluate([expression], 'Evaluate ' + expression)
+                self.assertIsNotNone(result)
+                self.assertEqual(result['answer'], expected)
+                self.assertEqual(result['check'], 'finite numerical comparison using SymPy')
+
+    def test_equiv_does_not_accept_nan_or_infinity(self):
+        sp = self.module.sp
+        for a, b in ((sp.nan, sp.nan), (sp.zoo, sp.zoo), (sp.oo, sp.oo), (sp.oo, 1)):
+            with self.subTest(a=a, b=b):
+                self.assertFalse(self.module.equiv(sp.sympify(a), sp.sympify(b)))
+
+    def test_numerical_comparison_checks_all_complex_components(self):
+        sp = self.module.sp
+        compare = self.module.finite_numeric_agreement
+        self.assertTrue(compare(sp.I, sp.I, 1e-9))
+        self.assertFalse(compare(sp.I, 2*sp.I, 1e-9))
+        self.assertFalse(compare(sp.Float('nan'), sp.Integer(1), 1e-9))
+        self.assertFalse(compare(sp.Integer(10)**1000, sp.Integer(10)**1000, 1e-9))
+
+    def test_ordinary_question_is_still_answered(self):
+        self.assertEqual(self.organ.answer('What is 17 * 23?')['answer'], '391')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/usage/fixtures/composition/cases.json

@@ -0,0 +1,62 @@
+[
+  {
+    "id": "journey",
+    "conversation_id": "composition_journey",
+    "text": "A car travels 150 km at a constant speed of 60 km/h. Parking then takes 15 minutes. What is the total elapsed time in hours?"
+  },
+  {
+    "id": "energy_cost",
+    "conversation_id": "composition_energy_cost",
+    "text": "A 1500 W heater runs for 2 hours. Electricity costs 0.20 dollars per kWh. What is the electricity cost in dollars?"
+  },
+  {
+    "id": "material_cost",
+    "conversation_id": "composition_material_cost",
+    "text": "An aluminium block has volume 0.002 m^3 and density 2700 kg/m^3. Aluminium costs 4 dollars per kg. What is the material cost in dollars?"
+  },
+  {
+    "id": "trip_fuel",
+    "conversation_id": "composition_trip_fuel",
+    "text": "A car uses 6 litres of fuel per 100 km and travels 250 km. Fuel costs 1.60 dollars per litre. What is the total fuel cost in dollars?"
+  },
+  {
+    "id": "resistor_energy",
+    "conversation_id": "composition_resistor_energy",
+    "text": "A 10 ohm resistor has 5 A of current for 60 seconds. What is the energy dissipated in joules?"
+  },
+  {
+    "id": "solar_useful",
+    "conversation_id": "composition_solar_useful",
+    "text": "A solar panel produces 400 W for 5 hours. A battery stores 80% of this energy. What is the stored energy in kWh?"
+  },
+  {
+    "id": "tank_fill",
+    "conversation_id": "composition_tank_fill",
+    "text": "A rectangular tank is 2 m long, 1 m wide and 0.5 m deep. A pump supplies 20 litres per minute. How many minutes does it take to fill the empty tank?"
+  },
+  {
+    "id": "work_price",
+    "conversation_id": "composition_work_price",
+    "text": "Three workers each work 8 hours at 20 dollars per hour. Materials cost 100 dollars. What is the total project cost in dollars?"
+  },
+  {
+    "id": "date_relation",
+    "conversation_id": "composition_date_relation",
+    "text": "Who wrote Leaves of Grass, and how many years after the author was born was the first edition published?"
+  },
+  {
+    "id": "orbital_ratio",
+    "conversation_id": "composition_orbital_ratio",
+    "text": "Earth takes 365.25 days to orbit the Sun and Mars takes 687 days. How many Earth years are 3 Mars years?"
+  },
+  {
+    "id": "net_energy",
+    "conversation_id": "composition_net_energy",
+    "text": "A battery initially stores 5 kWh. A 500 W appliance runs for 3 hours. Ignoring losses, how much energy remains in the battery in kWh?"
+  },
+  {
+    "id": "ambiguous_efficiency",
+    "conversation_id": "composition_ambiguous_efficiency",
+    "text": "A heater uses 2 kWh of electricity. How much useful heat does it produce?"
+  }
+]

tests/usage/fixtures/engineering/cases.json

@@ -0,0 +1,16 @@
+[
+ {"id":"lift_ideal","conversation_id":"lift","text":"How much energy is needed to lift a 25 kg crate vertically by 4 m? Use g = 9.81 m/s^2 and ignore losses."},
+ {"id":"lift_efficiency","conversation_id":"lift","text":"For that same lift, how much electrical energy is needed if the motor efficiency is 80%?"},
+ {"id":"pump_power","conversation_id":"pump","text":"A pump raises water at 0.002 m^3/s through a vertical height of 10 m. Use water density 1000 kg/m^3, g = 9.81 m/s^2, and 70% overall efficiency. What electrical input power is needed? Ignore pipe friction."},
+ {"id":"spring_work","conversation_id":"spring-work","text":"A linear spring has stiffness 200 N/m. Its extension changes from 0.1 m to 0.3 m. How much additional elastic energy is stored?"},
+ {"id":"spring_force","conversation_id":"spring-force","text":"A spring has unstretched length 0.4 m, final length 0.5 m and stiffness 200 N/m. What is its force magnitude?"},
+ {"id":"spring_simple","conversation_id":"spring-simple","text":"What is the elastic energy stored in a spring with stiffness 200 N/m and extension 0.3 m?"},
+ {"id":"heat_endpoints","conversation_id":"heat-endpoints","text":"How much heat is needed to warm 2 kg of water from 20 C to 80 C? Use constant specific heat 4180 J/(kg K), with no phase change or heat loss."},
+ {"id":"heat_interval","conversation_id":"heat-interval","text":"How much heat is needed to raise the temperature of 2 kg of water by 60 K? Use specific heat 4180 J/(kg K)."},
+ {"id":"battery_roles","conversation_id":"battery-roles","text":"How long can a 1000 Wh battery run a 100 W load through a 500 W rated inverter with 90% inverter efficiency and 80% depth of discharge? The load is constant."},
+ {"id":"battery_plain","conversation_id":"battery-plain","text":"How long can a 1000 Wh battery run a 100 W load with 90% inverter efficiency and 80% depth of discharge?"},
+ {"id":"battery_invalid","conversation_id":"battery-invalid","text":"How long can a 1000 Wh battery run a 100 W load with 120% inverter efficiency and 80% depth of discharge?"},
+ {"id":"conversion_flow","conversation_id":"conversion-flow","text":"Convert 30 litres per minute to cubic metres per second."},
+ {"id":"temperature_interval","conversation_id":"temperature-interval","text":"Convert a temperature increase of 18 F to a temperature increase in C."},
+ {"id":"dimension_mismatch","conversation_id":"dimension-mismatch","text":"Convert 2 metres to kilograms."}
+]

tests/usage/fixtures/engineering/followup_cases.json

@@ -0,0 +1,22 @@
+[
+  {
+    "id": "interval_helper_v2",
+    "conversation_id": "interval_helper_v2",
+    "text": "What is 18 * (5 / 9)?"
+  },
+  {
+    "id": "battery_rating_first",
+    "conversation_id": "battery_rating_first",
+    "text": "How long can a 1000 Wh battery with a 500 W rated inverter run a 100 W load with 90% inverter efficiency and 80% depth of discharge?"
+  },
+  {
+    "id": "spring_energy_rephrase",
+    "conversation_id": "spring_energy_rephrase",
+    "text": "How much energy is stored in a spring with stiffness 200 N/m and extension 0.3 m?"
+  },
+  {
+    "id": "heat_one_sentence",
+    "conversation_id": "heat_one_sentence",
+    "text": "How much heat is needed to warm 2 kg of water from 20 C to 80 C using specific heat 4180 J/(kg K), with no phase change or heat loss?"
+  }
+]

tests/usage/fixtures/reliability/cases.json

@@ -0,0 +1,77 @@
+[
+  {
+    "id": "percent_base",
+    "conversation_id": "rel_percent_base",
+    "text": "What is 20% of 80?"
+  },
+  {
+    "id": "percent_paraphrase",
+    "conversation_id": "rel_percent_paraphrase",
+    "text": "Calculate twenty percent of eighty."
+  },
+  {
+    "id": "percent_changed",
+    "conversation_id": "rel_percent_changed",
+    "text": "What is 25% of 80?"
+  },
+  {
+    "id": "area_base",
+    "conversation_id": "rel_area_base",
+    "text": "A rectangular room is 3 meters long and 4 meters wide. What is its area?"
+  },
+  {
+    "id": "area_paraphrase",
+    "conversation_id": "rel_area_paraphrase",
+    "text": "What is the area of a rectangle with width 4 meters and length 3 meters?"
+  },
+  {
+    "id": "area_incidental",
+    "conversation_id": "rel_area_incidental",
+    "text": "Apartment 12 has a rectangular room 3 meters long and 4 meters wide. What is the room area?"
+  },
+  {
+    "id": "perimeter_requested",
+    "conversation_id": "rel_perimeter_requested",
+    "text": "A rectangular room is 3 meters long and 4 meters wide. What is its perimeter?"
+  },
+  {
+    "id": "temperature_negative",
+    "conversation_id": "rel_temperature_negative",
+    "text": "Convert -5 degrees Celsius to Fahrenheit."
+  },
+  {
+    "id": "temperature_paraphrase",
+    "conversation_id": "rel_temperature_paraphrase",
+    "text": "What is five degrees below zero Celsius in Fahrenheit?"
+  },
+  {
+    "id": "zero_denominator",
+    "conversation_id": "rel_zero_denominator",
+    "text": "What is 10 divided by 0?"
+  },
+  {
+    "id": "zero_numerator",
+    "conversation_id": "rel_zero_numerator",
+    "text": "What is 0 divided by 10?"
+  },
+  {
+    "id": "speed_zero_time",
+    "conversation_id": "rel_speed_zero_time",
+    "text": "A car travels 150 kilometers in 0 hours. What is its average speed?"
+  },
+  {
+    "id": "speed_base",
+    "conversation_id": "rel_speed_base",
+    "text": "A car travels 150 kilometers in 3 hours. What is its average speed?"
+  },
+  {
+    "id": "speed_contradiction",
+    "conversation_id": "rel_speed_contradiction",
+    "text": "The same trip took exactly 3 hours and exactly 4 hours. The car traveled 150 kilometers. What was its average speed?"
+  },
+  {
+    "id": "area_contradiction",
+    "conversation_id": "rel_area_contradiction",
+    "text": "A rectangular room has length exactly 3 meters and length exactly 5 meters, and width 4 meters. What is its area?"
+  }
+]

tests/usage/fixtures/reliability/preserved_answers.json

@@ -0,0 +1,202 @@
+{
+  "scope": "Saved successful parent replies from U1 run-2; test fixtures, not fresh Engine output.",
+  "source": "var/usage-20261026/reliability/run-2/results.jsonl",
+  "cases": [
+    {
+      "text": "What is 20% of 80?",
+      "reply": {
+        "status": "answered",
+        "path": "organ:math>word:percent_of",
+        "response": "[ev:derived] 16. Read as percent of: 20% of 80. Checked: every quantity the formula needs was found with its unit, and the question asks for what the formula gives.",
+        "provenance": {
+          "kind": "organ_word_problem",
+          "schema": "percent_of",
+          "value": 16.0,
+          "parent_path": "arb:definitional->document_runtime|substitution_disclosed|math:out_of_fragment|vessel:receipt",
+          "parent_status": "withheld"
+        },
+        "latency_ms": 9.0,
+        "zero_model_gate": {
+          "lm_calls": 0,
+          "transformer_calls": 0
+        },
+        "arbitration": {
+          "winner": "definitional",
+          "runner_up": "act_continue",
+          "margin": 0.799,
+          "floor": false,
+          "regex_family": "open_topic",
+          "agrees": false,
+          "mode": "authoritative",
+          "arbiter": "v3",
+          "canonical_surface": "What is a 80?",
+          "capture_point": "capability"
+        },
+        "evidential": {
+          "input_marked": null,
+          "answer_licensed": "unknown"
+        },
+        "continuation": {
+          "doors": [
+            "cardinal",
+            "number",
+            "product"
+          ],
+          "offer": "from here, cardinal or number stand open"
+        }
+      }
+    },
+    {
+      "text": "Calculate twenty percent of eighty.",
+      "reply": {
+        "status": "answered",
+        "path": "compute:verified",
+        "response": "In steps: 20 % of 80 = 16. The answer is 16.",
+        "provenance": {
+          "kind": "computation",
+          "verified": true,
+          "steps": [
+            "20 % of 80 = 16"
+          ],
+          "carried_prior": false,
+          "evaluator": "w27_closed_grammar"
+        },
+        "latency_ms": 1
+      }
+    },
+    {
+      "text": "What is 25% of 80?",
+      "reply": {
+        "status": "answered",
+        "path": "organ:math>word:percent_of",
+        "response": "[ev:derived] 20. Read as percent of: 25% of 80. Checked: every quantity the formula needs was found with its unit, and the question asks for what the formula gives.",
+        "provenance": {
+          "kind": "organ_word_problem",
+          "schema": "percent_of",
+          "value": 20.0,
+          "parent_path": "arb:definitional->document_runtime|substitution_disclosed|math:out_of_fragment|vessel:receipt",
+          "parent_status": "withheld"
+        },
+        "latency_ms": 7.7,
+        "zero_model_gate": {
+          "lm_calls": 0,
+          "transformer_calls": 0
+        },
+        "arbitration": {
+          "winner": "definitional",
+          "runner_up": "timeline",
+          "margin": 0.688,
+          "floor": false,
+          "regex_family": "open_topic",
+          "agrees": false,
+          "mode": "authoritative",
+          "arbiter": "v3",
+          "canonical_surface": "What is a 80?",
+          "capture_point": "capability"
+        },
+        "evidential": {
+          "input_marked": null,
+          "answer_licensed": "unknown"
+        },
+        "continuation": {
+          "doors": [
+            "cardinal",
+            "number",
+            "product"
+          ],
+          "offer": "from here, cardinal or number stand open"
+        }
+      }
+    },
+    {
+      "text": "What is the area of a rectangle with width 4 meters and length 3 meters?",
+      "reply": {
+        "status": "answered",
+        "path": "organ:math>word:geometry",
+        "response": "[ev:derived] 12 square units. Read as geometry: A = L x W = 3 x 4. Checked: every quantity the formula needs was found with its unit, and the question asks for what the formula gives.",
+        "provenance": {
+          "kind": "organ_word_problem",
+          "schema": "geometry",
+          "value": 12.0,
+          "parent_path": "corpus_query:property_of|vessel:receipt",
+          "parent_status": "withheld"
+        },
+        "latency_ms": 2.0,
+        "zero_model_gate": {
+          "lm_calls": 0,
+          "transformer_calls": 0
+        },
+        "arbitration": {
+          "winner": "definitional",
+          "runner_up": "multi_step",
+          "margin": 0.722,
+          "floor": false,
+          "regex_family": null,
+          "agrees": null,
+          "mode": "shadow",
+          "arbiter": "v3"
+        },
+        "evidential": {
+          "input_marked": null,
+          "answer_licensed": "unknown"
+        }
+      }
+    },
+    {
+      "text": "Convert -5 degrees Celsius to Fahrenheit.",
+      "reply": {
+        "status": "answered",
+        "path": "specialist_call>specialist:units-v3>temperature",
+        "response": "-5 \u00b0C is 23 \u00b0F. [units-v3]",
+        "provenance": {
+          "kind": "core_called_specialist",
+          "core_status": "clarification",
+          "core_path": "act:clarify|vessel:receipt",
+          "specialist": "units-v3",
+          "parts": null,
+          "trace": {
+            "rule": "only"
+          }
+        },
+        "arbitration": {
+          "winner": "clarification",
+          "runner_up": "summarize",
+          "margin": 0.022,
+          "floor": true,
+          "regex_family": "open_topic",
+          "agrees": false,
+          "mode": "shadow",
+          "arbiter": "v3"
+        },
+        "latency_ms": 6.6,
+        "zero_model_gate": {
+          "lm_calls": 0,
+          "transformer_calls": 0
+        },
+        "evidential": {
+          "input_marked": null,
+          "answer_licensed": "unknown"
+        },
+        "references": []
+      }
+    },
+    {
+      "text": "What is 0 divided by 10?",
+      "reply": {
+        "status": "answered",
+        "path": "compute:verified",
+        "response": "In steps: 0 / 10 = 0. The answer is 0.",
+        "provenance": {
+          "kind": "computation",
+          "verified": true,
+          "steps": [
+            "0 / 10 = 0"
+          ],
+          "carried_prior": false,
+          "evaluator": "w27_closed_grammar"
+        },
+        "latency_ms": 1
+      }
+    }
+  ]
+}

tests/usage/reliability/test_geometry_consumer.py

@@ -0,0 +1,189 @@
+"""Untrusted focused harness: actual word module/w488 consumer, substituted parent.
+
+The w480 timed-call helper and answered predicate are AST-selected unchanged.
+No full Engine, stores, model or admission gate is launched.
+"""
+import ast
+import importlib.util
+import json
+import os
+from pathlib import Path
+import sys
+import threading
+import types
+import unittest
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[3]
+SOURCE = Path(os.environ.get('RELIABILITY_SOURCE_ROOT', ROOT))
+ADMITTED = SOURCE / 'root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted'
+
+
+def load(path, name):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def consumer(word_path=None, fold_path=None):
+    wp = load(word_path or SOURCE / 'root/wander-train/word_problems_v1.py', 'reliability_word_subject')
+    tree = ast.parse((ADMITTED / 'oracle_release_runtime_w480.py').read_text())
+    selected = [n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == '_run']
+    parent_class = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'OracleReleaseRuntimeW480')
+    selected += [n for n in parent_class.body if isinstance(n, ast.FunctionDef) and n.name == '_c480_answered']
+    ns = {'threading': threading, 'BUDGET_S': 4.0}
+    exec(compile(ast.Module(body=selected, type_ignores=[]), '<actual-w480-helpers>', 'exec'), ns)
+
+    class Parent:
+        _c480_answered = ns['_c480_answered']
+
+        def _c480_dispatch(self, text, session_id, res):
+            return res
+
+    base = types.ModuleType('oracle_release_runtime_w486')
+    base.OracleReleaseRuntimeW486 = Parent
+    timed = types.ModuleType('oracle_release_runtime_w480')
+    timed._run = ns['_run']
+    with patch.dict(sys.modules, {'word_problems_v1': wp, 'oracle_release_runtime_w486': base,
+                                  'oracle_release_runtime_w480': timed}):
+        fold = load(fold_path or ADMITTED / 'oracle_release_runtime_w488.py', 'reliability_fold_subject')
+    return wp, fold.OracleReleaseRuntimeW488()
+
+
+class GeometryConsumerTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.wp, cls.runtime = consumer()
+        cls.original = json.loads((ROOT / 'tests/usage/fixtures/reliability/cases.json').read_text())
+        cls.cases = {c['id']: c['text'] for c in cls.original}
+
+    def dispatch(self, text, parent=None):
+        if parent is None:
+            parent = {'status': 'clarification', 'path': 'act:clarify_specific',
+                      'response': 'What does "its" refer to?', 'latency_ms': 1}
+        return self.runtime._c480_dispatch(text, 'isolated', parent)
+
+    def test_original_room_words_and_requested_quantity(self):
+        # Independent equations: area = 3 * 4; perimeter = 2 * (3 + 4).
+        for key, value in [('area_base', 12), ('area_incidental', 12), ('area_paraphrase', 12), ('perimeter_requested', 14)]:
+            with self.subTest(key=key):
+                result = self.dispatch(self.cases[key])
+                self.assertEqual(result['status'], 'answered')
+                self.assertEqual(result['provenance']['value'], value)
+
+    def test_changed_dimension_changes_area(self):
+        self.assertEqual(self.dispatch('A rectangular room is 5 meters long and 4 meters wide. What is its area?')['provenance']['value'], 20)
+
+    def test_real_conflict_has_useful_explanation(self):
+        result = self.dispatch(self.cases['area_contradiction'])
+        self.assertEqual(result['status'], 'clarification')
+        self.assertEqual(result['path'], 'organ:math>word:conflicting_dimension')
+        self.assertEqual(result['response'], 'The supplied length values disagree (3 meters and 5 meters). Which length should I use?')
+        self.assertEqual(result['provenance']['parent_path'], 'act:clarify_specific')
+        self.assertNotIn('value', result['provenance'])
+
+    def test_postfix_conflict_also_explained(self):
+        result = self.dispatch('A rectangular room is 3 meters long and 5 meters long and 4 meters wide. What is its area?')
+        self.assertEqual(result['provenance']['reason'], 'conflicting_dimension')
+
+    def test_equal_prefix_postfix_mentions_count_once(self):
+        for text in ['A rectangle has length 3 meters long and width 4 meters wide. What is its area?',
+                     'A rectangle is 3 meters long and 3 meters long and 4 meters wide. What is its area?']:
+            self.assertEqual(self.dispatch(text)['provenance']['value'], 12)
+
+    def test_malformed_negative_or_unbound_dimensions_decline(self):
+        for text in ['A rectangle is -3 meters long and 4 meters wide. What is its area?',
+                     'A rectangle is −3 meters long and 4 meters wide. What is its area?',
+                     'A rectangle is 3 bananas long and 4 meters wide. What is its area?',
+                     'A rectangle is 3 meters long and 4 meters wide and another side 5 meters. What is its area?',
+                     'A rectangle is 3 meters long and 4 centimeters wide. What is its area?']:
+            with self.subTest(text=text):
+                result = self.dispatch(text)
+                self.assertEqual(result['path'], 'act:clarify_specific')
+                self.assertIsNone(self.wp.explain_refusal(text))
+
+    def test_equivalent_unit_duplicates_not_called_contradictory(self):
+        text = 'A rectangle has length 3 meters and length 300 centimeters and width 4 meters. What is its area?'
+        self.assertIsNone(self.wp.explain_refusal(text))
+        self.assertEqual(self.dispatch(text)['status'], 'clarification')
+
+    def test_different_shapes_not_conflated(self):
+        text = 'A rectangle has length 3 meters and width 4 meters. Another rectangle has length 5 meters and width 4 meters. What is the area?'
+        self.assertEqual(self.wp.explain_refusal(text)['reason'], 'unsupported_geometry_request')
+
+    def test_conflict_malformed_remainder_not_claimed_complete(self):
+        text = 'A rectangle has length 3 meters and length 5 meters and width 4 bananas. What is its area?'
+        self.assertIsNone(self.wp.explain_refusal(text))
+
+    def test_radius_diameter_diagnosis(self):
+        result = self.dispatch('A circle has radius 3 meters and diameter 8 meters. What is its area?')
+        self.assertEqual(result['status'], 'clarification')
+        self.assertIn('diameter must be twice the radius', result['response'])
+
+    def test_parent_answers_remain_unchanged(self):
+        # Replay retained successful outputs as parent responses; these are not
+        # fresh Engine output and the harness does not claim to recompute them.
+        answered = json.loads((ROOT / 'tests/usage/fixtures/reliability/preserved_answers.json').read_text())['cases']
+        self.assertEqual(len(answered), 6)
+        for row in answered:
+            reply = row['reply']
+            self.assertIs(self.dispatch(row['text'], reply), reply)
+
+    def test_multiple_rooms_not_silently_one_room(self):
+        # Two disjoint 3*4 rooms have total area 2*12=24; a scalar 12 is false.
+        for text in ['Two rectangular rooms are each 3 meters long and 4 meters wide. What is their total area?',
+                     '2 rooms are rectangular and each is 3 meters long and 4 meters wide. What is their total area?']:
+            result = self.dispatch(text)
+            self.assertEqual(result['status'], 'clarification')
+            self.assertIn('multiple shapes', result['response'])
+            self.assertNotIn('value', result['provenance'])
+
+    def test_multiple_requested_measures_not_partial_answer(self):
+        # Required pair is area12, perimeter14, not an unqualified scalar12.
+        text = 'A rectangle is 3 meters long and 4 meters wide. What are its area and perimeter?'
+        result = self.dispatch(text)
+        self.assertEqual(result['status'], 'clarification')
+        self.assertIn('each requested measure', result['response'])
+
+    def test_requested_area_unit_not_ignored(self):
+        # 12m^2 = 12*(100cm)^2 =120000cm^2; bare12 does not answer this.
+        text = 'A rectangle is 3 meters long and 4 meters wide. What is its area in square centimeters?'
+        result = self.dispatch(text)
+        self.assertEqual(result['status'], 'clarification')
+        self.assertIn('requested output unit', result['response'])
+
+    def test_apartment_identifier_is_not_shape_count(self):
+        text = 'Apartment 16 has a rectangular room 3 meters long and 4 meters wide. What is the room area?'
+        self.assertEqual(self.dispatch(text)['provenance']['value'], 12)
+
+    def test_rounding_and_location_are_not_output_units(self):
+        for question in ['What is its area rounded to the nearest tenth?', 'What is its area in this diagram?']:
+            text = 'A rectangle is 3 meters long and 4 meters wide. ' + question
+            result = self.dispatch(text)
+            self.assertEqual(result['status'], 'answered')
+            self.assertEqual(result['provenance']['value'], 12)
+        rounded = self.dispatch('A rectangle is 3.12 meters long and 4 meters wide. What is its area rounded to the nearest tenth?')
+        self.assertEqual(rounded['provenance']['value'], 12.5)
+
+    def test_explicit_unknown_units_still_decline(self):
+        for suffix in ['in square glorks', 'in units of glorks', 'in cm2']:
+            result = self.dispatch('A rectangle is 3 meters long and 4 meters wide. What is its area ' + suffix + '?')
+            self.assertEqual(result['path'], 'organ:math>word:unsupported_geometry_request')
+            self.assertIn('requested output unit', result['response'])
+
+    def test_non_measure_shape_questions_not_intercepted(self):
+        for text in ['Two rectangles are blue. What color are they?',
+                     'A rectangle is 3 meters long and 4 meters wide. What is its name?']:
+            parent = {'status': 'withheld', 'path': 'other:reader', 'response': 'Unanswered by parent.'}
+            self.assertIs(self.dispatch(text, parent), parent)
+
+    def test_non_geometry_refusals_preserved(self):
+        for text in ['What does its name mean?', 'A car travels 150 kilometers in 0 hours. What is its average speed?',
+                     'What is five degrees below zero Celsius in Fahrenheit?']:
+            original = {'status': 'withheld', 'path': 'existing:guard', 'response': 'No verified answer.'}
+            self.assertIs(self.dispatch(text, original), original)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/usage/reliability/test_geometry_units.py

@@ -0,0 +1,113 @@
+"""Independent geometry-unit checks through the actual untrusted w488 consumer.
+
+Uses the existing focused parent substitute; no full Engine or panel is run.
+"""
+import math
+import unittest
+
+from test_geometry_consumer import consumer
+
+
+class GeometryUnitTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.wp, cls.runtime = consumer()
+
+    def dispatch(self, text):
+        return self.runtime._c480_dispatch(text, 'units',
+            {'status': 'clarification', 'path': 'controlled:parent', 'response': 'Parent clarification.'})
+
+    def check(self, text, value, unit):
+        module = self.wp.answer(text)
+        self.assertIsNotNone(module)
+        self.assertAlmostEqual(module['value'], value, places=10)
+        self.assertEqual(module['unit'], unit)
+        reply = self.dispatch(text)
+        self.assertEqual(reply['status'], 'answered')
+        self.assertAlmostEqual(reply['provenance']['value'], value, places=10)
+        self.assertEqual(reply['provenance']['unit'], unit)
+        first_sentence = reply['response'].split('. Read as ', 1)[0]
+        self.assertTrue(first_sentence.endswith(' ' + unit.replace('^2', '²').replace('^3', '³')), first_sentence)
+        self.assertNotIn('square units', reply['response'])
+        self.assertNotIn('cubic units', reply['response'])
+        return reply
+
+    def test_original_room_area_and_perimeter(self):
+        # L=3m,W=4m: A=12m²; P=14m. These are the actual U4 question strings.
+        self.check('A rectangular room is 3 meters long and 4 meters wide. What is its area?', 12, 'm^2')
+        self.check('A rectangular room is 3 meters long and 4 meters wide. What is its perimeter?', 14, 'm')
+
+    def test_paraphrase_identifiers_and_location(self):
+        for text in [
+            'What is the area of a rectangle with width 4 meters and length 3 meters?',
+            'Apartment 12 has a rectangular room 3 meters long and 4 meters wide. What is the room area?',
+            'Apartment 16 has a rectangular room 3 meters long and 4 meters wide. What is the room area?',
+            'A rectangle is 3 meters long and 4 meters wide. What is its area in this diagram?']:
+            with self.subTest(text=text):
+                self.check(text, 12, 'm^2')
+
+    def test_supported_same_unit_scales_not_relabelled(self):
+        for spelling, canonical in [('millimeters', 'mm'), ('centimeters', 'cm'), ('meters', 'm'),
+                                    ('kilometers', 'km'), ('inches', 'in'), ('feet', 'ft'),
+                                    ('yards', 'yd'), ('miles', 'mi')]:
+            with self.subTest(unit=spelling):
+                self.check(f'A rectangle has length 3 {spelling} and width 4 {spelling}. What is its area?', 12, canonical+'^2')
+                self.check(f'A rectangle has length 3 {spelling} and width 4 {spelling}. What is its perimeter?', 14, canonical)
+
+    def test_equal_scale_aliases(self):
+        self.check('A rectangle has length 3 feet and width 4 ft. What is its area?', 12, 'ft^2')
+        self.check('A rectangle has length 3 m and width 4 meters. What is its perimeter?', 14, 'm')
+
+    def test_in_is_inches_only_in_bound_dimension_position(self):
+        self.check('A rectangle has length 3 in and width 4 inches. What is its area?', 12, 'in^2')
+        # A preposition without a measurement unit must not acquire inches.
+        text = 'A rectangle has length 3 in the diagram and width 4 in the diagram. What is its area?'
+        self.assertIsNone(self.wp.answer(text))
+
+    def test_area_rounding_retains_squared_unit(self):
+        self.check('A rectangle is 3.12 meters long and 4 meters wide. What is its area rounded to the nearest tenth?', 12.5, 'm^2')
+
+    def test_circle_radius_diameter_and_circumference(self):
+        self.check('A circle has radius 3 centimeters. What is its area?', 9*math.pi, 'cm^2')
+        self.check('A circle has diameter 6 centimeters. What is its area?', 9*math.pi, 'cm^2')
+        self.check('A circle has radius 3 centimeters and diameter 6 cm. What is its circumference?', 6*math.pi, 'cm')
+
+    def test_circumference_rounding_retains_linear_unit(self):
+        self.check('A circle has radius 1 meters. What is its circumference rounded to the nearest tenth?', 6.3, 'm')
+
+    def test_supported_volumes_retain_cubed_unit(self):
+        # Vcone=πr²h/3; Vcylinder=πr²h; Vsphere=4πr³/3.
+        self.check('A cone has radius 2 centimeters and height 3 centimeters. What is its volume?', 4*math.pi, 'cm^3')
+        self.check('A cylinder has radius 2 inches and height 3 in. What is its volume?', 12*math.pi, 'in^3')
+        self.check('A sphere has radius 2 feet. What is its volume?', 32*math.pi/3, 'ft^3')
+
+    def test_volume_rounding_retains_cubed_unit(self):
+        self.check('A cylinder has radius 1.2 centimeters and height 3.4 centimeters. What is its volume rounded to the nearest tenth?', 15.4, 'cm^3')
+
+    def test_mixed_units_and_malformed_units_not_silently_relabelled(self):
+        for text in [
+            'A rectangle has length 3 meters and width 4 centimeters. What is its area?',
+            'A cylinder has radius 2 inches and height 3 feet. What is its volume?',
+            'A rectangle has length 3 minutes and width 4 meters. What is its area?',
+            'A rectangle has length 3 smoots and width 4 smoots. What is its area?']:
+            with self.subTest(text=text):
+                self.assertIsNone(self.wp.answer(text))
+                self.assertNotEqual(self.dispatch(text)['status'], 'answered')
+
+    def test_conflict_and_scope_stay_bounded(self):
+        for text in [
+            'A circle has radius 3 meters and diameter 8 meters. What is its area?',
+            'A rectangle has length 3 meters and length 5 meters and width 4 meters. What is its area?',
+            'Two rectangular rooms are each 3 meters long and 4 meters wide. What is their total area?',
+            'A rectangle is 3 meters long and 4 meters wide. What are its area and perimeter?',
+            'A rectangle is 3 meters long and 4 meters wide. What is its area in square centimeters?']:
+            with self.subTest(text=text):
+                self.assertEqual(self.dispatch(text)['status'], 'clarification')
+                self.assertIsNone(self.wp.answer(text))
+
+    def test_zero_area_keeps_unit(self):
+        self.check('A rectangle has length 0 centimeters and width 4 centimeters. What is its area?', 0, 'cm^2')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/usage/reliability_route/test_geometry_route.py

@@ -0,0 +1,188 @@
+"""Actual geometry-v4 -> Family -> w504 checks with only the expensive parent substituted.
+
+Untrusted test harness; no full Engine, native build or admission authority.
+"""
+import importlib.util
+import json
+import math
+import os
+from pathlib import Path
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[3]
+SOURCE = Path(os.environ.get('RELIABILITY_SOURCE_ROOT', ROOT))
+SPECIALIST = SOURCE / 'root/specialists/geometry-v4'
+ADMITTED = SOURCE / 'root/fable-content/oracle-m-series-2026-08-15/self_loop/admitted'
+
+
+def load(path, name):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def actual_consumer():
+    combo = load(SOURCE / 'root/specialists/_gate/combo_runtime_v1.py', 'geometry_route_combo')
+    family = combo.Family([str(SPECIALIST / 'manifest.json')], [str(SPECIALIST)])
+    class Parent:
+        def chat(self, text, session_id='default'):
+            return self.parent_reply
+    parent_module = types.ModuleType('oracle_release_runtime_w366')
+    parent_module.OracleReleaseRuntimeW366 = Parent
+    with patch.dict(sys.modules, {'oracle_release_runtime_w366': parent_module}):
+        fold = load(ADMITTED / 'oracle_release_runtime_w504.py', 'geometry_route_fold')
+    fold._FAM['f'] = family
+    runtime = fold.OracleReleaseRuntimeW504()
+    runtime.parent_reply = {'status': 'clarification', 'path': 'act:clarify_specific', 'response': 'Unresolved parent reading.'}
+    return family, runtime
+
+
+class GeometryRouteTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.family, cls.runtime = actual_consumer()
+
+    def answer(self, text):
+        self.runtime.parent_reply = {'status': 'clarification', 'path': 'act:clarify_specific', 'response': 'Unresolved parent reading.'}
+        return self.runtime.chat(text)
+
+    def test_actual_recorded_mixed_units(self):
+        reply = self.answer('A rectangle has length 3 meters and width 4 centimeters. What is its area?')
+        self.assertEqual(reply['status'], 'answered')
+        self.assertEqual(reply['path'], 'specialist_call>specialist:geometry-v4>rect_area')
+        # 3m * .04m = .12m², not raw 3*4=12.
+        self.assertIn('area is 0.12 m²', reply['response'])
+
+    def test_actual_recorded_diagram_units(self):
+        reply = self.answer('A rectangle has length 3 in the diagram and width 4 in the diagram. What is its area?')
+        self.assertEqual(reply['status'], 'answered')
+        self.assertIn('area is 12 square units', reply['response'])
+        self.assertNotIn('in²', reply['response'])
+
+    def test_mixed_rectangle_perimeter(self):
+        # 2*(3+.04)m=6.08m.
+        self.assertIn('perimeter is 6.08 m', self.answer('A rectangle has length 3 meters and width 4 centimeters. What is its perimeter?')['response'])
+
+    def test_same_units_and_aliases(self):
+        for length, width, unit in [('centimeters', 'cm', 'cm²'), ('feet', 'ft', 'ft²'), ('meters', 'm', 'm²')]:
+            result = self.answer(f'A rectangle has length 3 {length} and width 4 {width}. What is its area?')
+            self.assertEqual(result['status'], 'answered')
+            self.assertIn('area is 12 '+unit, result['response'])
+
+    def test_explicit_inches_do_not_become_diagram_units(self):
+        self.assertIn('area is 12 in²', self.answer('A rectangle has length 3 in and width 4 inches. What is its area?')['response'])
+
+    def test_diagram_and_physical_dimensions_not_combined(self):
+        result = self.answer('A rectangle has length 3 meters and width 4 in the diagram. What is its area?')
+        self.assertEqual(result['status'], 'withheld')
+        self.assertIn('missing units', result['response'])
+
+    def test_unknown_and_ambiguous_units(self):
+        for text in ['A rectangle has length 3 smoots and width 4 meters. What is its area?',
+                     'A circle has radius 3 bananas. What is its area?',
+                     'A rectangle has length 3 in another place and width 4 inches. What is its area?']:
+            result = self.answer(text)
+            self.assertEqual(result['status'], 'withheld')
+            self.assertTrue(result['path'].endswith('geometry-v4>underspecified'))
+
+    def test_missing_unit_must_not_inherit_silently(self):
+        self.assertEqual(self.answer('A cylinder has radius 3 meters and height 4. What is its volume?')['status'], 'withheld')
+
+    def test_mixed_units_do_not_escape_through_parent_formulas(self):
+        for text in ['A cylinder has radius 3 meters and height 4 centimeters. What is its volume?',
+                     'A cone has radius 3 meters and height 4 centimeters. What is its volume?',
+                     'A triangle has base 3 meters and height 4 centimeters. What is its area?',
+                     'A box has length 3 meters and width 4 centimeters and height 5 meters. What is its volume?']:
+            with self.subTest(text=text):
+                result = self.answer(text)
+                self.assertEqual(result['status'], 'withheld')
+                self.assertIn('mixed length units', result['response'])
+
+    def test_inconsistent_radius_diameter_and_duplicates(self):
+        for text in ['A circle has radius 3 meters and diameter 8 centimeters. What is its area?',
+                     'A rectangle has length 3 meters and length 5 meters and width 4 meters. What is its area?',
+                     'A square has side 3 meters and side 5 meters. What is its area?']:
+            result = self.answer(text)
+            self.assertEqual(result['status'], 'withheld')
+            self.assertIn('contradict', result['response'])
+
+    def test_equal_dimension_repeats_and_aliases(self):
+        self.assertIn('area is 12 m²', self.answer('A rectangle has length 3 meters and length 300 centimeters and width 4 meters. What is its area?')['response'])
+
+    def test_other_same_unit_formulas_remain_useful(self):
+        for text, fragment in [
+            ('A cylinder has radius 2 centimeters and height 3 cm. What is its volume?', '37.6991 cm³'),
+            ('A circle has radius 3 centimeters and diameter 6 cm. What is its area?', '28.2743 cm²'),
+            ('A cube has side 2 feet. What is its volume?', '8 ft³')]:
+            reply = self.answer(text)
+            self.assertEqual(reply['status'], 'answered')
+            self.assertIn(fragment, reply['response'])
+
+    def test_powered_or_compound_units_not_read_as_lengths(self):
+        for unit in ['m^2', 'm2', 'm²', 'meters per second', 'm/s', 'µm']:
+            result = self.answer(f'A triangle has base 3 {unit} and height 4 meters. What is its area?')
+            self.assertEqual(result['status'], 'withheld', (unit, result))
+
+    def test_cube_side_and_edge_consistency(self):
+        self.assertEqual(self.answer('A cube has side 2 meters and edge 3 meters. What is its volume?')['status'], 'withheld')
+        self.assertIn('8 m³', self.answer('A cube has side 2 meters and edge 2 meters. What is its volume?')['response'])
+
+    def test_requests_respect_scope(self):
+        for text in ['Two rectangles have length 3 meters and width 4 meters. What is their total area?',
+                     'A rectangle has length 3 meters and width 4 meters. What are its area and perimeter?',
+                     'A rectangle has length 3 meters and width 4 meters. What is its area in square centimeters?']:
+            self.assertEqual(self.answer(text)['status'], 'withheld')
+
+    def test_rounding_and_location(self):
+        self.assertIn('area is 12.5 m²', self.answer('A rectangle has length 3.12 meters and width 4 meters. What is its area rounded to the nearest tenth?')['response'])
+        self.assertIn('area is 12 m²', self.answer('A rectangle has length 3 meters and width 4 meters. What is its area in this diagram?')['response'])
+
+    def test_parent_success_and_deliberate_refusal_preserved(self):
+        for original in [{'status': 'answered', 'path': 'existing:answer', 'response': 'Existing useful answer.'},
+                         {'status': 'withheld', 'path': 'guard:out_of_fragment', 'response': 'Deliberate refusal.'}]:
+            self.runtime.parent_reply = original
+            self.assertIs(self.runtime.chat('A rectangle has length 3 meters and width 4 centimeters. What is its area?'), original)
+
+    def test_shape_mentions_without_measure_request_stay_with_parent(self):
+        for text in ['A rectangle has length 3 meters and width 4 centimeters. Who invented rectangles?',
+                     'A rectangle has area 12 and length 3 meters and width 4 meters. What color is it?',
+                     'Two squares are drawn in blue. Who drew them?']:
+            self.runtime.parent_reply = {'status': 'clarification', 'path': 'act:clarify_specific', 'response': 'Original non-measure response.'}
+            self.assertIs(self.runtime.chat(text), self.runtime.parent_reply)
+
+    def test_non_calculation_question_with_measure_word_stays_with_parent(self):
+        for text in ['Who discovered the area formula of a circle?',
+                     'A square has side 3 meters. What is the history of its area formula?',
+                     'A rectangle has length 3 meters and width 4 meters. What is the name of its area formula?']:
+            self.runtime.parent_reply = {'status':'clarification','path':'act:clarify_specific','response':'Existing non-calculation answer.'}
+            self.assertIs(self.runtime.chat(text), self.runtime.parent_reply)
+
+    def test_extra_numeric_tuple_is_not_ignored(self):
+        for text in ['A rectangle has length 3 meters and width 4 meters, also 5 by 6. What is its area?',
+                     'A rectangle has length 3 meters and width 4 meters, also 5 by 6. What is its perimeter?']:
+            reply = self.answer(text)
+            self.assertEqual(reply['status'], 'withheld')
+            self.assertIn('every number', reply['response'])
+
+    def test_unused_physical_roles_are_not_ignored(self):
+        for text in ['A sphere has radius 2 centimeters and height 3 centimeters. What is its volume?',
+                     'A circle has radius 3 meters and height 4 meters. What is its area?',
+                     'A rectangle has length 3 meters and width 4 meters and radius 2 meters. What is its area?']:
+            reply = self.answer(text)
+            self.assertEqual(reply['status'], 'withheld')
+            self.assertIn('all supplied geometry roles', reply['response'])
+
+    def test_apartment_identifier_is_not_a_length(self):
+        self.assertIn('area is 0.12 m²', self.answer('Apartment 16 contains a rectangle with length 3 meters and width 4 centimeters. What is its area?')['response'])
+
+    def test_unrelated_question_does_not_cost_parent(self):
+        self.runtime.parent_reply = {'status':'clarification','path':'act:clarify_specific','response':'Original unrelated answer.'}
+        self.assertIs(self.runtime.chat('What music do you enjoy?'), self.runtime.parent_reply)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/usage/research/test_relation_semantics.py

@@ -0,0 +1,83 @@
+"""Regression tests for the granted Oracle relation_spec_v1 source repair.
+
+Set RESEARCH_RELATION_SOURCE to test the same module in another package. The
+default is the root-approved build source, never the immutable passing candidate.
+"""
+import importlib.util
+import os
+import re
+import sys
+import types
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[3]
+SOURCE = Path(os.environ.get("RESEARCH_RELATION_SOURCE", ROOT / "root/wander-train/relation_spec_v1.py"))
+
+
+@unittest.skipUnless(SOURCE.exists(), "Set RESEARCH_RELATION_SOURCE to the patched relation_spec_v1.py")
+class RelationSemanticsTests(unittest.TestCase):
+    def setUp(self):
+        self.names = {"star wars": [(462, 184, 0), (17738, 96, 1)]}
+        self.props = {(17738, 86): frozenset({"John Williams"}),
+                      (17738, 577): frozenset({"1977-05-25T00:00:00Z"})}
+        linker = types.SimpleNamespace(candidates=lambda name, limit: self.names.get(name, [])[:limit], STOP=set())
+        x = types.SimpleNamespace(L=linker, norm=lambda s: re.sub(r"[^a-z0-9]+", " ", s.lower()).strip(),
+                                  _show=lambda value, q: value, TIME_VARIANT=set())
+        spec = importlib.util.spec_from_file_location("test_relation_spec", SOURCE)
+        self.module = importlib.util.module_from_spec(spec)
+        with patch.dict(sys.modules, {"exact_router_v1": x}):
+            spec.loader.exec_module(self.module)
+        self.module.in_domain = lambda qid, domain: (qid == 17738 and domain == "films") or (qid == 2536187 and domain == "singers")
+        self.module.values = lambda qid, prop: self.props.get((qid, prop), frozenset())
+        self.module.analyse = lambda q: {"cands": [17738], "feats": {("where", "born")}}
+        self.patterns = {"inv|who|composed": [800], "fwd|where|born": [19]}
+
+    def test_observed_failure_now_reads_composer_of_dated_film(self):
+        answer = self.module.answer("Who composed the music for Star Wars (1977)?", "films", self.patterns)
+        self.assertEqual((answer["answer"], answer["property"], answer["subject_qid"]), ("John Williams", 86, 17738))
+
+    def test_singer_notable_work_never_satisfies_composer(self):
+        self.assertIsNone(self.module.answer("Who composed the music for Star Wars (1977)?", "singers", self.patterns))
+
+    def test_supported_composer_phrasings(self):
+        for question in ["Who composed Star Wars?", "Who wrote the music for Star Wars?",
+                         "Who is the composer of Star Wars?", "Which composer wrote Star Wars?",
+                         "Could you please tell me who composed the music for the film Star Wars (1977)?"]:
+            with self.subTest(question=question):
+                self.assertEqual(self.module.answer(question, "films", self.patterns)["property"], 86)
+
+    def test_missing_composer_does_not_fall_back_to_notable_work(self):
+        self.props.pop((17738, 86))
+        self.assertIsNone(self.module.answer("Who composed Star Wars?", "films", self.patterns))
+
+    def test_unmatched_year_is_not_ignored(self):
+        self.assertIsNone(self.module.answer("Who composed Star Wars (1777)?", "films", self.patterns))
+
+    def test_extra_condition_is_not_ignored(self):
+        self.assertIsNone(self.module.answer("Who composed Star Wars and directed Jaws?", "films", self.patterns))
+
+    def test_capped_candidates_do_not_count_as_complete(self):
+        self.names["star wars"] = [(17738, 96, 1)] * 65
+        self.assertIsNone(self.module.answer("Who composed Star Wars?", "films", self.patterns))
+
+    def test_disagreeing_composers_are_not_selected_by_popularity(self):
+        self.names["star wars"].append((999, 1, 1))
+        self.module.in_domain = lambda qid, domain: qid in {17738, 999}
+        self.props[(999, 86)] = frozenset({"Someone else"})
+        self.assertIsNone(self.module.answer("Who composed Star Wars?", "films", self.patterns))
+
+    def test_other_relations_remain_available(self):
+        self.props[(17738, 19)] = frozenset({"Test City"})
+        answer = self.module.answer("Where was Test Person born?", "films", self.patterns)
+        self.assertEqual((answer["answer"], answer["property"]), ("Test City", 19))
+
+    def test_receipt_labels_preserve_property_meaning(self):
+        self.assertEqual(self.module.prop_label(26), "spouse")
+        self.assertEqual(self.module.prop_label(86), "composer")
+        self.assertEqual(self.module.prop_label(800), "notable work")
+
+
+if __name__ == "__main__":
+    unittest.main()