scriptoria 0.4.0__tar.gz → 0.5.1__tar.gz

{scriptoria-0.4.0 → scriptoria-0.5.1}/.gitignore

@@ -29,3 +29,7 @@ build/
 
 # roborev snapshots
 /.roborev/
+
+# Obsidian local state: created when you open vault/ in Obsidian (UI config,
+# sideloaded plugin copies). Local-only; the vault is valid without it.
+vault/.obsidian/

{scriptoria-0.4.0 → scriptoria-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptoria
-Version: 0.4.0
+Version: 0.5.1
 Summary: Deterministic scriptorium-keeper (the `scrip` CLI): staleness, provenance integrity, and fact queries for an agent-compiled knowledge base
 Project-URL: Homepage, https://github.com/coredipper/scriptorium
 Project-URL: Changelog, https://github.com/coredipper/scriptorium/blob/main/CHANGELOG.md

{scriptoria-0.4.0 → scriptoria-0.5.1}/pyproject.toml

@@ -2,7 +2,7 @@
 # Distribution name on PyPI is `scriptoria` (scrip/scriptorium were taken); the
 # CLI command and the import package both remain `scrip`.
 name = "scriptoria"
-version = "0.4.0"
+version = "0.5.1"
 description = "Deterministic scriptorium-keeper (the `scrip` CLI): staleness, provenance integrity, and fact queries for an agent-compiled knowledge base"
 readme = "README.md"
 requires-python = ">=3.10"

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-__version__ = "0.4.0"
+__version__ = "0.5.1"
 
 # --- canonical vault layout ------------------------------------------------
 # ``root`` is the repo/instance root: the directory containing ``vault/``.

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/anchors.py

@@ -90,6 +90,33 @@ def resolve(source_text: str, anchor: str) -> str:
     return "OK" if matches == 1 else "AMBIGUOUS"
 
 
+def span(source_text: str, anchor: str) -> tuple[str, str | None]:
+    """Return ``(status, cited_text)`` for ``anchor`` in ``source_text``.
+
+    Same verdicts as :func:`resolve`, but also returns the matched span (the
+    normalized cited text) so a caller can *read* what an anchor cites. For
+    ``AMBIGUOUS`` the window nearest the anchor's ``loc`` hint is returned; for
+    ``BROKEN`` the text is ``None``.
+    """
+    a = parse_anchor(anchor)
+    ns = normalize(source_text)
+    n, target, loc = a["len"], a["qh"], a["loc"]
+    length = len(ns)
+    if n <= 0 or n > length:
+        return "BROKEN", None
+    hits = [
+        start
+        for start in range(length - n + 1)
+        if hashlib.sha256(ns[start : start + n].encode("utf-8")).hexdigest() == target
+    ]
+    if not hits:
+        return "BROKEN", None
+    if len(hits) == 1:
+        return "OK", ns[hits[0] : hits[0] + n]
+    nearest = min(hits, key=lambda s: abs(s - loc * length))
+    return "AMBIGUOUS", ns[nearest : nearest + n]
+
+
 # --------------------------------------------------------------------------- #
 # Vault-wide verification
 # --------------------------------------------------------------------------- #
@@ -112,15 +139,16 @@ def source_text(root: Path, source_id: str) -> str:
 
 
 def _iter_footnote_anchors(path: Path) -> Iterator[dict]:
-    for line in path.read_text(encoding="utf-8").splitlines():
-        m = _FOOTNOTE.match(line)
-        if not m:
-            continue
-        target = m.group(2)
-        if "#" not in target:
-            continue
-        source_id, anchor = target.split("#", 1)
-        yield {"fn": m.group(1), "source_id": source_id, "anchor": anchor}
+    with path.open(encoding="utf-8") as f:
+        for line in f:
+            m = _FOOTNOTE.match(line)
+            if not m:
+                continue
+            target = m.group(2)
+            if "#" not in target:
+                continue
+            source_id, anchor = target.split("#", 1)
+            yield {"fn": m.group(1), "source_id": source_id, "anchor": anchor}
 
 
 def verify_vault(root: Path) -> dict:
@@ -152,25 +180,24 @@ def verify_vault(root: Path) -> dict:
     claims_path = facts_dir(root) / "claims.ndjson"
     if claims_path.exists():
         seen: set[str] = set()
-        for lineno, raw_line in enumerate(
-            claims_path.read_text(encoding="utf-8").splitlines(), start=1
-        ):
-            line = raw_line.strip()
-            if not line:
-                continue
-            try:
-                rec = json.loads(line)
-            except json.JSONDecodeError as e:
-                raise DataError(f"claims.ndjson:{lineno}: invalid JSON: {e}") from e
-            for key in ("claim_id", "source_id", "anchor"):
-                if key not in rec:
-                    raise DataError(f"claims.ndjson:{lineno}: missing '{key}'")
-            cid = rec["claim_id"]
-            if cid in seen:
-                raise DataError(f"duplicate claim_id: {cid}")
-            seen.add(cid)
-            text = _source_text(root, rec["source_id"], src_cache)
-            record(f"claim:{cid}", rec, resolve(text, rec["anchor"]))
+        with claims_path.open(encoding="utf-8") as f:
+            for lineno, raw_line in enumerate(f, start=1):
+                line = raw_line.strip()
+                if not line:
+                    continue
+                try:
+                    rec = json.loads(line)
+                except json.JSONDecodeError as e:
+                    raise DataError(f"claims.ndjson:{lineno}: invalid JSON: {e}") from e
+                for key in ("claim_id", "source_id", "anchor"):
+                    if key not in rec:
+                        raise DataError(f"claims.ndjson:{lineno}: missing '{key}'")
+                cid = rec["claim_id"]
+                if cid in seen:
+                    raise DataError(f"duplicate claim_id: {cid}")
+                seen.add(cid)
+                text = _source_text(root, rec["source_id"], src_cache)
+                record(f"claim:{cid}", rec, resolve(text, rec["anchor"]))
 
     wd = wiki_dir(root)
     if wd.is_dir():

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/cli.py

@@ -352,6 +352,31 @@ def _parse_source_ids(raw: str) -> list[str]:
     return ids
 
 
+def cmd_span(args: argparse.Namespace) -> int:
+    from . import anchors
+
+    root = resolve_root(args.root)
+    if args.claim:
+        from . import facts
+
+        source_id, anchor = facts.claim_source_anchor(root, args.claim)
+    else:
+        if "#" not in args.target:
+            raise errors.UsageError("target must be raw/<slug>#<anchor>")
+        source_id, anchor = args.target.split("#", 1)
+        source_id = source_id if source_id.startswith("raw/") else f"raw/{source_id}"
+        _safe_slug(source_id[len("raw/") :], "source")
+    text = anchors.source_text(root, source_id)
+    status, cited = anchors.span(text, anchor)
+    if args.json:
+        _emit({"target": f"{source_id}#{anchor}", "status": status, "text": cited})
+    else:
+        print(f"[{status}] {source_id}")
+        if cited is not None:
+            print(cited)
+    return 0 if status == "OK" else 1
+
+
 def cmd_similar(args: argparse.Namespace) -> int:
     from . import similar
 
@@ -388,7 +413,12 @@ def cmd_fact_add(args: argparse.Namespace) -> int:
         _emit(result)
     else:
         for r in result["appended"]:
-            ident = r.get("claim_id") or r.get("entity_id") or f"{r['src']} -> {r['dst']}"
+            ident = (
+                r.get("claim_id")
+                or r.get("entity_id")
+                or r.get("reconciliation_id")
+                or f"{r.get('src')} -> {r.get('dst')}"
+            )
             print(f"  appended {ident}")
         for s in result["skipped"]:
             print(f"  = record {s['index']} skipped (duplicate)")
@@ -517,7 +547,7 @@ def build_parser() -> argparse.ArgumentParser:
     pq.add_argument(
         "name",
         nargs="?",
-        choices=["claims", "entities", "edges", "contradictions"],
+        choices=["claims", "entities", "edges", "contradictions", "reconciliations"],
         help="a named query (omit when using --sql)",
     )
     pq.add_argument("--sql", help="raw DuckDB SQL (views: claims, entities, edges)")
@@ -585,6 +615,16 @@ def build_parser() -> argparse.ArgumentParser:
     pn.add_argument("--title", help="human title (default: the slug)")
     pn.set_defaults(func=cmd_new)
 
+    psp = sub.add_parser(
+        "span",
+        parents=[common],
+        help="resolve an anchor and print the cited text (read both sides of a contradiction)",
+    )
+    span_src = psp.add_mutually_exclusive_group(required=True)
+    span_src.add_argument("target", nargs="?", metavar="raw/<slug>#<anchor>", help="anchor target")
+    span_src.add_argument("--claim", metavar="ID", help="resolve this claim's anchor instead")
+    psp.set_defaults(func=cmd_span)
+
     psim = sub.add_parser(
         "similar",
         parents=[common],
@@ -629,7 +669,7 @@ def build_parser() -> argparse.ArgumentParser:
     )
     pfa.add_argument(
         "--table",
-        choices=["claims", "entities", "edges"],
+        choices=["claims", "entities", "edges", "reconciliations"],
         default="claims",
         help="facts table to append to (default: claims)",
     )

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/facts.py

@@ -36,10 +36,12 @@ _FILES = {
     "claims": "claims.ndjson",
     "entities": "entities.ndjson",
     "edges": "graph.ndjson",
+    "reconciliations": "reconciliations.ndjson",
 }
 
 # Fields scrip mints itself; proposing them is a schema error, not a finding.
 _SCRIP_OWNED = ("claim_id", "anchor", "extracted_at")
+_RECON_OWNED = ("reconciliation_id", "at")
 
 _CLAIM_REQUIRED = ("quote", "source_id", "subject", "predicate", "object", "polarity", "confidence")
 _CLAIM_ALLOWED = frozenset((*_CLAIM_REQUIRED, "claim_text", "tags"))
@@ -47,12 +49,16 @@ _ENTITY_REQUIRED = ("entity_id", "name", "kind")
 _ENTITY_ALLOWED = frozenset((*_ENTITY_REQUIRED, "tags"))
 _EDGE_REQUIRED = ("src", "dst", "kind")
 _EDGE_ALLOWED = frozenset(_EDGE_REQUIRED)
+_DECISIONS = ("supersede", "qualify", "keep-both")
+_RECON_REQUIRED = ("decision", "claim_a", "claim_b")
+_RECON_ALLOWED = frozenset((*_RECON_REQUIRED, "winner", "rationale"))
 
 # Same conservative shape ``cli._safe_slug`` enforces — no path separators,
 # '..', or leading dot — applied to source ids arriving as record *data*.
 _SLUG_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
 
 _CLAIM_ID_RE = re.compile(r"clm_(\d+)")
+_RECON_ID_RE = re.compile(r"rec_(\d+)")
 
 
 def _now() -> str:
@@ -96,12 +102,18 @@ def _check_tags(rec: dict, index: int) -> None:
         raise DataError(f"record {index}: 'tags' must be a list of strings")
 
 
-def _check_shape(rec: dict, index: int, required: tuple[str, ...], allowed: frozenset[str]) -> None:
-    owned = [k for k in _SCRIP_OWNED if k in rec]
-    if owned:
+def _check_shape(
+    rec: dict,
+    index: int,
+    required: tuple[str, ...],
+    allowed: frozenset[str],
+    owned: tuple[str, ...] = _SCRIP_OWNED,
+) -> None:
+    present = [k for k in owned if k in rec]
+    if present:
         raise DataError(
-            f"record {index}: scrip mints {', '.join(owned)} itself — propose a "
-            f"verbatim 'quote', not precomputed ids/anchors/timestamps"
+            f"record {index}: scrip mints {', '.join(present)} itself — do not "
+            f"propose precomputed ids/anchors/timestamps"
         )
     unknown = sorted(rec.keys() - allowed)
     if unknown:
@@ -136,10 +148,27 @@ def _validate(table: str, rec: dict, index: int) -> None:
         if not (eid.startswith("entity/") and _SLUG_RE.fullmatch(eid[len("entity/") :])):
             raise DataError(f"record {index}: entity_id must look like entity/<slug>")
         _check_tags(rec, index)
-    else:  # edges
+    elif table == "edges":
         _check_shape(rec, index, _EDGE_REQUIRED, _EDGE_ALLOWED)
         for key in _EDGE_REQUIRED:
             _check_str(rec, key, index)
+    else:  # reconciliations
+        _check_shape(rec, index, _RECON_REQUIRED, _RECON_ALLOWED, owned=_RECON_OWNED)
+        for key in ("decision", "claim_a", "claim_b"):
+            _check_str(rec, key, index)
+        if rec["decision"] not in _DECISIONS:
+            raise DataError(f"record {index}: decision must be one of {', '.join(_DECISIONS)}")
+        if "rationale" in rec:
+            _check_str(rec, "rationale", index, allow_blank=True)
+        # winner is required for (and only for) supersede, and must be one of the pair
+        if rec["decision"] == "supersede":
+            winner = rec.get("winner")
+            if winner not in (rec["claim_a"], rec["claim_b"]):
+                raise DataError(
+                    f"record {index}: supersede needs 'winner' = claim_a or claim_b"
+                )
+        elif "winner" in rec:
+            raise DataError(f"record {index}: 'winner' is only valid for decision 'supersede'")
 
 
 # --------------------------------------------------------------------------- #
@@ -199,23 +228,48 @@ def _resolve_claim(
 # --------------------------------------------------------------------------- #
 # Existing-table reads & keys
 # --------------------------------------------------------------------------- #
-def _read_table(path: Path) -> tuple[list[dict], str]:
-    """Read an NDJSON table, returning ``(records, raw_text)``. Malformed lines
-    are a :class:`DataError` — the vault on disk violates the contract."""
+def _ends_with_newline(path: Path) -> bool:
+    """Whether the file's final byte is a newline (an empty/absent file counts as
+    terminated, so no separator is prepended before the next append)."""
+    if not path.exists() or path.stat().st_size == 0:
+        return True
+    with path.open("rb") as f:
+        f.seek(-1, 2)
+        return f.read(1) == b"\n"
+
+
+def _read_table(path: Path) -> tuple[list[dict], bool]:
+    """Read an NDJSON table, returning ``(records, ends_with_newline)``. Streams the
+    file line-by-line rather than loading it whole. Malformed lines are a
+    :class:`DataError` — the vault on disk violates the contract."""
     if not path.exists():
-        return [], ""
-    text = path.read_text(encoding="utf-8")
+        return [], True
+    ends_newline = _ends_with_newline(path)
     records: list[dict] = []
-    for lineno, raw_line in enumerate(text.splitlines(), start=1):
-        line = raw_line.strip()
-        if not line:
-            continue
-        try:
-            rec = json.loads(line)
-        except json.JSONDecodeError as e:
-            raise DataError(f"{path.name}:{lineno}: invalid JSON: {e}") from e
-        records.append(rec)
-    return records, text
+    with path.open(encoding="utf-8") as f:
+        for lineno, raw_line in enumerate(f, start=1):
+            line = raw_line.strip()
+            if not line:
+                continue
+            try:
+                rec = json.loads(line)
+            except json.JSONDecodeError as e:
+                raise DataError(f"{path.name}:{lineno}: invalid JSON: {e}") from e
+            records.append(rec)
+    return records, ends_newline
+
+
+def claim_source_anchor(root: Path, claim_id: str) -> tuple[str, str]:
+    """Return ``(source_id, anchor)`` for a claim, for `scrip span --claim`.
+    Raises :class:`DataError` if the claim is missing or lacks the fields."""
+    records, _ = _read_table(facts_dir(root) / "claims.ndjson")
+    for rec in records:
+        if rec.get("claim_id") == claim_id:
+            sid, anchor = rec.get("source_id"), rec.get("anchor")
+            if not isinstance(sid, str) or not isinstance(anchor, str):
+                raise DataError(f"claim {claim_id} is missing source_id/anchor")
+            return sid, anchor
+    raise DataError(f"no such claim: {claim_id}")
 
 
 def _claim_key(source_id: str, qh: str, rec: dict) -> tuple:
@@ -251,6 +305,17 @@ def _next_claim_id(existing: list[dict]) -> tuple[int, int]:
     return highest + 1, max(4, len(str(highest)))
 
 
+def _next_recon_id(existing: list[dict]) -> tuple[int, int]:
+    """Return ``(next_number, pad_width)`` continuing the ``rec_NNNN`` sequence."""
+    numbers = [
+        int(m.group(1))
+        for rec in existing
+        if (m := _RECON_ID_RE.fullmatch(str(rec.get("reconciliation_id", ""))))
+    ]
+    highest = max(numbers, default=0)
+    return highest + 1, max(4, len(str(highest)))
+
+
 # --------------------------------------------------------------------------- #
 # facts/_meta.yaml: merge derived-from, never stamp
 # --------------------------------------------------------------------------- #
@@ -331,7 +396,7 @@ def add(root: Path, table: str, proposals: list[dict]) -> dict:
             if failures:
                 return {"table": table, "appended": [], "skipped": [], "failures": failures}
 
-        existing, existing_text = _read_table(path)
+        existing, ends_with_newline = _read_table(path)
         meta = _load_meta(root)  # parse before appending: fail whole, not half
         appended: list[dict] = []
         skipped: list[dict] = []
@@ -394,7 +459,7 @@ def add(root: Path, table: str, proposals: list[dict]) -> dict:
                             "detail": "an entity with this id already exists with different fields",
                         }
                     )
