structuremappingmemory 1.0.0__py3-none-any.whl

sma/encoders/coverage.py

@@ -0,0 +1,80 @@
+"""Per-query structural coverage indicator (blueprint section 12-R3).
+
+The cross-system event ontology in ``logs_drain.EVENT_CLASS_RULES`` is frozen
+(tag ontology-v1). When a query's vocabulary falls outside those keyword
+rules, MAC/FAC retrieval degrades silently: events still get template
+functors, but none of the shared cross-system class statements fire, so
+structural similarity is computed over near-disjoint functor sets. This is
+the "lattice-miss" tripwire from blueprint section 4.3 / 12-R3, surfaced as a
+measured per-query coverage number rather than hidden.
+
+Read-only consumer of the frozen ontology: imports ``event_classes`` from
+``logs_drain`` and never modifies the rules.
+"""
+
+from __future__ import annotations
+
+from sma.encoders.logs_drain import event_classes
+
+# Below this fraction the SMA evidence panel shows an amber chip and the
+# verbalizer prompt carries an explicit low-confidence caveat.
+COVERAGE_WARN_THRESHOLD = 0.4
+
+# Keyword attributes emitted by LogEncoder in addition to the class rules
+# (timeout/retry/failure statements). They are subsets of the class keyword
+# sets today, but checked explicitly so coverage stays correct even if the
+# attribute rules and class rules ever diverge in a future ontology version.
+_KEYWORD_ATTRIBUTES: tuple[tuple[str, ...], ...] = (
+    ("timeout",),
+    ("retry",),
+    ("error", "exception", "fail"),
+)
+
+
+def _line_fired(line_lower: str, extra_classes=None) -> bool:
+    if event_classes(line_lower):
+        return True
+    if extra_classes is not None and any(
+        any(k in line_lower for k in keywords) for _, keywords in extra_classes
+    ):
+        return True
+    return any(any(k in line_lower for k in keywords) for keywords in _KEYWORD_ATTRIBUTES)
+
+
+def rule_coverage(text: str, extra_classes=None) -> dict:
+    """Fraction of non-empty lines that fired at least one class rule.
+
+    ``extra_classes``: optional (name, keywords) pairs from an active draft
+    adapter - while a draft is applied, its rules legitimately count toward
+    coverage (the chip must reflect what retrieval can actually use).
+
+    Returns a dict with:
+    - ``fraction``: covered / total non-empty lines (0.0 for empty text)
+    - ``covered_lines`` / ``total_lines``: the raw counts
+    - ``low``: True when fraction < COVERAGE_WARN_THRESHOLD
+    - ``percent``: integer percent, for display
+    """
+    lines = [line for line in text.splitlines() if line.strip()]
+    covered = sum(1 for line in lines if _line_fired(line.lower(), extra_classes))
+    total = len(lines)
+    fraction = covered / total if total else 0.0
+    return {
+        "fraction": fraction,
+        "covered_lines": covered,
+        "total_lines": total,
+        "low": fraction < COVERAGE_WARN_THRESHOLD,
+        "percent": round(fraction * 100),
+    }
+
+
+def coverage_warning(coverage: dict) -> str | None:
+    """The exact low-confidence caveat for evidence metadata and the prompt."""
+    if not coverage.get("low"):
+        return None
+    return (
+        f"structural coverage of this query is LOW ({coverage['percent']}%) - "
+        "structural retrieval is low-confidence for this vocabulary"
+    )
+
+
+__all__ = ["COVERAGE_WARN_THRESHOLD", "rule_coverage", "coverage_warning"]

sma/encoders/draft_adapter.py

