sourcedrecall 0.6.0__py3-none-any.whl

sourcedrecall/__init__.py

@@ -0,0 +1,11 @@
+"""sourcedrecall: local memory for AI agents. It stores the user's own dated
+messages; a grammar parser (not a language model) decides what is stored,
+whose words they are, and what has gone out of date. MCP server, hooks for
+Claude Code, Codex, Gemini CLI and Cursor, and a command line."""
+
+# 2026-10-12 (review 4.5): was a fixed "0.1.0" while the package said 0.5.2
+try:
+    from importlib.metadata import version as _v
+    __version__ = _v("sourcedrecall")
+except Exception:
+    __version__ = "unknown"

sourcedrecall/_bridge.py

@@ -0,0 +1,17 @@
+"""Where the memory code lives (2026-10-04): the repository checkout when
+there is one (core and rgx/, for development), else the copy a
+wheel carries in sourcedrecall/_core (tools/build_wheel.py). RG_ROOT
+overrides the checkout location."""
+import os
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+def code_roots():
+    """-> (root holding the rgx package, directory of the flat p2 modules)."""
+    repo = os.environ.get("RG_ROOT", os.path.dirname(os.path.dirname(_HERE)))
+    p2 = os.path.join(repo, "core")
+    if os.path.isdir(p2) and os.path.isdir(os.path.join(repo, "rgx")):
+        return repo, p2
+    core = os.path.join(_HERE, "_core")
+    return core, core

sourcedrecall/_core/answer_type.py