-        else:  # edges
+        elif table == "edges":
             seen_edges = {
                 (rec.get("src"), rec.get("dst"), rec.get("kind")) for rec in existing
             }
@@ -405,6 +470,43 @@ def add(root: Path, table: str, proposals: list[dict]) -> dict:
                     continue
                 seen_edges.add(key)
                 appended.append({"src": rec["src"], "dst": rec["dst"], "kind": rec["kind"]})
+        else:  # reconciliations
+            claim_ids = {c.get("claim_id") for c in _read_table(facts_dir(root) / "claims.ndjson")[0]}
+            for i, rec in enumerate(proposals):
+                refs = [rec["claim_a"], rec["claim_b"]]
+                if rec["decision"] == "supersede":
+                    refs.append(rec["winner"])
+                missing = next((r for r in refs if r not in claim_ids), None)
+                if missing is not None:
+                    failures.append({
+                        "index": i, "status": "MISSING_CLAIM", "claim": missing,
+                        "detail": f"{missing!r} is not a claim in claims.ndjson",
+                    })
+            if failures:
+                return {"table": table, "appended": [], "skipped": [], "failures": failures}
+            seen_pairs = {frozenset((r.get("claim_a"), r.get("claim_b"))) for r in existing}
+            number, width = _next_recon_id(existing)
+            now = _now()
+            for i, rec in enumerate(proposals):
+                pair = frozenset((rec["claim_a"], rec["claim_b"]))
+                if pair in seen_pairs:
+                    skipped.append({"index": i, "reason": "duplicate", "existing_id": None})
+                    continue
+                seen_pairs.add(pair)
+                rid = f"rec_{number:0{width}d}"
+                number += 1
+                full = {
+                    "reconciliation_id": rid,
+                    "decision": rec["decision"],
+                    "claim_a": rec["claim_a"],
+                    "claim_b": rec["claim_b"],
+                }
+                if rec["decision"] == "supersede":
+                    full["winner"] = rec["winner"]
+                if rec.get("rationale"):
+                    full["rationale"] = rec["rationale"]
+                full["at"] = now
+                appended.append(full)
 
         if failures:
             return {"table": table, "appended": [], "skipped": skipped, "failures": failures}