@@ -0,0 +1,183 @@
+"""LLM-drafted adapter: rules as data, never facts.
+
+The frozen ontology (logs_drain.EVENT_CLASS_RULES, tag ontology-v1) cannot be
+edited, but the blueprint's section 4.1 discipline allows EXTRA deterministic
+class rules supplied as data at the adapter boundary. An LLM may *propose*
+those rules (see sma.agent.adapter_draft); it never encodes anything. Once
+the rules exist as data, encoding is pure deterministic keyword matching:
+identical input + identical rules => identical case bytes.
+
+DraftAdapter composes the standard LogEncoder output with additional class
+statements derived from the supplied DraftRules, mirroring the
+``event_classes`` first-match-per-class semantics of the frozen rules.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+
+import blake3
+
+from sma.ir.schema import entity, make_case, stmt
+
+from .base import EncodeResult
+from .logs_drain import EVENT_CLASS_RULES, LogEncoder, infer_session
+
+FROZEN_CLASS_NAMES = frozenset(name for name, _ in EVENT_CLASS_RULES)
+
+_CLASS_NAME_RE = re.compile(r"^[A-Za-z][A-Za-z0-9]*Event$")
+
+MAX_CLASSES = 8
+MAX_KEYWORDS = 5
+
+
+@dataclass(frozen=True)
+class DraftRules:
+    """Extra deterministic class rules, supplied as data.
+
+    ``classes``: ordered (class_name, tuple-of-keywords) pairs, mirroring the
+    shape of the frozen EVENT_CLASS_RULES. ``maskings``: optional regexes for
+    variable tokens (ids, timestamps, counters), validated and carried in the
+    content-addressed artifact for future template masking. They are NOT
+    applied before keyword matching - class matching mirrors event_classes
+    exactly (raw lowered line), and LLM-drafted masks routinely cover the very
+    substrings the keywords need (e.g. ``code=[a-z0-9-]+`` vs ``grain-drift``).
+    """
+
+    classes: tuple[tuple[str, tuple[str, ...]], ...] = ()
+    maskings: tuple[str, ...] = field(default_factory=tuple)
+
+
+def validate_rules(rules: DraftRules) -> list[str]:
+    """Return a list of validation errors (empty list means valid)."""
+    errors: list[str] = []
+    seen: set[str] = set()
+    for name, keywords in rules.classes:
+        if not isinstance(name, str) or not _CLASS_NAME_RE.match(name):
+            errors.append(
+                f"class name {name!r} must be alphanumeric with an 'Event' suffix"
+            )
+        if name in FROZEN_CLASS_NAMES:
+            errors.append(
+                f"class name {name!r} collides with the frozen ontology-v1 EVENT_CLASS_RULES"
+            )
+        if name in seen:
+            errors.append(f"duplicate class name {name!r}")
+        seen.add(name)
+        if not keywords:
+            errors.append(f"class {name!r} has no keywords")
+        for keyword in keywords:
+            if not isinstance(keyword, str) or not keyword or keyword != keyword.lower():
+                errors.append(
+                    f"class {name!r} keyword {keyword!r} must be a non-empty lowercase string"
+                )
+    for pattern in rules.maskings:
+        try:
+            re.compile(pattern)
+        except re.error as exc:
+            errors.append(f"masking regex {pattern!r} does not compile: {exc}")
+    return errors
+
+
+def rules_hash(rules: DraftRules) -> str:
+    """Content address (blake3) of the canonical JSON form of the rules."""
+    return blake3.blake3(rules_to_json(rules).encode("utf-8")).hexdigest()
+
+
+def rules_to_json(rules: DraftRules) -> str:
+    payload = {
+        "classes": [
+            {"name": name, "keywords": list(keywords)} for name, keywords in rules.classes
+        ],
+        "maskings": list(rules.maskings),
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def rules_from_json(text: str) -> DraftRules:
+    payload = json.loads(text)
+    classes = tuple(
+        (row["name"], tuple(row["keywords"])) for row in payload.get("classes", [])
+    )
+    maskings = tuple(payload.get("maskings", []))
+    return DraftRules(classes=classes, maskings=maskings)
+
+
+class DraftAdapter:
+    """LogEncoder output + extra deterministic class statements from DraftRules."""
+
+    adapter_id = "logs+draft"
+    version = "0.1.0"
+
+    def __init__(self, rules: DraftRules):
+        errors = validate_rules(rules)
+        if errors:
+            raise ValueError("invalid draft rules: " + "; ".join(errors))
+        self.rules = rules
+        self.draft_hash = rules_hash(rules)
+        self._base = LogEncoder()
+
+    def draft_classes(self, line: str) -> list[str]:
+        """Mirror of logs_drain.event_classes, over the supplied rules.
+
+        Matches the raw lowered line, exactly like the frozen rules; see the
+        DraftRules docstring for why maskings are not applied here.
+        """
+        line_lower = line.lower()
+        return [
+            name
+            for name, keywords in self.rules.classes
+            if any(k in line_lower for k in keywords)
+        ]
+
+    def encode(self, artifact: str, **kwargs) -> EncodeResult:
+        base = self._base.encode(artifact, **kwargs)
+        session = kwargs.get("session_id") or infer_session(artifact)
+        extra = []
+        # Mirror the base encoder's event enumeration exactly: e{i} over
+        # non-empty lines, so the extra class statements attach to the same
+        # event entities the base statements use.
+        for i, line in enumerate(line for line in artifact.splitlines() if line.strip()):
+            for cls in self.draft_classes(line):
+                extra.append(stmt(cls, entity(f"e{i}", "event"), entity(session, "session")))
+        metadata = dict(base.case.metadata)
+        metadata.update(
+            {
+                "adapter": "draft",
+                "base_adapter": self._base.adapter_id,
+                "draft_hash": self.draft_hash,
+                "version": self.version,
+            }
+        )
+        case = make_case(tuple(base.case.statements) + tuple(extra), metadata)
+        return EncodeResult(case, base.warnings)
+
+
+def check_determinism(adapter: DraftAdapter, text: str) -> bool:
+    """Encode twice and assert identical canonical bytes (blueprint section 4 CI rule)."""
+    from sma.ir.sexpr import canonical_case_text
+
+    first = adapter.encode(text).case
+    second = adapter.encode(text).case
+    first_text = canonical_case_text(first.statements)
+    second_text = canonical_case_text(second.statements)
+    if first_text != second_text or first.case_id != second.case_id:
+        raise AssertionError(
+            f"draft adapter is non-deterministic for hash={adapter.draft_hash[:8]}"
+        )
+    return True
+
+
+__all__ = [
+    "DraftAdapter",
+    "DraftRules",
+    "MAX_CLASSES",
+    "MAX_KEYWORDS",
+    "check_determinism",
+    "rules_from_json",
+    "rules_hash",
+    "rules_to_json",
+    "validate_rules",
+]

sma/encoders/healthcare.py

@@ -0,0 +1,207 @@
+"""Expert clinical encoder for diabetes inpatient encounters (Tier-0).
+
+Designed as a clinical-informatics specialist would: it does not emit flat
+attribute=value triples. It encodes the *clinical relationships* an
+endocrinologist reasons over — diagnosis comorbidity over the ICD-9 hierarchy,
+the specific diabetes complication, antidiabetic therapy by drug CLASS with
+titration, glycemic control state, care acuity/chronicity — and the higher-order
+causal/temporal chains that link them (poor control -> therapy escalation;
+diabetes -> end-organ complication; chronic utilization -> acute admission).
+
+All mappings are real medical knowledge (ICD-9 category grouping per Strack et
+al. 2014; antidiabetic drug classes per pharmacology; ADA glycemic thresholds).
+NOTHING is fitted to the readmission label, which is never encoded.
+"""
+from __future__ import annotations
+
+from sma.ir.schema import Case, Statement, entity, make_case, stmt
+
+from .base import EncodeResult
+
+# --- ICD-9 diagnosis grouping (Strack et al. 2014, the canonical Diabetes-130
+#     categorization). Maps a code to a body-system category. ---------------
+_DIABETES_COMPLICATION = {
+    "0": "uncomplicated", "1": "ketoacidosis", "2": "hyperosmolar",
+    "3": "other_coma", "4": "renal", "5": "ophthalmic", "6": "neurological",
+    "7": "peripheral_circulatory", "8": "other_specified", "9": "unspecified",
+}
+
+
+def icd9_category(code: str) -> str | None:
+    code = (code or "").strip()
+    if not code:
+        return None
+    if code[0] in "EV":                 # external-cause / supplementary -> Other
+        return "other"
+    if code.startswith("250"):
+        return "diabetes"
+    try:
+        num = int(float(code))
+    except ValueError:
+        return "other"
+    if 390 <= num <= 459 or num == 785:
+        return "circulatory"
+    if 460 <= num <= 519 or num == 786:
+        return "respiratory"
+    if 520 <= num <= 579 or num == 787:
+        return "digestive"
+    if 800 <= num <= 999:
+        return "injury"
+    if 710 <= num <= 739:
+        return "musculoskeletal"
+    if 580 <= num <= 629 or num == 788:
+        return "genitourinary"
+    if 140 <= num <= 239:
+        return "neoplasm"
+    return "other"
+
+
+def diabetes_complication(code: str) -> str | None:
+    code = (code or "").strip()
+    if not code.startswith("250"):
+        return None
+    _, _, dec = code.partition(".")
+    return _DIABETES_COMPLICATION.get(dec[:1], "uncomplicated") if dec else "uncomplicated"
+
+
+# --- Antidiabetic pharmacology: drug -> therapeutic class -------------------
+_DRUG_CLASS = {
+    "metformin": "biguanide",
+    "glimepiride": "sulfonylurea", "glipizide": "sulfonylurea",
+    "glyburide": "sulfonylurea", "chlorpropamide": "sulfonylurea",
+    "tolbutamide": "sulfonylurea", "acetohexamide": "sulfonylurea",
+    "tolazamide": "sulfonylurea",
+    "repaglinide": "meglitinide", "nateglinide": "meglitinide",
+    "pioglitazone": "tzd", "rosiglitazone": "tzd", "troglitazone": "tzd",
+    "acarbose": "agi", "miglitol": "agi",
+    "insulin": "insulin",
+    "examide": "other", "citoglipton": "other",
+    "glyburide-metformin": "combination", "glipizide-metformin": "combination",
+    "glimepiride-pioglitazone": "combination",
+    "metformin-rosiglitazone": "combination", "metformin-pioglitazone": "combination",
+}
+_DRUGS = tuple(_DRUG_CLASS)
+
+
+def _glycemic_state(a1c: str, glu: str) -> str:
+    a1c, glu = (a1c or "").strip(), (glu or "").strip()
+    if a1c in (">7", ">8") or glu in (">200", ">300"):
+        return "uncontrolled"
+    if a1c == "Norm" or glu == "Norm":
+        return "controlled"
+    return "unmeasured"
+
+
+def _bin_count(n: int, lo: int = 1, hi: int = 3) -> str:
+    if n <= 0:
+        return "none"
+    return "low" if n <= hi else "high"
+
+
+def _int(fields: dict, key: str) -> int:
+    try:
+        return int(float(fields.get(key, "0")))
+    except (ValueError, TypeError):
+        return 0
+
+
+class HealthcareEncoder:
+    adapter_id = "healthcare"
+    version = "1.0.0"
+
+    def encode(self, artifact: str, **kwargs) -> EncodeResult:
+        import json
+        fields = json.loads(artifact) if isinstance(artifact, str) else dict(artifact)
+        return EncodeResult(self.encode_record(fields), ())
+
+    def encode_record(self, f: dict) -> Case:
+        # Clinical features are lifted into FUNCTORS (a structure-mapping memory
+        # discriminates on functor identity, not entity arguments), each over a
+        # constant patient node; the higher-order clinical relations connect
+        # them. So two patients with the same comorbidity/therapy/control profile
+        # share functors (MAC discriminates) AND share relational structure (SME
+        # systematicity).
+        p = entity("patient", "patient")
+        S: list[Statement] = []
+
+        def feat(name: str) -> Statement:
+            return stmt(name, p)
+
+        # 0. Raw discriminative features (high-cardinality functors = retrieval
+        #    discrimination). A structure-mapping memory needs BOTH discriminative
+        #    detail AND curated structure; abstraction alone collapses patients.
+        for col, val in f.items():
+            S.append(stmt(col, p, entity(str(val), "value")))
+
+        # 1. Diagnoses -> dx<Category> functors; diabetes complication -> cx<Type>.
+        cats: list[str] = []
+        dia_stmt: Statement | None = None
+        for col in ("diag_1", "diag_2", "diag_3"):
+            cat = icd9_category(f.get(col, ""))
+            if not cat:
+                continue
+            d = feat("dx" + cat.capitalize())
+            S.append(d)
+            cats.append(cat)
+            if cat == "diabetes" and dia_stmt is None:
+                dia_stmt = d
+                comp = diabetes_complication(f.get(col, ""))
+                if comp and comp not in ("uncomplicated", "unspecified"):
+                    c = feat("cx" + comp.replace("_", " ").title().replace(" ", ""))
+                    S.append(c)
+                    S.append(stmt("manifests", d, c))                  # higher-order
+        # comorbidity: relate the first diagnosis to each distinct other system
+        seen_dx = {s.functor: s for s in S if s.functor.startswith("dx")}
+        dx_list = list(seen_dx.values())
+        for other in dx_list[1:]:
+            S.append(stmt("comorbidWith", dx_list[0], other))          # higher-order
+
+        # 2. Therapy -> rx<Class> functors, titration -> up/down<Class>; treats.
+        therapy_stmts: dict[str, Statement] = {}
+        for drug in _DRUGS:
+            status = (f.get(drug, "No") or "No").strip()
+            if status == "No":
+                continue
+            cls = _DRUG_CLASS[drug]
+            if cls not in therapy_stmts:
+                t = feat("rx" + cls.capitalize())
+                therapy_stmts[cls] = t
+                S.append(t)
+                if dia_stmt is not None:
+                    S.append(stmt("treats", t, dia_stmt))              # higher-order
+            if status == "Up":
+                S.append(feat("titrUp" + cls.capitalize()))
+            elif status == "Down":
+                S.append(feat("titrDown" + cls.capitalize()))
+        if len(therapy_stmts) >= 2:
+            S.append(feat("polytherapy"))
+
+        # 3. Glycemic control -> gly<State> functor; clinical picture links.
+        gly = _glycemic_state(f.get("A1Cresult", ""), f.get("max_glu_serum", ""))
+        gly_stmt = feat("gly" + gly.capitalize())
+        S.append(gly_stmt)
+        if dx_list:
+            S.append(stmt("presentsWith", dx_list[0], gly_stmt))       # higher-order
+        for t in therapy_stmts.values():
+            S.append(stmt("addresses", t, gly_stmt))                   # higher-order
+
+        # 4. Poor control -> therapy escalation (the causal chain).
+        change = (f.get("change", "No") or "No").strip()
+        insulin = (f.get("insulin", "No") or "No").strip()
+        if gly == "uncontrolled" and (change == "Ch" or insulin in ("Up", "Steady")):
+            esc = feat("escalation")
+            S.append(esc)
+            S.append(stmt("cause", gly_stmt, esc))                     # higher-order
+
+        # 5. Care acuity / chronicity -> functors.
+        prior = _int(f, "number_inpatient") + _int(f, "number_emergency") + _int(f, "number_outpatient")
+        util = feat("priorUtil" + _bin_count(prior).capitalize())
+        S.append(util)
+        adm = feat("admit" + str(f.get("admission_type_id", "0")))
+        S.append(adm)
+        if _bin_count(prior) == "high":
+            S.append(stmt("chronicity", util, adm))                    # higher-order
+        S.append(feat("los" + _bin_count(_int(f, "time_in_hospital"), hi=4).capitalize()))
+
+        return make_case(S or [feat("encounterUnknown")],
+                         {"adapter": self.adapter_id, "tier": 0})

sma/encoders/logs_drain.py

@@ -0,0 +1,142 @@
+"""Deterministic Tier-0 log encoder.
+
+This is a small Drain-like template masker for the MVP. When Drain3 is
+installed, it can be substituted behind the same output contract.
+"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+from sma.ir.schema import Entity, Statement, entity, make_case, stmt
+
+from .base import EncodeResult
+
+IP_RE = re.compile(r"\b(?:\d{1,3}\.){3}\d{1,3}\b")
+HEX_RE = re.compile(r"\b0x[0-9a-fA-F]+\b")
+NUM_RE = re.compile(r"\b\d+(?:\.\d+)?\b")
+BLOCK_RE = re.compile(r"\bblk[_-]?[A-Za-z0-9_-]+\b")
+
+# Cross-system event ontology (blueprint section 4.3 mini-ontology, tripwire
+# response to the measured ~100% cross-system lattice miss): template hashes
+# are system-specific by construction, so every event also gets coarse
+# deterministic class statements whose functors ARE shared across systems.
+# First-match-per-class keyword rules over the lowercased line; a line may
+# carry several classes. Order is fixed; rules are data.
+EVENT_CLASS_RULES: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("timeoutEvent", ("timeout", "timed out")),
+    ("retryEvent", ("retry", "retrying", "retransmit", "re-send", "resend")),
+    ("ioEvent", ("eofexception", "ioexception", "io error", "input/output", "end of file")),
+    ("memoryEvent", ("out of memory", "oom", "memory error", "ecc", "dimm", "cache error")),
+    ("kernelEvent", ("kernel", "panic", "machine check", "mce", "interrupt")),
+    ("networkEvent", ("connect", "socket", "network", "unreachable", "reset by peer",
+                      "dhcp", "http", "link", "heartbeat", "packet")),
+    ("authEvent", ("auth", "permission", "denied", "credential", "token", "login")),
+    ("storageEvent", ("block", "replica", "disk", "volume", "snapshot", "image", "file system",
+                      "filesystem", "storage")),
+    ("lifecycleEvent", ("start", "stop", "restart", "boot", "shutdown", "terminat", "spawn",
+                        "delet", "creat", "launch", "instance")),
+    ("failureEvent", ("error", "fail", "exception", "fatal", "abort", "corrupt", "invalid")),
+)
+
+
+def event_classes(line_lower: str) -> list[str]:
+    return [name for name, keywords in EVENT_CLASS_RULES if any(k in line_lower for k in keywords)]
+
+
+class LogEncoder:
+    adapter_id = "logs"
+    version = "0.2.0"
+
+    def encode(self, artifact: str, **kwargs) -> EncodeResult:
+        session = kwargs.get("session_id") or infer_session(artifact)
+        statements: list[Statement] = [stmt("logSession", entity(session, "session"))]
+        events: list[Statement] = []
+        counts: Counter[str] = Counter()
+        for i, line in enumerate(line for line in artifact.splitlines() if line.strip()):
+            template = mask_template(line)
+            functor = template_functor(template)
+            event_id = entity(f"e{i}", "event")
+            event_stmt = stmt(functor, event_id, entity(session, "session"))
+            events.append(event_stmt)
+            counts[functor] += 1
+            statements.append(event_stmt)
+            component = infer_component(line)
+            if component:
+                statements.append(stmt("component", event_id, entity(component, "component")))
+            line_lower = line.lower()
+            if "timeout" in line_lower:
+                statements.append(stmt("timeout", event_id, entity(session, "session")))
+            if "retry" in line_lower:
+                statements.append(stmt("retry", event_id, entity(session, "session")))
+            if "error" in line_lower or "exception" in line_lower or "fail" in line_lower:
+                statements.append(stmt("failureEvent", event_id, entity(session, "session")))
+            for cls in event_classes(line_lower):
+                statements.append(stmt(cls, event_id, entity(session, "session")))
+        for left, right in zip(events, events[1:], strict=False):
+            statements.append(stmt("before", left, right))
+        for functor, count in counts.items():
+            statements.append(stmt("count", entity(functor, "event_type"), entity(str(count), "integer")))
+        statements.extend(derive_higher_order(events, statements))
+        case = make_case(statements, {"adapter": self.adapter_id, "version": self.version, "tier": 0})
+        return EncodeResult(case, ())
+
+
+def mask_template(line: str) -> str:
+    line = IP_RE.sub("<IP>", line)
+    line = HEX_RE.sub("<HEX>", line)
+    line = BLOCK_RE.sub("<BLOCK>", line)
+    line = NUM_RE.sub("<NUM>", line)
+    return " ".join(line.strip().split())
+
+
+def template_functor(template: str) -> str:
+    import hashlib
+
+    digest = hashlib.blake2b(template.encode("utf-8"), digest_size=4).hexdigest()
+    words = [w.lower() for w in re.findall(r"[A-Za-z]+", template)]
+    alias = "evt"
+    for key in ("timeout", "retry", "error", "exception", "restart", "fail", "block"):
+        if key in words:
+            alias = key
+            break
+    return f"{alias}_{digest}"
+
+
+def infer_session(text: str) -> str:
+    match = BLOCK_RE.search(text)
+    if match:
+        return match.group(0)
+    return "session_0"
+
+
+def infer_component(line: str) -> str | None:
+    match = re.search(r"\b(?:INFO|WARN|ERROR|DEBUG)\s+([A-Za-z0-9_.-]+)", line)
+    if match:
+        return match.group(1)
+    return None
+
+
+def derive_higher_order(events: list[Statement], statements: list[Statement]) -> list[Statement]:
+    out: list[Statement] = []
+    timeouts = [s for s in statements if s.functor == "timeout"]
+    retries = [s for s in statements if s.functor == "retry"]
+    failures = [s for s in statements if s.functor == "failureEvent"]
+
+    # rules/logs.yaml requires the antecedent event to precede the consequent
+    # ("timeout before retry within session").
+    def event_index(attribute: Statement) -> int:
+        name = attribute.args[0].name if isinstance(attribute.args[0], Entity) else ""
+        return int(name[1:]) if name.startswith("e") and name[1:].isdigit() else -1
+
+    for timeout in timeouts:
+        for retry in retries:
+            if event_index(timeout) < event_index(retry):
+                out.append(stmt("cause", timeout, retry))
+    for failure in failures:
+        for retry in retries:
+            if event_index(failure) < event_index(retry):
+                out.append(stmt("enables", failure, retry))
+    return out
+

