graph-engine-memory 0.6.1__py3-none-any.whl

graph_engine/hygiene.py

@@ -0,0 +1,213 @@
+"""Hygiene/status analysis (`ig status`, `ig near-dup`).
+
+Read-only reports that support brain maintenance:
+
+- `near_dup_pairs` — finds near-duplicate pairs in the cosine band below the
+  auto-dedup threshold (0.92). These pairs need a manual
+  `ig merge` decision (see `graph_engine.merge`).
+- `connectivity` / `status_counts` — islands, weak nodes, orphans and
+  status distribution, so underpopulation and the hygiene backlog become visible.
+
+Everything is read-only — nothing on the brain is modified.
+"""
+from __future__ import annotations
+
+import json
+from collections import Counter
+from dataclasses import dataclass
+
+import numpy as np
+
+from .brain import Brain
+
+# Auto-dedup threshold in brain_engine (cos >= 0.92 -> merge). Pairs below it,
+# but close enough, are candidates for manual consolidation.
+DEFAULT_DEDUP_THRESHOLD = 0.92
+DEFAULT_NEAR_LO = 0.78
+
+
+@dataclass
+class NearDup:
+    score: float
+    a: str
+    b: str
+    a_text: str
+    b_text: str
+
+
+_VEC_CACHE: dict[tuple[str, float, int], tuple[list[str], np.ndarray]] = {}
+
+
+def _load_vectors(brain: Brain) -> tuple[list[str], np.ndarray]:
+    """Reads vectors.jsonl; uses the dominant dimension (384 real vs 64 hash).
+
+    Audit #38: float32 rounds band-boundary cases wrong (0.9199999990 float64
+    -> 0.9200000167 float32 — the pair falls through BOTH mechanisms: no dup
+    in the engine, but not in the review band either). Hence float64.
+    Audit #60: results are cached keyed by (path, mtime, size) — repeated
+    report calls within one process skip the re-parse; any write to the file
+    invalidates the entry automatically."""
+    if hasattr(brain, "identity"):
+        vecs = brain.read_vectors()
+        if not vecs:
+            return [], np.zeros((0, 0), dtype=np.float64)
+        lens = Counter(len(v) for v in vecs.values())
+        dom = max(lens, key=lens.get)
+        ids = [nid for nid, v in vecs.items() if len(v) == dom]
+        values = np.array([vecs[nid] for nid in ids], dtype=np.float64)
+        return ids, values / (np.linalg.norm(values, axis=1, keepdims=True) + 1e-12)
+    vec_file = brain.path / "vectors.jsonl"
+    if not vec_file.exists():
+        return [], np.zeros((0, 0), dtype=np.float64)
+    try:
+        st = vec_file.stat()
+        key = (str(vec_file), st.st_mtime_ns, st.st_size)
+    except OSError:
+        key = None
+    if key is not None and key in _VEC_CACHE:
+        return _VEC_CACHE[key]
+    vecs: dict[str, list[float]] = {}
+    lens: Counter = Counter()
+    for l in vec_file.read_text(encoding="utf-8").splitlines():
+        if not l.strip():
+            continue
+        try:
+            o = json.loads(l)
+        except json.JSONDecodeError:
+            continue  # Audit #17 family: a corrupt line does not kill the report
+        vecs[o["id"]] = o["vec"]
+        lens[len(o["vec"])] += 1
+    if not vecs:
+        return [], np.zeros((0, 0), dtype=np.float64)
+    dom = max(lens, key=lambda k: lens[k])
+    ids = [n for n, v in vecs.items() if len(v) == dom]
+    V = np.array([vecs[n] for n in ids], dtype=np.float64)
+    V = V / (np.linalg.norm(V, axis=1, keepdims=True) + 1e-12)
+    if key is not None:
+        _VEC_CACHE[key] = (ids, V)
+    return ids, V
+
+
+def near_dup_pairs(
+    brain: Brain,
+    lo: float = DEFAULT_NEAR_LO,
+    hi: float = DEFAULT_DEDUP_THRESHOLD,
+    max_pairs: int | None = None,
+) -> list[NearDup]:
+    """Finds near-duplicate pairs in the cosine band [lo, hi), descending by score.
+
+    Audit #38: the upper band end is inclusive-consistent with the engine — a
+    float64 cos of 0.9199999990 is NOT a dup in the engine (0.92 threshold),
+    so it must appear in the review band. An epsilon buffer at `hi` prevents
+    rounding from dropping such pairs out of both mechanisms.
+    Audit #39: the pair iteration runs vectorized (triu mask) instead of in
+    O(N²) Python loops (4M iterations @2k, ~50 s @20k)."""
+    ids, V = _load_vectors(brain)
+    if len(ids) < 2:
+        return []
+    # Tombstones are edge-less BY DESIGN (`ig merge` redirects the deletee's edges
+    # away), so a merged deletee keeps its stale vector in vectors.jsonl and would
+    # re-report the very pair it was merged for on EVERY run — the same phantom-node
+    # class as the connectivity()/gaps filter. Review only live nodes.
+    nodes = brain.read_nodes()
+    live = {n.id for n in nodes if n.status != "tombstone"}
+    keep = [i for i, nid in enumerate(ids) if nid in live]
+    if len(keep) < 2:
+        return []
+    ids = [ids[i] for i in keep]
+    V = V[keep]
+    S = V @ V.T
+    np.fill_diagonal(S, -1.0)
+    band = (S >= lo) & (S < hi + 1e-6)
+    band = np.triu(band, k=1)
+    ii, jj = np.nonzero(band)
+    texts = {n.id: n.text for n in nodes}
+    pairs = [NearDup(float(S[i][j]), ids[int(i)], ids[int(j)],
+                     texts.get(ids[int(i)], ids[int(i)])[:72],
+                     texts.get(ids[int(j)], ids[int(j)])[:72])
+             for i, j in zip(ii, jj)]
+    pairs.sort(key=lambda p: p.score, reverse=True)
+    if max_pairs is not None:
+        # Audit #60: `if max_pairs:` treated max_pairs=0 as "unbounded" —
+        # 0 means limit 0 (no pairs).
+        pairs = pairs[:max_pairs]
+    return pairs
+
+
+@dataclass
+class Connectivity:
+    total: int
+    edges: int
+    islands: list[str]   # degree <= 1
+    weak: list[str]      # degree == 2
+    orphans: list[str]   # degree == 0
+    max_degree: int
+    mean_degree: float
+
+
+def connectivity(brain: Brain) -> Connectivity:
+    nodes = brain.read_nodes()
+    # Tombstones are edge-less BY DESIGN (merge redirects their edges away and
+    # keeps the node as append-only history) — counting them made every merge
+    # leave a permanent phantom "orphan/island" in the status report, and the
+    # autonomous cycle then tried to re-link a dead node (found 2026-09-15).
+    nodes = [n for n in nodes if n.status != "tombstone"]
+    edges = brain.read_edges()
+    # Audit #40: invalidated or out-of-window edges no longer count toward
+    # connectivity — otherwise the status report would contradict the
+    # admit-rule logic (_has_relation correctly ignores them).
+    live_edges = [e for e in edges if e.is_current]
+    deg: Counter = Counter()
+    for e in live_edges:
+        deg[e.source] += 1
+        deg[e.target] += 1
+    ids = [n.id for n in nodes]
+    islands = [n for n in ids if deg[n] <= 1]
+    weak = [n for n in ids if deg[n] == 2]
+    orphans = [n for n in ids if deg[n] == 0]
+    vals = [deg[n] for n in ids] or [0]
+    return Connectivity(
+        total=len(ids),
+        edges=len(live_edges),
+        islands=islands,
+        weak=weak,
+        orphans=orphans,
+        max_degree=max(vals),
+        mean_degree=sum(vals) / len(vals),
+    )
+
+
+def status_counts(brain: Brain) -> Counter:
+    c: Counter = Counter()
+    for n in brain.read_nodes():
+        c[n.status] += 1
+    return c
+
+
+def render_status(brain: Brain) -> str:
+    c = connectivity(brain)
+    st = status_counts(brain)
+    lines = [
+        f"Status ({c.total} nodes / {c.edges} edges):",
+        f"  Degree: max={c.max_degree} mean={c.mean_degree:.1f}",
+        f"  Orphans (0 edges): {len(c.orphans)}",
+        f"  Islands (<=1 edge): {len(c.islands)}",
+        f"  Weak (==2 edges): {len(c.weak)}",
+        f"  Status: {dict(st)}",
+    ]
+    if c.islands:
+        lines.append("  Island nodes: " + ", ".join(c.islands[:15]) + (" …" if len(c.islands) > 15 else ""))
+    if c.orphans:
+        lines.append("  Orphan nodes: " + ", ".join(c.orphans[:15]) + (" …" if len(c.orphans) > 15 else ""))
+    return "\n".join(lines)
+
+
+def render_near_dup(pairs: list[NearDup]) -> str:
+    if not pairs:
+        return "No near-duplicates in the band."
+    lines = [f"{len(pairs)} near-duplicate pairs (review consolidation via `ig merge`):"]
+    for p in pairs:
+        lines.append(f"[{p.score:.3f}] {p.a} ↔ {p.b}")
+        lines.append(f"    {p.a_text}")
+        lines.append(f"    {p.b_text}")
+    return "\n".join(lines)