@@ -413,7 +515,7 @@ def add(root: Path, table: str, proposals: list[dict]) -> dict:
             path.parent.mkdir(parents=True, exist_ok=True)
             payload = "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in appended)
             with open(path, "a", encoding="utf-8") as f:
-                if existing_text and not existing_text.endswith("\n"):
+                if not ends_with_newline:
                     f.write("\n")
                 f.write(payload)
             new_sources: list[str] = []

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/frontmatter.py

@@ -60,3 +60,30 @@ def require(meta: dict, keys: Iterable[str], where: str = "frontmatter") -> None
     missing = [k for k in keys if k not in meta]
     if missing:
         raise DataError(f"{where}: missing required key(s): {', '.join(missing)}")
+
+
+def as_str(meta: dict, key: str, where: str = "frontmatter") -> str | None:
+    """Return ``meta[key]`` as a string, or ``None`` if absent/null. Raise
+    :class:`DataError` (naming ``where``) if present but not a string."""
+    value = meta.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise DataError(
+            f"{where}: '{key}' must be a string, got {type(value).__name__}"
+        )
+    return value
+
+
+def as_str_list(meta: dict, key: str, where: str = "frontmatter") -> list[str]:
+    """Return ``meta[key]`` as a list of strings, or ``[]`` if absent/null. Raise
+    :class:`DataError` (naming ``where``) if present but not a list of strings.
+
+    This is what stops a hand-edited bare string (``derived-from: raw/x``) from
+    silently char-splitting into per-character dependency ids downstream."""
+    value = meta.get(key)
+    if value is None:
+        return []
+    if not isinstance(value, list) or not all(isinstance(x, str) for x in value):
+        raise DataError(f"{where}: '{key}' must be a list of strings")
+    return value

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/graph.py