sma/encoders/prose_tier1.py

@@ -0,0 +1,57 @@
+"""Flagged Tier-1 prose encoder.
+
+This is a deterministic connective/clause fallback. It is marked Tier-1 and
+does not support headline Tier-0 claims.
+"""
+
+from __future__ import annotations
+
+import re
+from hashlib import blake2s
+
+from sma.ir.schema import Statement, entity, make_case, stmt
+
+from .base import EncodeResult
+
+
+CONNECTIVES = {
+    "because": "cause",
+    "therefore": "cause",
+    "so": "cause",
+    "if": "implies",
+    "although": "contrast",
+    "but": "contrast",
+}
+
+
+class ProseTier1Encoder:
+    adapter_id = "prose_tier1"
+    version = "0.1.0"
+
+    def encode(self, artifact: str, **kwargs) -> EncodeResult:
+        clauses = [c.strip() for c in re.split(r"[.;!?]\s*", artifact) if c.strip()]
+        statements: list[Statement] = []
+        clause_stmts: list[Statement] = []
+        for i, clause in enumerate(clauses):
+            pred = first_verbish(clause) or "mentions"
+            digest = blake2s(clause.encode("utf-8"), digest_size=8).hexdigest()
+            clause_stmt = stmt(pred, entity(f"clause_{i}", "clause"), entity(digest, "text_digest"))
+            clause_stmts.append(clause_stmt)
+            statements.append(clause_stmt)
+        lower = artifact.lower()
+        for token, rel in CONNECTIVES.items():
+            if token in lower and len(clause_stmts) >= 2:
+                statements.append(stmt(rel, clause_stmts[0], clause_stmts[1]))
+        return EncodeResult(
+            make_case(statements or [stmt("emptyProse", entity("doc"))], {"adapter": self.adapter_id, "tier": 1}),
+            ("Tier-1 prose extraction is flagged and excluded from headline claims.",),
+        )
+
+
+def first_verbish(text: str) -> str | None:
+    words = re.findall(r"[A-Za-z]+", text)
+    for word in words:
+        low = word.lower()
+        if low.endswith("ed") or low.endswith("ing") or low in {"is", "are", "was", "were", "has", "have"}:
+            return low
+    return words[0].lower() if words else None