graph_engine/inference.py

@@ -0,0 +1,251 @@
+"""Read-only, evidence-backed relationship queries without an LLM.
+
+Connectivity is not entailment. Only homogeneous is_a/part_of fact chains
+and explicit same_as chains are transitive. Similarity, extends, arbitrary
+predicates and contradictions never acquire transitive logical meaning.
+"""
+from __future__ import annotations
+
+from collections import deque
+from datetime import datetime, timezone
+import re
+from typing import TYPE_CHECKING
+
+from .brain import Brain, Edge, Node
+
+if TYPE_CHECKING:
+    from .brain_engine import BrainEngine
+
+TRANSITIVE = frozenset({"is_a", "part_of", "same_as"})
+
+
+def _snapshot(brain: Brain) -> tuple[dict[str, Node], list[Edge]]:
+    nodes = {n.id: n for n in brain.read_nodes() if n.status != "tombstone"}
+    now = datetime.now(timezone.utc)
+    # Check both endpoints and actual start dates, including legacy edges.
+    edges = sorted((e for e in brain.read_edges()
+                    if e.source in nodes and e.target in nodes
+                    and not e.pending and not e.rejected and e.is_current
+                    and e.is_valid_at(now)), key=lambda e: e.id)
+    return nodes, edges
+
+
+def _resolve(nodes: dict[str, Node], reference: str) -> str:
+    reference = reference.strip().strip('"\'').strip()
+    if reference in nodes:
+        return reference
+    key = reference.casefold()
+    matches = sorted(n.id for n in nodes.values()
+                     if key in {s.casefold() for s in
+                                [n.text.strip(), n.entity_name or "", *n.aliases] if s})
+    if not matches:
+        raise ValueError(f"No live node matches {reference!r}; use a node ID or exact name.")
+    if len(matches) != 1:
+        raise ValueError(f"Ambiguous node {reference!r}; use an ID: {', '.join(matches)}")
+    return matches[0]
+
+
+def _query_pair(query: str) -> tuple[str, str]:
+    query = query.strip()
+    if "->" in query:
+        parts = query.split("->")
+        if len(parts) == 2 and all(p.strip() for p in parts):
+            return parts[0].strip(), parts[1].strip()
+    patterns = [
+        r"(?:what is (?:the )?)?relationship between (.+?) and (.+?)\??",
+        r"how (?:does|is) (.+?) (?:relate(?:d)?|connected) to (.+?)\??",
+    ]
+    for pattern in patterns:
+        match = re.fullmatch(pattern, query, flags=re.IGNORECASE)
+        if match:
+            return match[1].strip(), match[2].strip()
+    raise ValueError("Use 'A -> B', 'relationship between A and B', or "
+                     "'How does A relate to B?' (exact names or node IDs).")
+
+
+def _relation(edge: Edge) -> str:
+    return edge.predicate or "fact" if edge.kind == "fact" else edge.kind
+
+
+def _adjacency(edges: list[Edge], relation: str | None = None) -> dict[str, list[tuple[str, Edge]]]:
+    adj: dict[str, list[tuple[str, Edge]]] = {}
+    for edge in edges:
+        if relation is not None:
+            if _relation(edge) != relation:
+                continue
+            # A generic kind named part_of is not a structured fact.
+            if edge.kind != "fact" and edge.kind != "same_as":
+                continue
+        adj.setdefault(edge.source, []).append((edge.target, edge))
+        if relation is None or relation == "same_as":
+            adj.setdefault(edge.target, []).append((edge.source, edge))
+    for links in adj.values():
+        links.sort(key=lambda pair: (pair[0], pair[1].id))
+    return adj
+
+
+def _walks(start: str, adj: dict[str, list[tuple[str, Edge]]], max_depth: int,
+           *, target: str | None = None, limit: int | None = None) -> list[dict]:
+    """Deterministic BFS: one shortest evidence path per reachable node."""
+    queue = deque([(start, [start], [])])
+    seen = {start}
+    paths = []
+    while queue:
+        current, node_ids, steps = queue.popleft()
+        if len(steps) >= max_depth:
+            continue
+        for other, edge in adj.get(current, []):
+            if other in seen:
+                continue
+            seen.add(other)
+            new_steps = [*steps, {"edge_id": edge.id, "source": edge.source,
+                                 "target": edge.target, "relation": _relation(edge),
+                                 "direction": "out" if edge.source == current else "in"}]
+            new_ids = [*node_ids, other]
+            path = {"node_ids": new_ids, "steps": new_steps, "hops": len(new_steps)}
+            if target is None or other == target:
+                paths.append(path)
+                if target is not None or (limit is not None and len(paths) >= limit):
+                    return paths
+            queue.append((other, new_ids, new_steps))
+    return paths
+
+
+def _contradictions(edges: list[Edge], relevant: set[str],
+                    relations: list[dict] | None = None) -> list[dict]:
+    conflicts = []
+    facts: dict[tuple[str, str, str], list[str]] = {}
+    for edge in edges:
+        if edge.source not in relevant or edge.target not in relevant:
+            continue
+        if _relation(edge) == "contradicts":
+            conflicts.append({"kind": "recorded", "source": edge.source,
+                              "target": edge.target, "edge_ids": [edge.id]})
+        if edge.kind == "fact" and edge.predicate:
+            facts.setdefault((edge.source, edge.predicate, edge.target), []).append(edge.id)
+    # Include inferred support so a direct not_part_of can conflict with a
+    # multi-hop part_of proof. Negative predicates themselves are not transitive.
+    for relation in relations or []:
+        if relation["inferred"]:
+            key = relation["source"], relation["relation"], relation["target"]
+            facts.setdefault(key, []).extend(relation["edge_ids"])
+    for (source, predicate, target), ids in sorted(facts.items()):
+        if predicate.startswith("not_"):
+            positive = facts.get((source, predicate[4:], target))
+            if positive:
+                conflicts.append({"kind": "opposing_facts", "source": source,
+                                  "target": target, "relation": predicate[4:],
+                                  "edge_ids": sorted(set(ids + positive))})
+    return conflicts
+
+
+def infer(brain: Brain, query: str, *, max_depth: int = 4) -> dict:
+    """Answer a pair query with direct facts, conservative inference and paths.
+
+    Results are bounded by max_depth and describe stored assertions, not
+    independently verified real-world facts. No brain files are written.
+    """
+    if not 1 <= max_depth <= 20:
+        raise ValueError("max_depth must be between 1 and 20")
+    left, right = _query_pair(query)
+    nodes, edges = _snapshot(brain)
+    source, target = _resolve(nodes, left), _resolve(nodes, right)
+    paths = (_walks(source, _adjacency(edges), max_depth, target=target)
+             if source != target else [{"node_ids": [source], "steps": [], "hops": 0}])
+    relations = []
+    for edge in edges:
+        if {edge.source, edge.target} == {source, target}:
+            relations.append({"source": edge.source, "target": edge.target,
+                              "relation": _relation(edge), "inferred": False,
+                              "edge_ids": [edge.id], "rule": "recorded_edge"})
+    for predicate in sorted(TRANSITIVE):
+        # Direction matters: report reverse proofs with their real endpoints.
+        pairs = [(source, target)] if predicate == "same_as" else [(source, target), (target, source)]
+        for start, end in pairs:
+            proof = _walks(start, _adjacency(edges, predicate), max_depth, target=end)
+            if proof and proof[0]["hops"] > 1:
+                path = proof[0]
+                relations.append({"source": start, "target": end, "relation": predicate,
+                                  "inferred": True, "rule": f"transitive_{predicate}",
+                                  "edge_ids": [s["edge_id"] for s in path["steps"]]})
+                if path not in paths:
+                    paths.append(path)
+    relevant = {source, target} | {nid for p in paths for nid in p["node_ids"]}
+    conflicts = _contradictions(edges, relevant, relations)
+    evidence_ids = ({s["edge_id"] for p in paths for s in p["steps"]}
+                    | {eid for r in relations for eid in r["edge_ids"]}
+                    | {eid for c in conflicts for eid in c["edge_ids"]})
+    labels = {nid: nodes[nid].entity_name or nodes[nid].text for nid in sorted(relevant)}
+    statements = [f"{labels[r['source']]} --{r['relation']}--> {labels[r['target']]}"
+                  + (" (transitive)" if r["inferred"] else " (recorded)") for r in relations]
+    if source == target:
+        answer = "Both references resolve to the same node."
+    elif statements:
+        answer = "; ".join(statements) + "."
+    elif paths:
+        answer = (f"Connected by a {paths[0]['hops']}-edge path; this connection "
+                  "does not establish a transitive relation.")
+    else:
+        answer = f"No connection found within {max_depth} hops."
+    if conflicts:
+        answer += f" {len(conflicts)} recorded contradiction(s) or opposing fact(s) in the evidence."
+    return {"query": query, "source": source, "target": target, "answer": answer,
+            "max_depth": max_depth, "relations": relations, "paths": paths,
+            "contradictions": conflicts, "nodes": labels,
+            "edges": [e.to_dict() for e in edges if e.id in evidence_ids]}
+
+
+def explain_node(brain: Brain, node_id: str, *, max_depth: int = 2, limit: int = 20) -> dict:
+    """Explain a node's current graph context; never claim it caused retrieval."""
+    if not 1 <= max_depth <= 20 or not 1 <= limit <= 1000:
+        raise ValueError("max_depth must be 1..20 and limit must be 1..1000")
+    nodes, edges = _snapshot(brain)
+    if node_id not in nodes:
+        raise ValueError(f"No live node with id {node_id!r}.")
+    found = _walks(node_id, _adjacency(edges), max_depth, limit=limit + 1)
+    paths = found[:limit]
+    relevant = {node_id} | {nid for path in paths for nid in path["node_ids"]}
+    context = [e for e in edges if e.source in relevant and e.target in relevant]
+    return {"node_id": node_id, "text": nodes[node_id].text,
+            "graph_used_for_ranking": False, "max_depth": max_depth, "limit": limit,
+            "truncated": len(found) > limit, "paths": paths,
+            "graph_context": [e.to_dict() for e in context],
+            "contradictions": _contradictions(context, relevant),
+            "explanation": "Current graph paths are context only. Use --query to recompute "
+                           "retrieval scores; graph paths are not used by hybrid ranking."}
+
+
+def print_paths(paths: list[dict]) -> None:
+    for path in paths:
+        parts = [path["node_ids"][0]]
+        for step, nid in zip(path["steps"], path["node_ids"][1:]):
+            arrow = (f"--{step['relation']}[{step['edge_id']}]-->" if step["direction"] == "out"
+                     else f"<--{step['relation']}[{step['edge_id']}]--")
+            parts.extend([arrow, nid])
+        print("  " + " ".join(parts))
+
+
+def cmd_infer(engine: BrainEngine, args: list[str]) -> None:
+    import argparse
+    import json
+    import sys
+
+    parser = argparse.ArgumentParser(prog="ig infer", description=infer.__doc__)
+    parser.add_argument("query", nargs="+")
+    parser.add_argument("--max-depth", type=int, default=4)
+    parser.add_argument("--json", action="store_true")
+    options = parser.parse_args(args)
+    try:
+        result = infer(engine.brain, " ".join(options.query), max_depth=options.max_depth)
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        raise SystemExit(1)
+    if options.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        print(result["answer"])
+        print("Evidence paths:")
+        print_paths(result["paths"])
+        for conflict in result["contradictions"]:
+            print(f"  Conflict {conflict['source']} / {conflict['target']}: "
+                  + ", ".join(conflict["edge_ids"]))