@@ -80,28 +80,35 @@ def scan_derived(root: Path) -> dict:
             meta, _ = frontmatter.load(path)
             if not meta or "derived-from" not in meta:
                 continue  # index.md, log.md, hand notes: not tracked artifacts
-            did = meta.get("id") or str(path.relative_to(root))
+            where = str(path.relative_to(root))
+            did = frontmatter.as_str(meta, "id", where) or where
             out[did] = {
-                "path": str(path.relative_to(root)),
-                "type": meta.get("type", "wiki"),
-                "derived_from": list(meta.get("derived-from") or []),
-                "input_hash": meta.get("input-hash"),
-                "last_compiled": meta.get("last-compiled"),
+                "path": where,
+                "type": frontmatter.as_str(meta, "type", where) or "wiki",
+                "derived_from": frontmatter.as_str_list(meta, "derived-from", where),
+                "input_hash": frontmatter.as_str(meta, "input-hash", where),
+                "last_compiled": frontmatter.as_str(meta, "last-compiled", where),
             }
     fmeta = facts_dir(root) / "_meta.yaml"
     if fmeta.exists():
         try:
-            data = yaml.safe_load(fmeta.read_text(encoding="utf-8")) or {}
+            data = yaml.safe_load(fmeta.read_text(encoding="utf-8"))
         except yaml.YAMLError as e:
             raise DataError(f"invalid facts/_meta.yaml: {e}") from e