@@ -0,0 +1,314 @@
+"""What TYPE of thing a question asks for, and whether a sentence has one.
+
+2026-10-02. Recall was the gap on the blind bench: the answer was often in a
+sentence that shares no word with the question ("Which food do I dislike?"
+-- "I can't stand cilantro"; "What is my beverage of choice?" -- "I
+switched to tea"). Similarity could not separate those from leaks (word
+pairs: true 0.57-0.96, false 0.55-0.71; "children" ~ "dog" 0.58). An is-a
+relation can: WordNet says cilantro is a food, tea a beverage, Leeds a city,
+a daughter a child -- and a dog is not a child.
+
+  question_type("Which food do I dislike?") -> ("food", "neg")
+  has_type("I can't stand cilantro.", "food") -> True
+
+Brands and titles are mostly not in WordNet; cars and programming languages
+use the closed lists the rest of p2 already keeps. When WordNet is not
+installed every check returns False, so nothing is grounded by it.
+"""
+import re
+
+_WN = None
+
+
+def _wn():
+    global _WN
+    if _WN is None:
+        try:
+            from nltk.corpus import wordnet as wn
+            wn.synsets("food")
+            _WN = wn
+        except Exception:
+            _WN = False
+    return _WN or None
+
+
+_Q_TYPE = [
+    re.compile(r"^(?:which|what)\s+(?:kind of\s+|type of\s+|sort of\s+)?"
+               r"(?P<t>[a-z]+)\s+(?:do|did|does|is|are|was|were|have|has|had|"
+               r"can|would|should|will)\b"),
+    re.compile(r"^what(?:'s| is| are| was)\s+my\s+(?:favou?rite\s+)(?P<t>[a-z]+)"),
+    re.compile(r"^what(?:'s| is| are| was)\s+my\s+(?P<t>[a-z]+)\s+of\s+choice"),
+    re.compile(r"^(?:do|did|have)\s+i\s+(?:have|own|keep|got)\s+(?:any\s+|a\s+|an\s+)?"
+               r"(?P<t>[a-z]+)"),
+]
+# question nouns that are not types of THING (handled elsewhere or too vague)
+_NOT_TYPES = frozenset("""time year day date month week thing things way kind
+sort type name one ones much many reason job work""".split())
+_NEG_Q = re.compile(r"\b(dislike|hate|can't stand|cannot stand|avoid|"
+                    r"don't like|do not like|detest|loathe|allergic)\b")
+_POS_Q = re.compile(r"\b(like|love|enjoy|prefer|favou?rite|adore|of choice)\b")
+_NEG_S = re.compile(r"\b(hate|dislike|can't stand|cannot stand|can not stand|"
+                    r"don't like|do not like|not a fan|avoid|detest|loathe|"
+                    r"allergic|can't eat|cannot eat|gross|disgusting)\b", re.I)
+_POS_S = re.compile(r"\b(love|like|enjoy|adore|prefer|favou?rite|fan of|"
+                    r"switched to|into)\b", re.I)
+
+_EXTRA = {}          # type -> closed list, filled lazily
+
+
+def _closed(typ):
+    if not _EXTRA:
+        try:
+            from currency import _CAR_BRANDS
+            _EXTRA["car"] = set(_CAR_BRANDS)
+        except Exception:
+            pass
+        try:
+            from answerability import _LANGUAGES
+            _EXTRA["language"] = set(_LANGUAGES)
+        except Exception:
+            pass
+    return _EXTRA.get(typ, set())
+
+
+def _singular(w):
+    if w.endswith("ies") and len(w) > 4:
+        return w[:-3] + "y"
+    if w.endswith("ren"):            # children
+        return w[:-3]
+    if w.endswith("s") and not w.endswith("ss") and len(w) > 3:
+        return w[:-1]
+    return w
+
+
+_GENERIC_V = frozenset("""do does did is are was were be been have has had
+get got own keep i me my myself the a an any some in on at to of for with from about like
+love enjoy prefer dislike hate stand avoid choice favourite favorite usually
+often ever currently now still really""".split())
+
+
+def _verb_lemma(w):
+    wn = _wn()
+    if wn is None:
+        return w
+    return wn.morphy(w, wn.VERB) or wn.morphy(w) or w
+
+
+def question_verbs(q, typ):
+    """The question's own content words after the type noun ("born",
+    "play", "drive"), lemmatised; empty for generic questions."""
+    # only the USER's own action: "What city was I BORN in?", "What car do
+    # I DRIVE?" -- not the entity in "What language is the billing service
+    # in?"
+    s = re.sub(r"\s+", " ", (q or "").lower())
+    m = re.search(r"\b(?:do|did|does|was|were|am|have|had|can|would|will)\s+i\s+"
+                  r"((?:[a-z]+\s*){1,3})", s)
+    if not m:
+        return set()
+    t = {typ, typ + "s", typ + "es", typ + "ren"}
+    return {_verb_lemma(w) for w in re.findall(r"[a-z]+", m.group(1))
+            if w not in _GENERIC_V and len(w) > 1 and w not in t
+            and _singular(w) != typ}
+
+
+def question_type(q):
+    """-> (type noun, polarity "pos"/"neg"/None) or None."""
+    s = re.sub(r"\s+", " ", (q or "").strip().lower()).replace("’", "'")
+    for rx in _Q_TYPE:
+        m = rx.match(s)
+        if m:
+            t = _singular(m.group("t"))
+            if t in _NOT_TYPES or len(t) < 3:
+                return None
+            pol = "neg" if _NEG_Q.search(s) else "pos" if _POS_Q.search(s) else None
+            return t, pol
+    return None
+
+
+def _is_a(word, typ):
+    wn = _wn()
+    if wn is None:
+        return False
+    tsyn = set(wn.synsets(typ, pos=wn.NOUN))
+    if not tsyn:
+        return False
+    for syn in wn.synsets(word, pos=wn.NOUN)[:8]:
+        if syn in tsyn:
+            return True
+        for path in syn.hypernym_paths():
+            if tsyn & set(path):
+                return True
+    return False
+
+
+_STOP = frozenset("""the and for are was were been have has had this that with
+from they them their there what when where which while about into over just
+really very much more most some any every lot lots also still now then than
+because since after before during my your our his her its""".split())
+
+
+# WordNet files dogs under "domestic animal", not "pet"
+_ALIAS = {"pet": "animal", "drink": "beverage", "color": "colour"}
+
+
+# 2026-10-03 (stale dev set): getting a thing makes it the user's -- "We
+# adopted a kitten", "bought a used Corolla", "Picked up a rescue greyhound"
+_POSSESS = re.compile(r"\b(my|our|i have|i've|i've got|i own|we have|we've|"
+                      r"i got|we got)\b|(?:\b(?:i|we)\s+(?:just\s+|finally\s+)?|^\W*)"
+                      r"(?:adopted|bought|picked up|rescued|purchased|leased|"
+                      r"inherited|took in)\b", re.I)
+
+
+def has_type(sentence, typ, pol=None, verbs=(), possess=False):
+    """Does the sentence contain a thing of this type (and, for like/dislike
+    questions, the matching polarity, and the question's own verbs)?
+    "What city was I born in?" is not answered by "I went to Lyon"."""
+    if not sentence or not typ:
+        return False
+    typ = _ALIAS.get(typ, typ)
+    if verbs:
+        sv = {_verb_lemma(w.lower()) for w in re.findall(r"[A-Za-z]+", sentence)}
+        if not set(verbs) & sv:
+            return False
+    if pol == "neg" and not _NEG_S.search(sentence):
+        return False
+    if pol == "pos" and _NEG_S.search(sentence):
+        return False
+    closed = _closed(typ)
+    for m in re.finditer(r"[A-Za-z][A-Za-z'-]+", sentence):
+        w = m.group(0).lower().strip("'")
+        hit = w in closed            # closed lists may hold short words ("Go")
+        if not hit and (len(w) < 3 or w in _STOP):
+            continue
+        hit = hit or w == typ or _singular(w) == typ or (
+            _is_a(w, typ) or _is_a(_singular(w), typ))
+        if not hit:
+            continue
+        # "Do I have any children?" is not answered by "...recipes for the
+        # kids": the thing must be the user's
+        if possess and not _POSSESS.search(sentence[max(0, m.start() - 40):m.start()]):
+            continue
+        return True
+    return False
+
+
+def is_presence(q):
+    return bool(re.match(r"^\s*(?:do|did|have)\s+i\s+(?:have|own|keep|got)\b",
+                         (q or "").lower()))
+
+
+# types WordNet (or a closed list) covers well enough that a record NOT of
+# the type can be said not to answer: "What sport do I play?" is not
+# answered by "plays the cello"
+CHECKABLE = frozenset("""food beverage drink sport instrument animal pet city
+country language car fruit vegetable dish meal herb spice flower tree bird
+fish child colour color music genre""".split())
+
+
+# ---- semantic grounding (2026-10-03) ---------------------------------------
+# The dev paraphrase set (bench/false_memory/cases_dev_paraphrase.jsonl) found
+# 30 of 64 questions refused while the answering fact WAS stored: "Do I have
+# any siblings?" / "my sister Priya", "What health conditions do I have?" /
+# "type 2 diabetes", "Which country did I visit?" / "Peru". A WordNet
+# relation between a question word and a fact word -- same meaning, or the
+# fact's word is a kind (or an instance) of the question's -- grounds the
+# question, with the same guard as answer types: the user's own action verb
+# in the question ("born", "attend") must be in the fact too.
+_LIGHT = frozenset("""do does did done doing have has had having get got go
+goes went gone going make made take took be is am are was were been being
+thing things stuff kind sort type way time times lot lots one ones bit
+something anything everything nothing what which who whom whose where when
+why how my mine me myself i you your our we us the a an any some much many
+more most less few""".split())
+
+
+def _syn(word, pos=None):
+    wn = _wn()
+    if wn is None:
+        return []
+    try:
+        return wn.synsets(word, pos=pos)[:6]
+    except Exception:
+        return []
+
+
+def related(q, s):
+    """Is fact word s the same as, a kind of, or an instance of question
+    word q (or derivationally the same: study / student)?"""
+    if q == s or _singular(q) == _singular(s):
+        return True
+    q = _ALIAS.get(_singular(q), q)
+    qs = set(_syn(q)) | set(_syn(_singular(q)))
+    if not qs:
+        return False
+    qn = _singular(q)
+    for syn in _syn(s) + _syn(_singular(s)):
+        if syn in qs:
+            return True
+        for path in syn.hypernym_paths():
+            if qs & set(path):
+                return True
+            # WordNet files a sister under "female_sibling", apart from
+            # "sibling": a broader term NAMED with the question word counts
+            if any(qn in l.name().lower().split("_") for x in path[:-1]
+                   for l in x.lemmas()):
+                return True
+        for inst in syn.instance_hypernyms():
+            for path in inst.hypernym_paths():
+                if qs & set(path):
+                    return True
+    # derivation: "studying" / "student", "married" / "marriage"
+    qlem = {l.name().lower() for x in qs for l in x.lemmas()}
+    for syn in _syn(s):
+        for l in syn.lemmas():
+            for d in l.derivationally_related_forms():
+                if d.name().lower() in qlem:
+                    return True
+    return False
+
+
+def _main_verb(query):
+    """The user's own action: the first word after "do/did/was ... I", if it
+    is a verb that is not a light one ("born", "attend", "purchase")."""
+    m = re.search(r"\b(?:do|did|does|was|were|am|have|had|can|would|will)\s+i\s+"
+                  r"([a-z]+)", (query or "").lower())
+    if not m:
+        return None
+    w = m.group(1)
+    if w in _LIGHT or w in _GENERIC_V:
+        return None
+    wn = _wn()
+    if wn is None or not wn.synsets(w, pos=wn.VERB):
+        return None
+    return w
+
+
+def _verb_related(v, w):
+    wn = _wn()
+    if _verb_lemma(v) == _verb_lemma(w):
+        return True
+    a = set(wn.synsets(v, pos=wn.VERB)[:3])
+    b = set(wn.synsets(w, pos=wn.VERB)[:3])
+    return bool(a & b)
+
+
+def semantic_grounded(query, text):
+    if not query or not text or _wn() is None:
+        return False
+    swords = [w for w in re.findall(r"[a-z]+", text.lower())
+              if w not in _LIGHT and w not in _STOP and len(w) > 2]
+    if not swords:
+        return False
+    verb = _main_verb(query)
+    if verb:
+        if not any(_verb_related(verb, w) for w in swords):
+            return False
+    qwords = [w for w in re.findall(r"[a-z]+", query.lower())
+              if w not in _LIGHT and w not in _GENERIC_V and len(w) > 2
+              and w != verb]
+    nouns = [w for w in qwords if _wn().synsets(w, pos=_wn().NOUN)
+             or _wn().synsets(_singular(w), pos=_wn().NOUN)]
+    if not nouns:
+        # "What did I purchase recently?" -- the verb is the whole question
+        return bool(verb)
+    return any(related(q, s) for q in nouns for s in swords)