graph_engine/intent.py

@@ -0,0 +1,207 @@
+"""Intent-typed edges (Roadmap V2#3, Zettelkasten lesson).
+
+Beyond bare similarity ("similar"/"extends") the engine detects
+INTENT between two nodes from signals in the text:
+
+  supersedes      new makes old obsolete        ("API v2 replaces v1")
+  contradicts     new denies/opposes old        ("The Earth is NOT flat")
+  continues       new continues/builds on old   ("further ... based on")
+
+Heuristic (no NLP dependency), deterministic and testable. Returns None
+when no intent is detected — similarity then decides as before.
+
+Audit #35/#36/#51/#61 (fix wave 3): markers match on token boundaries
+("versetzt" no longer fires "ersetzt"), the subject check runs
+clause-scoped (the marker must share a sentence with a shared content
+word — mere presence in the text is not enough), the negation check runs
+bidirectionally (new affirms what old denied -> contradicts too), and
+the marker sets are fully bilingual.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Marker sequences (lowercase). Matching is token-based: a marker only
+# matches when its tokens appear as a SEQUENCE in the token stream —
+# "versetzt" (tokens: [versetzt]) no longer matches "ersetzt", while
+# "findet statt" (tokens [findet, statt]) still matches the supersedes
+# marker "statt" because it really occurs as its own word there (but only
+# in the same clause as the subject — see _clause_hits).
+# Bilingual (Audit #61): every set covers DE and EN.
+SUPERSEDE_MARKERS: tuple[tuple[str, ...], ...] = (
+    ("ersetzt",), ("ersetzt", "durch"), ("ersatz",),
+    ("ablöst",), ("löst", "ab"), ("abgelöst",),
+    ("supersedes",), ("superseded",), ("replaces",), ("replaced", "by"),
+    ("obsolet",), ("obsolete",), ("deprecated",),
+    ("statt",), ("anstelle", "von"), ("instead", "of"), ("replaces",),
+)
+CONTRADICT_MARKERS: tuple[tuple[str, ...], ...] = (
+    ("ist", "nicht"), ("nicht", "mehr"), ("keineswegs",),
+    ("widerspricht",), ("widersprochen",),
+    ("keine",), ("kein",), ("niemals",), ("nie",),
+    ("ist", "falsch"), ("falsch",), ("falsche",),
+    ("is", "not"), ("no", "longer"), ("never",), ("not", "true"),
+    ("false",), ("wrong",), ("contradicts",),
+)
+CONTINUE_MARKERS: tuple[tuple[str, ...], ...] = (
+    ("setzt", "fort"), ("basiert", "auf"), ("aufbauend",),
+    ("weiterentwicklung",), ("weiterentwickelt",), ("verfeinert",),
+    ("erweitert", "um"), ("fortgeführt",),
+    ("builds", "on"), ("based", "on"), ("extends",), ("extends", "with"),
+    ("continues",), ("continued",), ("refines",), ("follows", "from"),
+)
+
+# Priority on multiple hits (audit #51): supersedes > contradicts
+# > continues — documented and deterministic; the clause-scoped subject
+# check already disambiguates most double hits.
+_PRIORITY = ("supersedes", "contradicts", "continues")
+
+# The three intent kinds, public and single-source: the review policy
+# (`review.INTENT_KINDS` import) and the eval oracle both bound their behavior
+# on this tuple instead of re-listing the strings.
+INTENT_KINDS: tuple[str, ...] = _PRIORITY
+
+_MARKER_TO_INTENT: dict[tuple[str, ...], str] = {}
+for _m in SUPERSEDE_MARKERS:
+    _MARKER_TO_INTENT[_m] = "supersedes"
+for _m in CONTRADICT_MARKERS:
+    _MARKER_TO_INTENT[_m] = "contradicts"
+for _m in CONTINUE_MARKERS:
+    _MARKER_TO_INTENT[_m] = "continues"
+
+_WORD_RE = re.compile(r"[a-zäöüß0-9]+")
+
+# Common function/stop words (DE + EN) that do NOT indicate topical overlap.
+# Without the filter `shared` would be almost always true (die/der/und/ist… in
+# every text), which would make the intent subject check ineffective.
+_STOPWORDS = frozenset(
+    """
+    die der das und ist ein eine einer eines mit von für auf den dem aus bei
+    als wie nur auch sich nicht keine kein sind wird werden wurde sein ihre
+    ihren ihrer diesem diese dieses dieser gegen über unter zwischen ohne weil
+    dass durch zum zur im am in an wir ich du er sie es war hat habe haben
+    dann wenn so aber oder noch nach vor hier da bitte würde können sollen
+    muss worden indem obwohl deshalb trotz außer sowohl sowie bspw z.b bzw
+    the and is are with for on of a an to in not no this that but or as was
+    were been has have it its be been can will would should must shall may
+    """.split()
+)
+
+
+def _tokens(text: str) -> list[str]:
+    """Token stream: lowercase, punctuation separated (Audit #36: "Erde," was
+    previously a different token than "Erde")."""
+    return _WORD_RE.findall(text.lower())
+
+
+def _content_words(text: str) -> set[str]:
+    return {w for w in _tokens(text) if len(w) >= 3 and w not in _STOPWORDS}
+
+
+def _clauses(text: str) -> list[list[str]]:
+    """Sentence/clause boundaries: . ! ? ; , : and line breaks separate."""
+    parts = re.split(r"[.!?;,:()\[\]\"\']|\n+", text.lower())
+    return [_tokens(p) for p in parts if _tokens(p)]
+
+
+def _marker_hits(tokens: list[str], markers: tuple[tuple[str, ...], ...]) -> list[tuple[str, ...]]:
+    """Markers that occur as contiguous token sequences."""
+    hits = []
+    n = len(tokens)
+    for m in markers:
+        L = len(m)
+        for i in range(n - L + 1):
+            if tokens[i:i + L] == list(m):
+                hits.append(m)
+                break
+    return hits
+
+
+# Noun-negation/replacement markers: here the negated/replaced thing is the
+# OBJECT of the marker — it must appear as a shared content word SHORTLY AFTER
+# the marker. "keine Zeit für Review" negates "Zeit", not "Review" (Audit #35);
+# "findet statt" has no object after "statt" (stattfinden verb, no supersedes).
+_OBJECT_MARKERS = frozenset(("keine", "kein", "nie", "niemals", "statt", "falsch",
+                             "falsche", "no", "never", "false", "wrong"))
+
+
+def _marker_object_shared(clause: list[str], marker: tuple[str, ...], subjects: set[str]) -> bool:
+    if marker[0] not in _OBJECT_MARKERS:
+        return True  # verbal markers: subject-in-clause check suffices
+    # Find the end position of the marker; a shared content word within the
+    # next 2 tokens makes the negation the subject ("keine Scheibe" ✓,
+    # "keine Zeit für Review" ✗ — Review sits at position +3 and is not
+    # the negated thing). The window is positional (articles/adjectives in
+    # between are fine).
+    n = len(clause)
+    for i in range(n - len(marker) + 1):
+        if clause[i:i + len(marker)] == list(marker):
+            window = clause[i + len(marker):i + len(marker) + 2]
+            if set(window) & subjects:
+                return True
+    return False
+
+
+def _clause_hits(clauses: list[list[str]], markers: tuple[tuple[str, ...], ...],
+                 subjects: set[str]) -> bool:
+    """True when a marker shares a sentence/clause with a subject content word.
+
+    Audit #35: mere marker presence in the text fired against EVERY related
+    node ("Der Mitarbeiter wird versetzt" → supersedes because of the
+    'ersetzt' substring in 'versetzt' + shared domain words). Now the marker
+    must be in the same sentence as a shared content word — and for object
+    markers (keine/kein/nie/statt/falsch) the negated/replaced object itself
+    must be shared."""
+    for clause in clauses:
+        if not (_content_words(" ".join(clause)) & subjects):
+            continue
+        hits = _marker_hits(clause, markers)
+        if any(_marker_object_shared(clause, m, subjects) for m in hits):
+            return True
+    return False
+
+
+def detect_intent(new_text: str, old_text: str) -> str | None:
+    """Intent between the new and the existing node, or None.
+
+    `new_text` is the newly ingested statement, `old_text` the existing one.
+    All three intents require that both talk about the same subject
+    (shared content words) AND that the marker shares a sentence with a
+    shared content word (Audit #35).
+
+    Audit #36 (bidirectional negation): if OLD denies the subject and
+    NEW affirms it (or vice versa), that is also contradicts — before,
+    new-affirms-what-old-denies returned None.
+    """
+    new_subjects = _content_words(new_text)
+    shared = new_subjects & _content_words(old_text)
+    if not shared:
+        return None
+
+    new_clauses = _clauses(new_text)
+    old_clauses = _clauses(old_text)
+
+    hits: dict[str, bool] = {}
+    for intent, markers in (
+        ("supersedes", SUPERSEDE_MARKERS),
+        ("contradicts", CONTRADICT_MARKERS),
+        ("continues", CONTINUE_MARKERS),
+    ):
+        hits[intent] = (
+            _clause_hits(new_clauses, markers, shared)
+            or _clause_hits(old_clauses, markers, shared)
+        )
+
+    # Bidirectional negation (Audit #36): old denies, new affirms the same
+    # subject without negation → contradiction between the statements.
+    if not hits["contradicts"]:
+        old_denies = _clause_hits(old_clauses, CONTRADICT_MARKERS, shared)
+        new_denies = _clause_hits(new_clauses, CONTRADICT_MARKERS, shared)
+        if old_denies and not new_denies:
+            hits["contradicts"] = True
+
+    for intent in _PRIORITY:
+        if hits[intent]:
+            return intent
+    return None

graph_engine/mcp/__init__.py

@@ -0,0 +1 @@
+"""Read-only MCP server for the GraphEngine brain (report #1)."""