-        if isinstance(data, dict) and "derived-from" in data:
-            did = data.get("id") or "facts/core"
+        if data is None:
+            data = {}  # empty / null file: legitimately "no facts set"
+        elif not isinstance(data, dict):
+            # don't let `or {}` mask falsey non-mappings ([], false, 0, '')
+            raise DataError("facts/_meta.yaml must be a YAML mapping")
+        if "derived-from" in data:
+            where = str(fmeta.relative_to(root))
+            did = frontmatter.as_str(data, "id", where) or "facts/core"
             out[did] = {
-                "path": str(fmeta.relative_to(root)),
-                "type": data.get("type", "facts.set"),
-                "derived_from": list(data.get("derived-from") or []),
-                "input_hash": data.get("input-hash"),
-                "last_compiled": data.get("last-compiled"),
+                "path": where,
+                "type": frontmatter.as_str(data, "type", where) or "facts.set",
+                "derived_from": frontmatter.as_str_list(data, "derived-from", where),
+                "input_hash": frontmatter.as_str(data, "input-hash", where),
+                "last_compiled": frontmatter.as_str(data, "last-compiled", where),
             }
     return out
 
@@ -114,10 +121,10 @@ def _dep_hash(dep_id: str, raw: dict) -> str | None:
         r = raw.get(base)
         if not r:
             return None