sourcedrecall/_core/answerability.py

@@ -0,0 +1,290 @@
+"""Does a stored fact ANSWER the question, or only share its topic?
+
+2026-10-02. "What is my partner's job?" retrieved "partner Sam works from
+home" and came back as an answer. Retrieval scores similarity, and a fact
+about the right entity is similar to any question about it, so similarity
+alone cannot tell "Sam's job" from "something about Sam". The same failure
+appears in JP's "Repetition Without Exclusivity" (child-scale LMs show
+repetition priming, never mutual exclusivity): without a mechanism in which
+candidate referents COMPETE, the familiar item wins. RINSE (arXiv
+2609.37469) names the missing signal for retrieval -- coverage of the
+question's components -- and "Two Axes of LLM Abstention" (arXiv 2607.08456)
+shows answerability needs its own decision, separate from relevance.
+
+This module is that decision, deterministic and cheap:
+  * read from the question WHAT is asked (an attribute: job, colour, name, a
+    number, a reason, a place) and ABOUT WHAT (my partner, my dog, Sam);
+  * a fact answers only if it mentions the entity AND supplies that kind of
+    answer.
+When the question has no recognisable asked attribute ("Do I own any
+pets?", "What do I eat?") nothing is decided here and retrieval stands.
+"""
+import re
+
+# --- what kind of answer an attribute needs ---------------------------------
+
+_COLOURS = set("""red orange yellow green blue purple violet pink brown black
+white grey gray silver gold beige navy teal maroon cream""".split())
+_NUMBER_WORDS = set("""zero one two three four five six seven eight nine ten
+eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen
+twenty thirty forty fifty sixty seventy eighty ninety hundred thousand million
+dozen half few several couple""".split())
+_LANGUAGES = set("""go rust python java javascript typescript ruby php kotlin
+swift scala haskell elixir erlang perl lua sql c c++ c# english german french
+spanish italian portuguese mandarin chinese japanese korean arabic hindi dutch
+greek russian""".split())
+_REASON = re.compile(r"\b(because|since|due to|so that|as it|as the|in order to"
+                     r"|thanks to|which is why)\b")
+_PREFERENCE = re.compile(r"\b(favou?rite|prefer\w*|love\w*|like\w*|enjoy\w*|"
+                         r"best)\b")
+_PLACE = re.compile(r"\b(in|at|from|near|based|located|lives?|moved|"
+                    r"headquartered)\b\s+[A-Z]|\b(live|lives|living|based|"
+                    r"located)\b")
+
+# attribute words -> answer kind
+_KIND = {}
+for k, words in {
+    "role": "job occupation profession role title work career position",
+    "employer": "employer company workplace firm",
+    "place": "address city town suburb country location home live based "
+             "located",
+    "colour": "colour color",
+    "name": "name called",
+    "number": "salary earn earns income cost price age old long often fast "
+              "tall big many much years year",
+    "time": "year when date birthday",
+    "reason": "why reason",
+    "language": "language languages",
+    "preference": "favourite favorite",
+    "kind": "breed kind type sort species variety make model brand",
+}.items():
+    for w in words.split():
+        _KIND.setdefault(w, k)
+
+_ROLE_WORDS = None
+
+
+def _roles():
+    global _ROLE_WORDS
+    if _ROLE_WORDS is None:
+        try:
+            from currency import _ROLES
+            _ROLE_WORDS = set(_ROLES)
+        except Exception:
+            _ROLE_WORDS = set()
+    return _ROLE_WORDS
+
+
+# --- reading the question ---------------------------------------------------
+
+_DET = r"(?:my|our|the|your|his|her|their)"
+_PATTERNS = [
+    # what is my partner's job / what's Sam's salary / what is Priya's last name
+    re.compile(rf"^(?:what|who)(?:'s| is| was| are)\s+(?:{_DET}\s+)?"
+               r"(?P<ent>[\w ]+?)'s\s+(?P<att>[\w ]+?)\??$"),
+    # how much does Sam earn / how old is my dog / how fast is my scooter
+    re.compile(rf"^how\s+(?P<att>\w+)\s+(?:is|are|was|does|do|did)\s+"
+               rf"(?:{_DET}\s+)?(?P<ent>[\w ]+?)(?:\s+\w+)?\??$"),
+    # what colour is my car / what breed is my dog / what year did I buy my car
+    re.compile(rf"^(?:what|which)\s+(?P<att>\w+)\s+(?:is|are|was|were)\s+"
+               rf"(?:{_DET}\s+)?(?P<ent>[\w ]+?)\??$"),
+    re.compile(rf"^(?:what|which)\s+(?P<att>year|colour|color|breed|brand|"
+               rf"model|size|name)\s+(?:did|do|does)\s+i\s+\w+\s+"
+               rf"(?:{_DET}\s+)?(?P<ent>[\w ]+?)\??$"),
+    # where is acme based / where does lee live
+    re.compile(r"^where\s+(?:is|are|does|do)\s+(?:my\s+|the\s+)?"
+               r"(?P<ent>(?!i\b)[\w ]+?)\s+(?P<att>based|located|live|work)\??$"),
+    # what is my job title / what is my favourite database / my salary
+    re.compile(r"^what(?:'s| is| was)\s+my\s+(?P<att>[\w ]+?)\??$"),
+]
+_TRIM = re.compile(r"\s+(?:at work|now|these days|currently|again|going to be|"
+                   r"going to|going|gonna be|gonna|turning|this year|next year)$")
+
+
+def read_question(q):
+    """-> (entity or None, attribute words) or None when nothing is asked
+    that this module can check. entity None means the owner."""
+    s = re.sub(r"\s+", " ", (q or "").strip().lower())
+    s = s.replace("’", "'")
+    for i, rx in enumerate(_PATTERNS):
+        m = rx.match(s)
+        if not m:
+            continue
+        att = _TRIM.sub("", m.group("att").strip())
+        ent = m.groupdict().get("ent")
+        if ent:
+            ent = ent.strip()
+            for _ in range(3):
+                ent = _TRIM.sub("", ent)
+        if ent:
+            # "the billing service in" -> "the billing service"
+            ent = re.sub(r"\s+(in|at|on|to|for|from|of|with|by)$", "", ent)
+            # "the atlas project written" -> "the atlas project"
+            ent = re.sub(r"\s+(written|made|built|based|located|run|hosted)$",
+                         "", ent)
+            # "i born in", "i buy" -> the owner
+            if re.match(r"^(i|me|myself)\b", ent):
+                ent = None
+        if ent in ("i", "me", "", "home", "my home", "my place", "my house",
+                   "my flat"):
+            ent = None           # "Which suburb is home?" is about the user
+        if i == 5:                       # "what is my X": X may be "favourite Y"
+            # "what is my daughter called" -> (daughter, name)
+            m = re.match(r"^(.+?)\s+(?:called|named)$", att)
+            if m:
+                return (m.group(1), "name")
+            words = att.split()
+            if words and words[0] in ("favourite", "favorite") and len(words) > 1:
+                return (" ".join(words[1:]), "favourite")
+            if not any(w in _KIND for w in words):
+                return None              # "what is my car like" etc.
+        return (ent, att)
+    return None
+
+
+def _kind(att):
+    words = att.split()
+    for w in reversed(words):            # "job title" -> role, "last name" -> name
+        if w in _KIND:
+            return _KIND[w]
+    return None
+
+
+_ENT_STOP = {"the", "and", "our", "your", "his", "her", "their", "its"}
+# generic heads: "the Atlas project" is mentioned by "Atlas is written in
+# Go"; "the billing service" still needs "billing" (review 2026-10-02)
+_GENERIC_HEADS = {"project", "service", "app", "application", "team",
+                  "company", "system", "tool", "product", "website", "site",
+                  "repo", "codebase", "platform", "thing"}
+
+
+# 2026-10-03 (dev paraphrase set): "my mother" is "Mum", "my sibling" is "my
+# brother Callum"
+_KIN = {"mother": "mum mom mam mummy mommy ma", "father": "dad daddy pa papa",
+        "grandmother": "nan nana gran granny grandma", "grandfather":
+        "grandpa granddad grandad pop", "partner": "husband wife boyfriend "
+        "girlfriend fiance fiancee spouse", "spouse": "husband wife",
+        "sibling": "brother sister", "child": "son daughter kid",
+        "children": "son daughter kids", "kid": "son daughter child"}
+
+
+def _mentions(text, ent):
+    """Every content word of the entity: "the billing service" is not
+    mentioned by "the pricing service" (tools/scale_test.py, 2026-10-02 --
+    any one word let filler about other services answer)."""
+    if not ent:
+        return True
+    words = [w for w in re.findall(r"[a-z]+", ent)
+             if len(w) > 2 and w not in _ENT_STOP]
+    specific = [w for w in words if w not in _GENERIC_HEADS]
+    words = specific or words
+    tl = text.lower()
+
+    def present(w):
+        if re.search(rf"\b{re.escape(w)}s?\b", tl):
+            return True
+        alts = _KIN.get(w) or _KIN.get(w.rstrip("s"))
+        if alts and any(re.search(rf"\b{a}s?\b", tl) for a in alts.split()):
+            return True
+        try:
+            import answer_type as _AT
+            return any(_AT.related(w, t) for t in re.findall(r"[a-z]+", tl)
+                       if len(t) > 2)
+        except Exception:
+            return False
+    return all(present(w) for w in words) if words else True
+
+
+def _names_a_kind(tl, ent):
+    ent_words = re.findall(r"[a-z]+", (ent or "").lower())
+    if not ent_words:
+        return False
+    import answer_type as _AT
+    head = _AT._singular(ent_words[-1])
+    closed = _AT._closed(head)
+    for w in set(re.findall(r"[a-z]+", tl)) - set(ent_words) - _AT._STOP:
+        if len(w) < 3 or _AT._singular(w) == head:
+            continue
+        if w in closed or _below(w, head, 2):
+            return True
+    return False
+
+
+def _below(word, head, depth):
+    """Is `word` at least `depth` hypernym steps under `head` in WordNet?
+    One step is a life stage or a plain sub-kind ("puppy", "sedan"), not
+    what "breed" or "make" asks for; breeds sit deeper ("beagle -> hound ->
+    hunting dog -> dog")."""
+    import answer_type as _AT
+    wn = _AT._wn()
+    if wn is None:
+        return False
+    tsyn = set(wn.synsets(head, pos=wn.NOUN))
+    for syn in wn.synsets(word, pos=wn.NOUN)[:8]:
+        for path in syn.hypernym_paths():
+            hit = [i for i, x in enumerate(path) if x in tsyn]
+            if hit and len(path) - 1 - hit[-1] >= depth:
+                return True
+    return False
+
+
+def answers(fact, q_read, owner=None):
+    """Does this fact (a recall dict with text/said/attribute/value) supply
+    what the question asks?"""
+    ent, att = q_read
+    text = " ".join(str(fact.get(k) or "") for k in ("text", "said"))
+    tl = text.lower()
+    if not _mentions(text, ent):
+        return False
+    kind = _kind(att)
+    toks = set(re.findall(r"[a-z+#]+", tl))
+    if kind == "role":
+        return bool(toks & _roles()) or "works as" in tl
+    if kind == "employer":
+        return bool(re.search(r"\b(works? (?:at|for)|joined|employ\w*|"
+                              r"job at)\b", tl))
+    if kind == "place":
+        return bool(_PLACE.search(text))
+    if kind == "colour":
+        return bool(toks & _COLOURS)
+    if kind == "name":
+        # 2026-10-02 (tools/scale_test.py): "any two capitalised words" let
+        # "What is Priya's last name?" be answered by "Alex Reyes's manager
+        # Priya suggested it" -- the capitals were the owner's own name. A
+        # name answers when it is introduced as one, or stands right after
+        # the entity ("Priya Sharma", "my cat Tom").
+        if re.search(r"\b(called|named|name is)\b", tl):
+            return True
+        # Review 2026-10-02: "My wife is Priya", "my dentist is Dr Lee" -- a
+        # copula and a title may stand between the entity and the name.
+        own = {w.lower() for w in re.findall(r"[A-Za-z]+", owner or "")}
+        for w in [w for w in re.findall(r"[a-z]+", ent or "") if len(w) > 2]:
+            for m in re.finditer(
+                    rf"\b{re.escape(w)}(?:'s|s)?\b(?:\s+(?:is|was|'s))?"
+                    rf"(?:\s+(?:Dr|Mr|Mrs|Ms|Miss|Prof)\.?)?\s+([A-Za-z]+)",
+                    text, re.I):
+                nm = m.group(1)
+                if nm[0].isupper() and nm.lower() not in own:
+                    return True
+        return False
+    if kind == "number":
+        return bool(re.search(r"\d", tl) or toks & _NUMBER_WORDS)
+    if kind == "time":
+        return bool(re.search(r"\b(19|20)\d\d\b|\b(january|february|march|april|"
+                              r"may|june|july|august|september|october|"
+                              r"november|december|last|ago|since)\b", tl))
+    if kind == "reason":
+        return bool(_REASON.search(tl))
+    if kind == "language":
+        return bool(toks & _LANGUAGES)
+    if kind == "preference":
+        return bool(_PREFERENCE.search(tl))
+    if kind == "kind" and _names_a_kind(tl, ent):
+        # 2026-10-03 (fresh install on the Mac): "What breed is my dog?" was
+        # refused against "My dog Biscuit is a beagle" -- "breed" is never
+        # said. A word naming a kind of the entity answers it (WordNet: a
+        # beagle is a dog; a closed list for car makes).
+        return True
+    # no known kind: the attribute word itself must appear
+    words = [w for w in re.findall(r"[a-z]+", att) if len(w) > 2]
+    return bool(words) and all(re.search(rf"\b{re.escape(w)}", tl) for w in words)