-        for b in r["blocks"]:
-            if b["block_id"] == block_id:
-                return b["hash"]
-        return None
+        # ⚡ Bolt: Replace O(n) loop with O(1) hash map lookup for blocks
+        if "_blocks_map" not in r:
+            r["_blocks_map"] = {b["block_id"]: b["hash"] for b in r["blocks"]}
+        return r["_blocks_map"].get(block_id)
     r = raw.get(dep_id)
     return r["content_hash"] if r else None
 

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/hashing.py

@@ -7,13 +7,10 @@ self-describing in the manifest and frontmatter.
 from __future__ import annotations
 
 import hashlib
-import re
 import unicodedata
 from collections.abc import Mapping
 from pathlib import Path
 
-_WS = re.compile(r"\s+")
-
 
 def normalize(text: str) -> str:
     """Canonical text normalization shared by provenance anchors and block ids.
@@ -23,8 +20,8 @@ def normalize(text: str) -> str:
     ``blocks`` import) means anchor identity and block identity can never drift.
     """
     t = unicodedata.normalize("NFC", text)
-    t = _WS.sub(" ", t).strip()
-    return t.lower()
+    # Using split() and join() is significantly faster than regex for whitespace normalization
+    return " ".join(t.split()).lower()
 
 
 def _digest(data: bytes) -> str:

{scriptoria-0.4.0 → scriptoria-0.5.1}/src/scrip/query.py

@@ -22,15 +22,18 @@ _VIEWS = {
     "claims": "claims.ndjson",
     "entities": "entities.ndjson",
     "edges": "graph.ndjson",
+    "reconciliations": "reconciliations.ndjson",
 }
 
 _NAMED = {
     "claims": "SELECT * FROM claims",
     "entities": "SELECT * FROM entities",
     "edges": "SELECT * FROM edges",
+    "reconciliations": "SELECT * FROM reconciliations",
     # contradiction *candidates*: same subject+predicate, opposing polarity,
-    # from different sources. Detection is deterministic; adjudication is the
-    # agent's job.
+    # from different sources, AND not yet adjudicated (no reconciliation record
+    # for the pair, either order) — so RECONCILE makes the set converge.
+    # Detection is deterministic; adjudication is the agent's job.
     "contradictions": """
         SELECT a.claim_id AS claim_a, b.claim_id AS claim_b,
                a.subject, a.predicate,
@@ -41,10 +44,15 @@ _NAMED = {
         WHERE a.polarity = 'asserts'
           AND b.polarity = 'denies'
           AND a.source_id <> b.source_id
+          AND NOT EXISTS (
+            SELECT 1 FROM reconciliations r
+            WHERE (r.claim_a = a.claim_id AND r.claim_b = b.claim_id)
+               OR (r.claim_a = b.claim_id AND r.claim_b = a.claim_id)
+          )
     """,
 }
 
-_FILTERABLE = {"claims", "entities", "edges"}
+_FILTERABLE = {"claims", "entities", "edges", "reconciliations"}
 
 
 def _connect(root: Path) -> duckdb.DuckDBPyConnection:
@@ -57,6 +65,16 @@ def _connect(root: Path) -> duckdb.DuckDBPyConnection:
                 f"CREATE VIEW {view} AS "
                 f"SELECT * FROM read_ndjson_auto('{p.as_posix()}')"
             )
+        elif view == "reconciliations":
+            # Always present (empty stub) so `contradictions` can anti-join it and
+            # raw SQL over its columns works even before any reconciliation exists.
+            con.execute(
+                "CREATE VIEW reconciliations AS SELECT "
+                "NULL::VARCHAR AS reconciliation_id, NULL::VARCHAR AS decision, "
+                "NULL::VARCHAR AS claim_a, NULL::VARCHAR AS claim_b, "
+                "NULL::VARCHAR AS winner, NULL::VARCHAR AS rationale, "
+                "NULL::VARCHAR AS at WHERE FALSE"
+            )
     return con