fathom-read 0.1.0__py3-none-any.whl

fathom_read/__init__.py

@@ -0,0 +1,17 @@
+"""fathom-read: catch the step where an AI agent contradicts a decision it already made."""
+from .ops import Op, Finding, Verdict  # noqa: F401
+from .client import read, ReadError  # noqa: F401
+
+__version__ = "0.1.0"
+__all__ = ["Op", "Finding", "Verdict", "read", "ReadError", "read_file", "load_ops"]
+
+
+def load_ops(path: str, fmt: str = "auto", mapping_path: str = None):
+    """Turn a trace file in any supported format into the op stream."""
+    from .cli import load_ops as _load
+    return _load(path, fmt, mapping_path)
+
+
+def read_file(path: str, fmt: str = "auto", supersede=None, mapping_path: str = None, **kw) -> Verdict:
+    """Read a trace file and return the hosted read's verdict."""
+    return read(load_ops(path, fmt, mapping_path), supersede=supersede, **kw)

fathom_read/adapters/__init__.py

@@ -0,0 +1,47 @@
+"""Adapters turn what a framework already records into the op stream the read consumes."""
+from . import events, edits, openinference, langgraph, crewai, letta, dbos  # noqa: F401
+
+FORMATS = {
+    "events": events,
+    "edits": edits,
+    "openinference": openinference,
+    "langgraph": langgraph,
+    "crewai": crewai,
+    "letta": letta,
+    "dbos": dbos,
+}
+
+
+def detect(doc) -> str:
+    """Guess the format of a loaded JSON document."""
+    if isinstance(doc, dict):
+        if "ops" in doc:
+            return "events"
+        if "spans" in doc or "resourceSpans" in doc:
+            return "openinference"
+        if "edits" in doc or "initial_files" in doc:
+            return "edits"
+        if "blocks" in doc or "passages" in doc:
+            return "letta"
+        if "steps" in doc and "workflow_id" in doc:
+            return "dbos"
+        if "events" in doc:
+            return "crewai"
+        if "snapshots" in doc or "history" in doc:
+            return "langgraph"
+    if isinstance(doc, list) and doc:
+        first = doc[0]
+        if isinstance(first, dict):
+            if "op" in first and "key" in first:
+                return "events"
+            if "attributes" in first or "span_kind" in first:
+                return "openinference"
+            if "values" in first and ("next" in first or "config" in first or "metadata" in first or "step" in first):
+                return "langgraph"
+            if "type" in first and ("tool_name" in first or "task_name" in first or first.get("type", "").startswith(("tool_", "task_"))):
+                return "crewai"
+            if "step_name" in first:
+                return "dbos"
+            if "tool" in first and "args" in first:
+                return "edits"
+    raise ValueError("could not detect the trace format; pass --format")

fathom_read/adapters/_tools.py

@@ -0,0 +1,88 @@
+"""Shared mapping from tool calls to ops. Adapters that see (tool name, args, result, ok) use this."""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Optional
+
+from ..ops import Op
+
+# Default mapping: tool name -> how to build an op from its arguments.
+# "key" and "value" name the argument fields; "kind" labels the fact; "op" is the ledger op.
+DEFAULT_MAP: Dict[str, Dict[str, Any]] = {
+    # coding agents (OpenHands, CodeAct-style editors); content folding lives in the edits adapter
+    "str_replace_editor": {"op": "edit"},
+    "edit_file": {"op": "edit"},
+    "write_file": {"op": "set", "kind": "file", "key": "path", "value": "content"},
+    "create_file": {"op": "set", "kind": "file", "key": "path", "value": "content"},
+    "delete_file": {"op": "remove", "kind": "file", "key": "path"},
+    # record-keeping crews and workflows
+    "write_record": {"op": "set", "kind": "record", "key": "record", "value": "content"},
+    "update_record": {"op": "set", "kind": "record", "key": "record", "value": "content"},
+    "commit_record": {"op": "set", "kind": "record", "key": "record", "value": "content"},
+    "set_value": {"op": "set", "kind": "fact", "key": "key", "value": "value"},
+    "update_value": {"op": "set", "kind": "fact", "key": "key", "value": "value"},
+    "delete_value": {"op": "remove", "kind": "fact", "key": "key"},
+    "rename_key": {"op": "rename", "kind": "fact", "key": "old", "to": "new"},
+    # Letta memory tools
+    "core_memory_append": {"op": "append", "kind": "block", "key": "label", "value": "content"},
+    "core_memory_replace": {"op": "set", "kind": "block", "key": "label", "value": "new_content"},
+    "memory_replace": {"op": "set", "kind": "block", "key": "label", "value": "new_str"},
+    "memory_insert": {"op": "append", "kind": "block", "key": "label", "value": "new_str"},
+    "memory_rethink": {"op": "set", "kind": "block", "key": "label", "value": "new_memory"},
+    "archival_memory_insert": {"op": "add", "kind": "passage", "key": "archival", "value": "content"},
+    # ordering and transactions (web agents, customer-service agents)
+    "add_item": {"op": "add", "kind": "order", "key": "cart", "value": "item"},
+    "add_to_cart": {"op": "add", "kind": "order", "key": "cart", "value": "item"},
+    "remove_item": {"op": "remove_member", "kind": "order", "key": "cart", "value": "item"},
+    "place_order": {"op": "commit", "kind": "order", "key": "order"},
+    "checkout": {"op": "commit", "kind": "order", "key": "order"},
+    "submit": {"op": "commit", "kind": "order", "key": "order"},
+    "book_reservation": {"op": "set", "kind": "reservation", "key": "reservation_id", "value": "details"},
+    "cancel_reservation": {"op": "remove", "kind": "reservation", "key": "reservation_id"},
+}
+
+
+def _first(args: Dict[str, Any], *names: str) -> Optional[str]:
+    for n in names:
+        if n in args and args[n] is not None:
+            v = args[n]
+            return v if isinstance(v, str) else json.dumps(v, sort_keys=True)
+    return None
+
+
+def load_map(path: Optional[str]) -> Dict[str, Dict[str, Any]]:
+    m = dict(DEFAULT_MAP)
+    if path:
+        with open(path) as f:
+            m.update(json.load(f))
+    return m
+
+
+def op_from_tool(name: str, args: Any, ok: bool, step: int, mapping: Dict[str, Dict[str, Any]],
+                 source: str = "") -> Optional[Op]:
+    """Build an op from one tool call, or None when the tool does not write committed state."""
+    name = (name or "").strip().lower().replace(" ", "_")
+    spec = mapping.get(name)
+    if spec is None:
+        return None
+    if not isinstance(args, dict):
+        try:
+            args = json.loads(args) if args else {}
+        except (TypeError, ValueError):
+            args = {}
+    kind = spec.get("kind", "fact")
+    op = spec["op"]
+    key = _first(args, spec.get("key", "key"), "key", "record", "path", "label", "name", "id") or spec.get("key", name)
+    value = _first(args, spec.get("value", "value"), "value", "content", "new_str", "new_content", "text")
+    if op == "edit":
+        return None  # the edits adapter folds these with file contents
+    if op == "append":
+        return Op("set", kind, key, value=value, ok=ok, step=step, source=source or name)
+    if op == "remove_member":
+        return Op("remove", kind, f"{key}:{value}", ok=ok, step=step, source=source or name)
+    if op == "rename":
+        to = _first(args, spec.get("to", "new"), "new", "to")
+        return Op("rename", kind, key, to=to, ok=ok, step=step, source=source or name)
+    if op == "commit":
+        return Op("commit", kind, key, ok=ok, step=step, source=source or name)
+    return Op(op, kind, key, value=value, ok=ok, step=step, source=source or name)

fathom_read/adapters/crewai.py

@@ -0,0 +1,34 @@
+"""
+CrewAI event logs: the events the crew's event bus already emits.
+
+Input: a list of events (or {"events": [...]}) with "type" in tool_usage_finished,
+tool_usage_error, task_completed; tool events carry tool_name and tool_args. A write tool's
+arguments name the record and the content committed to it; a task_completed event commits
+the task's output under the task name. Capture them with a listener on crewai's event bus.
+"""
+from __future__ import annotations
+
+from typing import Any, List
+
+from ..ops import Op
+from ._tools import op_from_tool, load_map
+
+
+def load(doc: Any, mapping_path: str = None, **_) -> List[Op]:
+    events = doc.get("events", []) if isinstance(doc, dict) else doc
+    mapping = load_map(mapping_path)
+    ops: List[Op] = []
+    for i, ev in enumerate(events):
+        t = (ev.get("type") or ev.get("_type") or "").replace("Event", "").lower()
+        t = {"toolusagefinished": "tool_usage_finished", "toolusageerror": "tool_usage_error",
+             "taskcompleted": "task_completed"}.get(t, t)
+        if t in ("tool_usage_finished", "tool_usage_error"):
+            ok = t == "tool_usage_finished" and not bool(ev.get("failure"))
+            op = op_from_tool(ev.get("tool_name", ""), ev.get("tool_args"), ok, i, mapping, source=t)
+            if op is not None:
+                ops.append(op)
+        elif t == "task_completed":
+            name = ev.get("task_name") or ev.get("task") or f"task_{i}"
+            out = ev.get("output") or ev.get("raw") or ""
+            ops.append(Op("set", "task", str(name), value=str(out), ok=True, step=i, source="task_completed"))
+    return ops

fathom_read/adapters/dbos.py

@@ -0,0 +1,25 @@
+"""
+DBOS step streams: the inputs and outputs of each step in a workflow, in order.
+
+Input: {"workflow_id": "...", "steps": [{"step_name", "args", "result", "ok"}]} or a bare list.
+Step names map to ops through the tool mapping (pass --map for your own step names).
+"""
+from __future__ import annotations
+
+from typing import Any, List
+
+from ..ops import Op
+from ._tools import op_from_tool, load_map
+
+
+def load(doc: Any, mapping_path: str = None, **_) -> List[Op]:
+    steps = doc.get("steps", []) if isinstance(doc, dict) else doc
+    mapping = load_map(mapping_path)
+    ops: List[Op] = []
+    for i, s in enumerate(steps):
+        ok = bool(s.get("ok", True)) and not bool(s.get("error"))
+        args = s.get("args") or s.get("inputs") or {}
+        op = op_from_tool(s.get("step_name") or s.get("name", ""), args, ok, i, mapping, source="step")
+        if op is not None:
+            ops.append(op)
+    return ops

fathom_read/adapters/edits.py

@@ -0,0 +1,51 @@
+"""
+Coding-agent edit logs: str_replace-style edits over a set of files.
+
+Input: {"initial_files": {path: content}, "edits": [{"tool": "str_replace_editor",
+        "args": {"path", "old_str", "new_str"}, "ok": true}, ...], "done": true}
+or a bare list of edit records. The adapter folds each successful edit onto the file it
+targets and emits one "set" op per edit with the file's new content, so the read can see what
+the agent actually left in each file. A rejected edit changes nothing.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ..ops import Op
+
+EDIT_TOOLS = {"str_replace_editor", "edit_file", "str_replace", "apply_patch"}
+
+
+def load(doc: Any, **_) -> List[Op]:
+    if isinstance(doc, list):
+        doc = {"edits": doc}
+    files: Dict[str, str] = dict(doc.get("initial_files", {}))
+    ops: List[Op] = []
+    step = 0
+    for path, content in files.items():
+        ops.append(Op("set", "file", path, value=content, ok=True, step=step, source="initial"))
+        step += 1
+    for e in doc.get("edits", []):
+        tool = (e.get("tool") or e.get("name") or "").strip().lower()
+        args = e.get("args") or e.get("parameters") or {}
+        ok = bool(e.get("ok", True)) and not bool(e.get("error"))
+        if tool in EDIT_TOOLS:
+            path, old, new = args.get("path"), args.get("old_str"), args.get("new_str")
+            applied = False
+            if ok and path in files and old and old in files[path]:
+                files[path] = files[path].replace(old, new or "")
+                applied = True
+            ops.append(Op("set", "file", str(path), value=files.get(str(path)), ok=applied, step=step, source=tool))
+        elif tool in ("write_file", "create_file"):
+            if ok:
+                files[str(args.get("path"))] = str(args.get("content", ""))
+            ops.append(Op("set", "file", str(args.get("path")), value=str(args.get("content", "")), ok=ok, step=step, source=tool))
+        elif tool in ("delete_file",):
+            if ok:
+                files.pop(str(args.get("path")), None)
+            ops.append(Op("remove", "file", str(args.get("path")), ok=ok, step=step, source=tool))
+        else:
+            step += 1
+            continue
+        step += 1
+    return ops

fathom_read/adapters/events.py

@@ -0,0 +1,17 @@
+"""Native format: a JSON list (or {"ops": [...]}) of op dicts, or JSON Lines with one op per line."""
+from __future__ import annotations
+
+import json
+from typing import Any, List
+
+from ..ops import Op
+
+
+def load(doc: Any, **_) -> List[Op]:
+    if isinstance(doc, dict):
+        doc = doc.get("ops", [])
+    return [Op.from_dict(d) for d in doc]
+
+
+def load_jsonl(text: str) -> List[Op]:
+    return [Op.from_dict(json.loads(line)) for line in text.splitlines() if line.strip()]

fathom_read/adapters/langgraph.py

@@ -0,0 +1,56 @@
+"""
+LangGraph state history: the checkpoint lineage from graph.get_state_history(config).
+
+Input: a list of snapshots, each with "values" (the channel values at that step), newest
+first as LangGraph returns them, or {"snapshots": [...]}. The adapter diffs consecutive
+snapshots and emits one op per changed channel: a scalar or string channel that changed is a
+"set"; a list channel that grew is an "add" per new element. Every checkpoint is a
+successful commit, so ok is always true here; the read then checks what those commits say
+against one another.
+
+To export from a running graph:
+    import json
+    history = [{"values": s.values, "step": s.metadata.get("step")} for s in graph.get_state_history(config)]
+    json.dump(history, open("history.json", "w"), default=str)
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, List
+
+from ..ops import Op
+
+
+def _as_text(v: Any) -> str:
+    return v if isinstance(v, str) else json.dumps(v, sort_keys=True, default=str)
+
+
+def load(doc: Any, **_) -> List[Op]:
+    snaps = doc.get("snapshots", doc.get("history", [])) if isinstance(doc, dict) else doc
+    snaps = list(snaps)
+    if len(snaps) > 1:
+        # get_state_history returns newest first; put them in run order.
+        s0 = snaps[0].get("step", snaps[0].get("metadata", {}).get("step"))
+        s1 = snaps[-1].get("step", snaps[-1].get("metadata", {}).get("step"))
+        if s0 is None or s1 is None or s0 > s1:
+            snaps = snaps[::-1]
+    ops: List[Op] = []
+    prev: dict = {}
+    step = 0
+    for snap in snaps:
+        values = snap.get("values", {}) or {}
+        for chan, val in values.items():
+            old = prev.get(chan)
+            if isinstance(val, list) and isinstance(old, list) and len(val) >= len(old) and val[:len(old)] == old:
+                for item in val[len(old):]:
+                    ops.append(Op("add", "channel", chan, value=_as_text(item), step=step, source="checkpoint"))
+                    step += 1
+            elif isinstance(val, list) and old is None:
+                for item in val:
+                    ops.append(Op("add", "channel", chan, value=_as_text(item), step=step, source="checkpoint"))
+                    step += 1
+            elif val != old:
+                ops.append(Op("set", "channel", chan, value=_as_text(val), step=step, source="checkpoint"))
+                step += 1
+        prev = values
+    return ops

fathom_read/adapters/letta.py

@@ -0,0 +1,32 @@
+"""
+Letta (MemGPT) memory: the blocks and passages the agent persists, and the edit calls that produced them.
+
+Input: {"blocks": [{"label", "value"}], "passages": [{"text"}], "tool_calls": [{"name", "args", "ok"}]}.
+Blocks and passages give the final committed memory; tool_calls give the stream. Export with
+agents.blocks.list, agents.passages.list, and the tool_call messages from agents.messages.list.
+"""
+from __future__ import annotations
+
+from typing import Any, List
+
+from ..ops import Op
+from ._tools import op_from_tool, load_map
+
+
+def load(doc: Any, mapping_path: str = None, **_) -> List[Op]:
+    mapping = load_map(mapping_path)
+    ops: List[Op] = []
+    step = 0
+    for tc in doc.get("tool_calls", []) or []:
+        op = op_from_tool(tc.get("name", ""), tc.get("args"), bool(tc.get("ok", True)), step, mapping, source="tool_call")
+        if op is not None:
+            ops.append(op)
+            step += 1
+    # The persisted memory at the end of the run, as the final committed values.
+    for b in doc.get("blocks", []) or []:
+        ops.append(Op("set", "block", str(b.get("label", "block")), value=str(b.get("value", "")), step=step, source="persisted"))
+        step += 1
+    for i, p in enumerate(doc.get("passages", []) or []):
+        ops.append(Op("set", "passage", str(p.get("id", i)), value=str(p.get("text", "")), step=step, source="persisted"))
+        step += 1
+    return ops

fathom_read/adapters/openinference.py

@@ -0,0 +1,66 @@
+"""
+OpenInference traces, the span format Arize Phoenix stores.
+
+Input: a list of spans, each with an "attributes" dict carrying openinference.span.kind,
+tool.name, tool.parameters, and output.value; or {"spans": [...]}. Only TOOL spans matter.
+Edit tools fold through the edits adapter when the document carries "initial_files".
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List
+
+from ..ops import Op
+from . import edits as _edits
+from ._tools import op_from_tool, load_map
+
+KIND = "openinference.span.kind"
+TOOL_NAME = "tool.name"
+TOOL_PARAMS = "tool.parameters"
+OUTPUT = "output.value"
+
+
+def _parse(v, default=None):
+    if v is None:
+        return default
+    if isinstance(v, (dict, list)):
+        return v
+    try:
+        return json.loads(v)
+    except (TypeError, ValueError):
+        return default
+
+
+def load(doc: Any, mapping_path: str = None, **_) -> List[Op]:
+    spans = doc.get("spans", []) if isinstance(doc, dict) else doc
+    initial_files = doc.get("initial_files") if isinstance(doc, dict) else None
+    mapping = load_map(mapping_path)
+    tool_spans: List[Dict[str, Any]] = []
+    for sp in spans:
+        a = sp.get("attributes", sp)
+        if str(a.get(KIND, "")).upper() == "TOOL":
+            tool_spans.append(a)
+    tool_spans.sort(key=lambda a: a.get("start_time", a.get("start", 0)) or 0)
+
+    edit_records = []
+    ops: List[Op] = []
+    for i, a in enumerate(tool_spans):
+        name = a.get(TOOL_NAME, "")
+        params = _parse(a.get(TOOL_PARAMS), {}) or {}
+        ret = _parse(a.get(OUTPUT), {})
+        ok = True
+        if isinstance(ret, dict) and "success" in ret:
+            ok = bool(ret["success"])
+        elif isinstance(ret, dict) and ret.get("error"):
+            ok = False
+        elif isinstance(ret, str) and ret.lower().startswith("error"):
+            ok = False
+        if str(name).strip().lower() in _edits.EDIT_TOOLS:
+            edit_records.append({"tool": name, "args": params, "ok": ok})
+            continue
+        op = op_from_tool(name, params, ok, i, mapping, source="span")
+        if op is not None:
+            ops.append(op)
+    if edit_records:
+        ops = _edits.load({"initial_files": initial_files or {}, "edits": edit_records}) + ops
+    return ops

fathom_read/cli.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import List, Optional, Tuple
+
+from . import adapters
+from .client import DEMO_KEY, ReadError, read
+from .ops import Op, Verdict
+
+EXAMPLES = os.path.join(os.path.dirname(__file__), "examples")
+
+
+def load_ops(path: str, fmt: str = "auto", mapping_path: Optional[str] = None) -> List[Op]:
+    with open(path) as f:
+        text = f.read()
+    if path.endswith(".jsonl"):
+        return adapters.events.load_jsonl(text)
+    doc = json.loads(text)
+    if fmt == "auto":
+        fmt = adapters.detect(doc)
+    if fmt not in adapters.FORMATS:
+        raise SystemExit(f"unknown format {fmt!r}; run `fathom formats`")
+    return adapters.FORMATS[fmt].load(doc, mapping_path=mapping_path)
+
+
+def parse_supersede(items: Optional[List[str]]) -> List[Tuple[str, str]]:
+    out = []
+    for it in items or []:
+        if "=" not in it:
+            raise SystemExit(f"--supersede expects old=new, got {it!r}")
+        old, new = it.split("=", 1)
+        out.append((old.strip(), new.strip()))
+    return out
+
+
+def render(verdict: Verdict, title: str = "") -> str:
+    lines = []
+    if title:
+        lines.append(title)
+    lines.append(f"ops read: {verdict.ops_read}   rejected (no-ops): {verdict.ops_rejected}   live facts: {verdict.live_facts}")
+    if verdict.coherent:
+        lines.append("committed state: coherent. No action contradicted an earlier commitment.")
+        return "\n".join(lines)
+    lines.append(f"committed state: {len(verdict.findings)} finding{'s' if len(verdict.findings) != 1 else ''}")
+    for f in verdict.findings:
+        where = f"step {f.step}" if f.step is not None else "end of run"
+        cite = f" (cites step {f.cites})" if f.cites is not None else ""
+        lines.append(f"  [{f.kind}] {where}{cite}: {f.detail}")
+    return "\n".join(lines)
+
+
+def _read(ops, supersede, args) -> Verdict:
+    try:
+        return read(ops, supersede=supersede, key=args.key, endpoint=args.endpoint)
+    except ReadError as e:
+        raise SystemExit(f"fathom: {e}")
+
+
+def cmd_read(args) -> int:
+    ops = load_ops(args.path, args.format, args.map)
+    if args.ops:
+        print(json.dumps([o.as_dict() for o in ops], indent=2))
+        return 0
+    v = _read(ops, parse_supersede(args.supersede), args)
+    if args.json:
+        print(json.dumps(v.as_dict(), indent=2))
+    else:
+        print(render(v, os.path.basename(args.path)))
+    return 0 if v.coherent else 2
+
+
+def cmd_demo(args) -> int:
+    print("fathom demo: a coding agent renames guest_id to customer_id across five files, then runs the tests.\n")
+    for name in ("rename_coherent.json", "rename_starved.json"):
+        ops = load_ops(os.path.join(EXAMPLES, name), "edits")
+        v = _read(ops, [("guest_id", "customer_id")], args)
+        print(render(v, f"== {name}"))
+        print()
+    print("Both runs reported success and a green test suite. Only one of them renamed the field.")
+    print("Try it on your own trace:  fathom read path/to/trace.json --supersede old=new")
+    return 0
+
+
+def cmd_formats(args) -> int:
+    for name, mod in adapters.FORMATS.items():
+        doc = (mod.__doc__ or "").strip().splitlines()[0] if mod.__doc__ else ""
+        print(f"{name:14s} {doc}")
+    return 0
+
+
+def _common(p):
+    p.add_argument("--key", help="your read key (or set FATHOM_API_KEY); the demo key is rate-limited")
+    p.add_argument("--endpoint", help=argparse.SUPPRESS)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    p = argparse.ArgumentParser(prog="fathom", description="Catch the step where an AI agent contradicts a decision it already made.")
+    sub = p.add_subparsers(dest="cmd")
+
+    r = sub.add_parser("read", help="read a trace and report contradictions of committed state")
+    r.add_argument("path", help="trace file (.json or .jsonl)")
+    r.add_argument("--format", default="auto", help="events | edits | openinference | langgraph | crewai | letta | dbos (default: auto)")
+    r.add_argument("--supersede", action="append", metavar="OLD=NEW", help="a token the run should have replaced, e.g. guest_id=customer_id (repeatable)")
+    r.add_argument("--map", help="JSON file mapping your tool or step names to ops")
+    r.add_argument("--json", action="store_true", help="print the verdict as JSON")
+    r.add_argument("--ops", action="store_true", help="print the op stream the adapter produced and stop (nothing is sent)")
+    _common(r)
+    r.set_defaults(fn=cmd_read)
+
+    d = sub.add_parser("demo", help="run the bundled rename example, coherent and not")
+    _common(d)
+    d.set_defaults(fn=cmd_demo)
+
+    f = sub.add_parser("formats", help="list the trace formats the adapters accept")
+    f.set_defaults(fn=cmd_formats)
+
+    args = p.parse_args(argv)
+    if not args.cmd:
+        p.print_help()
+        return 1
+    return args.fn(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fathom_read/client.py

@@ -0,0 +1,40 @@
+"""The hosted read. The client sends an op stream and gets a verdict back."""
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Iterable, List, Optional, Tuple
+
+from .ops import Op, Verdict
+
+DEFAULT_ENDPOINT = "https://read.embeddedriskanalytics.com/v1/read"
+DEMO_KEY = "demo"  # rate-limited; get your own key at https://embeddedriskanalytics.com/contact.html
+
+
+class ReadError(RuntimeError):
+    pass
+
+
+def read(ops: Iterable[Op], supersede: Optional[List[Tuple[str, str]]] = None,
+         key: Optional[str] = None, endpoint: Optional[str] = None, timeout: float = 30.0) -> Verdict:
+    """Send the ops to the hosted read and return its verdict."""
+    key = key or os.environ.get("FATHOM_API_KEY") or DEMO_KEY
+    endpoint = endpoint or os.environ.get("FATHOM_ENDPOINT") or DEFAULT_ENDPOINT
+    body = json.dumps({"ops": [o.as_dict() for o in ops], "supersede": [list(p) for p in (supersede or [])]}).encode()
+    req = urllib.request.Request(endpoint, data=body, method="POST", headers={
+        "Content-Type": "application/json", "Authorization": f"Bearer {key}",
+        "User-Agent": "fathom-read/0.1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            return Verdict.from_dict(json.loads(r.read().decode()))
+    except urllib.error.HTTPError as e:
+        msg = e.read().decode(errors="replace")
+        if e.code == 401:
+            raise ReadError("the read rejected the key; set FATHOM_API_KEY or request one at https://embeddedriskanalytics.com/contact.html") from None
+        if e.code == 429:
+            raise ReadError("the demo key is rate-limited; request your own at https://embeddedriskanalytics.com/contact.html") from None
+        raise ReadError(f"the read returned {e.code}: {msg[:200]}") from None
+    except urllib.error.URLError as e:
+        raise ReadError(f"could not reach the read at {endpoint}: {e.reason}") from None

fathom_read/examples/crewai_events.json

@@ -0,0 +1,31 @@
+[
+ {
+  "type": "tool_usage_finished",
+  "tool_name": "write_record",
+  "tool_args": {
+   "record": "r0",
+   "content": "customer_id: 100"
+  }
+ },
+ {
+  "type": "tool_usage_finished",
+  "tool_name": "write_record",
+  "tool_args": {
+   "record": "r1",
+   "content": "customer_id: 101"
+  }
+ },
+ {
+  "type": "tool_usage_finished",
+  "tool_name": "write_record",
+  "tool_args": {
+   "record": "r2",
+   "content": "guest_id: 102"
+  }
+ },
+ {
+  "type": "task_completed",
+  "task_name": "rename",
+  "output": "All records renamed to customer_id."
+ }
+]

fathom_read/examples/knowledge_update.json

@@ -0,0 +1,26 @@
+[
+ {
+  "op": "set",
+  "kind": "fact",
+  "key": "user.city",
+  "value": "Denver"
+ },
+ {
+  "op": "set",
+  "kind": "fact",
+  "key": "user.city",
+  "value": "Austin"
+ },
+ {
+  "op": "set",
+  "kind": "fact",
+  "key": "user.role",
+  "value": "engineer"
+ },
+ {
+  "op": "answer",
+  "kind": "fact",
+  "key": "user.city",
+  "value": "The user lives in Denver."
+ }
+]

fathom_read/examples/langgraph_history.json

@@ -0,0 +1,37 @@
+[
+ {
+  "step": 2,
+  "values": {
+   "definition": "customer_id",
+   "records": [
+    {
+     "id": "a",
+     "cites": "customer_id"
+    },
+    {
+     "id": "b",
+     "cites": "guest_id"
+    }
+   ]
+  }
+ },
+ {
+  "step": 1,
+  "values": {
+   "definition": "customer_id",
+   "records": [
+    {
+     "id": "a",
+     "cites": "customer_id"
+    }
+   ]
+  }
+ },
+ {
+  "step": 0,
+  "values": {
+   "definition": "guest_id",
+   "records": []
+  }
+ }
+]

fathom_read/examples/order_duplicate.json

@@ -0,0 +1,31 @@
+[
+ {
+  "op": "add",
+  "kind": "order",
+  "key": "cart",
+  "value": "lamp"
+ },
+ {
+  "op": "add",
+  "kind": "order",
+  "key": "cart",
+  "value": "chair"
+ },
+ {
+  "op": "add",
+  "kind": "order",
+  "key": "cart",
+  "value": "lamp"
+ },
+ {
+  "op": "commit",
+  "kind": "order",
+  "key": "order"
+ },
+ {
+  "op": "add",
+  "kind": "order",
+  "key": "cart",
+  "value": "table"
+ }
+]

fathom_read/examples/rename_coherent.json

@@ -0,0 +1,63 @@
+{
+ "initial_files": {
+  "schema.py": "class Guest:\n    guest_id: int\n    name: str\n",
+  "models.py": "from schema import Guest\n\ndef load(guest_id):\n    return Guest(guest_id=guest_id, name='x')\n",
+  "handler.py": "from models import load\n\ndef get(req):\n    return load(req['guest_id'])\n",
+  "report.py": "def summarize(g):\n    return f\"guest {g.guest_id}\"\n",
+  "test_app.py": "from handler import get\n\ndef test_get():\n    assert get({'guest_id': 1}).guest_id == 1\n"
+ },
+ "edits": [
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "schema.py",
+    "old_str": "guest_id: int",
+    "new_str": "customer_id: int"
+   },
+   "ok": true
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "models.py",
+    "old_str": "def load(guest_id):\n    return Guest(guest_id=guest_id, name='x')",
+    "new_str": "def load(customer_id):\n    return Guest(customer_id=customer_id, name='x')"
+   },
+   "ok": true
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "handler.py",
+    "old_str": "req['guest_id']",
+    "new_str": "req['customer_id']"
+   },
+   "ok": true
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "report.py",
+    "old_str": "guest {g.guest_id}",
+    "new_str": "customer {g.customer_id}"
+   },
+   "ok": true
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "test_app.py",
+    "old_str": "get({'guest_id': 1}).guest_id",
+    "new_str": "get({'customer_id': 1}).customer_id"
+   },
+   "ok": true
+  },
+  {
+   "tool": "run_tests",
+   "args": {},
+   "ok": true,
+   "result": "5 passed"
+  }
+ ],
+ "done": true
+}

fathom_read/examples/rename_starved.json

@@ -0,0 +1,63 @@
+{
+ "initial_files": {
+  "schema.py": "class Guest:\n    guest_id: int\n    name: str\n",
+  "models.py": "from schema import Guest\n\ndef load(guest_id):\n    return Guest(guest_id=guest_id, name='x')\n",
+  "handler.py": "from models import load\n\ndef get(req):\n    return load(req['guest_id'])\n",
+  "report.py": "def summarize(g):\n    return f\"guest {g.guest_id}\"\n",
+  "test_app.py": "from handler import get\n\ndef test_get():\n    assert get({'guest_id': 1}).guest_id == 1\n"
+ },
+ "edits": [
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "schema.py",
+    "old_str": "guest_id",
+    "new_str": "customer_id"
+   },
+   "ok": false
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "models.py",
+    "old_str": "guest_id",
+    "new_str": "customer_id"
+   },
+   "ok": false
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "handler.py",
+    "old_str": "guest_id",
+    "new_str": "customer_id"
+   },
+   "ok": false
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "schema.py",
+    "old_str": "guest_id",
+    "new_str": "customer_id"
+   },
+   "ok": false
+  },
+  {
+   "tool": "str_replace_editor",
+   "args": {
+    "path": "models.py",
+    "old_str": "guest_id",
+    "new_str": "customer_id"
+   },
+   "ok": false
+  },
+  {
+   "tool": "run_tests",
+   "args": {},
+   "ok": true,
+   "result": "1 passed"
+  }
+ ],
+ "done": true
+}

fathom_read/ops.py

@@ -0,0 +1,79 @@
+"""The op stream: what an adapter produces and the hosted read consumes."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional, Tuple
+
+Ref = Tuple[str, str]
+
+
+@dataclass
+class Op:
+    """One action the agent took.
+
+    op:     "set" writes a value to (kind, key); "remove" deletes it; "rename" moves (kind, key)
+            to (kind, to); "add" inserts an entity into a collection under (kind, key); "answer"
+            is an assertion the agent made (a final answer, a report); "commit" marks a terminal
+            action (an order placed, a booking confirmed).
+    kind:   what sort of thing the key names: "file", "record", "block", "fact", "order", or your own.
+    key:    the name of the thing.
+    value:  the content written (for set/add/answer).
+    to:     the new name (for rename).
+    ok:     whether the tool accepted the action. False makes the op a no-op.
+    refs:   facts this op depends on, as (kind, key) pairs.
+    step:   the position of the op in the stream (set by the reader if omitted).
+    source: where the op came from (an adapter's note).
+    """
+    op: str
+    kind: str
+    key: str
+    value: Optional[str] = None
+    to: Optional[str] = None
+    ok: bool = True
+    refs: List[Ref] = field(default_factory=list)
+    step: Optional[int] = None
+    source: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Op":
+        refs = [tuple(r) for r in d.get("refs", [])]
+        return cls(op=d["op"], kind=d.get("kind", "fact"), key=str(d["key"]),
+                   value=None if d.get("value") is None else str(d.get("value")),
+                   to=d.get("to"), ok=bool(d.get("ok", True)), refs=refs,
+                   step=d.get("step"), source=d.get("source"))
+
+    def as_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d["refs"] = [list(r) for r in self.refs]
+        return d
+
+
+@dataclass
+class Finding:
+    kind: str
+    step: Optional[int]
+    key: str
+    detail: str
+    cites: Optional[int] = None
+
+    def as_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class Verdict:
+    coherent: bool
+    findings: List[Finding]
+    ops_read: int
+    ops_rejected: int
+    live_facts: int
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Verdict":
+        return cls(coherent=bool(d["coherent"]), findings=[Finding(**f) for f in d.get("findings", [])],
+                   ops_read=int(d.get("ops_read", 0)), ops_rejected=int(d.get("ops_rejected", 0)),
+                   live_facts=int(d.get("live_facts", 0)))
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {"coherent": self.coherent, "findings": [f.as_dict() for f in self.findings],
+                "ops_read": self.ops_read, "ops_rejected": self.ops_rejected, "live_facts": self.live_facts}

fathom_read-0.1.0.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: fathom-read
+Version: 0.1.0
+Summary: Catch the step where an AI agent contradicts a decision it already made. Adapters and a CLI for the Fathom committed-state read over LangGraph, CrewAI, Letta, OpenInference, DBOS, and coding-agent traces.
+Author-email: Embedded Risk Analytics <contact@embeddedriskanalytics.com>
+License: MIT License
+        
+        Copyright (c) 2026 Peter Galligan, Embedded Risk Analytics
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://embeddedriskanalytics.com
+Project-URL: Repository, https://github.com/ERA-Fathom/fathom
+Project-URL: Research, https://embeddedriskanalytics.com/research.html
+Keywords: ai-agents,llm,langgraph,crewai,letta,openinference,agent-memory,context-engineering,agent-evaluation,coherence
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# fathom-read
+
+**Catch the step where an AI agent contradicts a decision it already made.**
+
+On a long task, an agent loses track of what it already decided and starts acting against it. It renames `guest_id` to `customer_id` at step 1, then writes new code against `guest_id` at step 6. The change compiles, imports, and passes the tests. It fails at runtime.
+
+`fathom-read` turns the traces your framework already records into an action stream and sends it to the Fathom read, which reconstructs the state the agent committed and flags the step that contradicts it. Deterministic. No model access. Nothing runs in your production path.
+
+![fathom demo](docs/demo.gif)
+
+## Install
+
+```
+pip install fathom-read
+```
+
+## Run
+
+```
+fathom demo                                              # the bundled rename example, coherent and not
+fathom read trace.json --supersede guest_id=customer_id  # your own trace
+fathom read history.json --format langgraph              # or name the format
+fathom read trace.json --ops                             # see the action stream before anything is sent
+fathom formats                                           # the formats it reads
+```
+
+`fathom read` exits 0 when the committed state is coherent and 2 when it finds a contradiction, so it drops into a test suite or a CI step as it is. Add `--json` for a machine-readable verdict.
+
+The package ships with a demo key that is rate-limited per day. For your own key, which lifts the limit and keeps your traces on a private tier, write to [contact@embeddedriskanalytics.com](mailto:contact@embeddedriskanalytics.com?subject=fathom-read%20key) and set `FATHOM_API_KEY`. `--ops` shows exactly what would be sent: the ops the adapter produced, and nothing else.
+
+## What it reads
+
+| Format | What you export | How |
+|---|---|---|
+| `langgraph` | The checkpoint lineage | `[{"values": s.values, "step": s.metadata["step"]} for s in graph.get_state_history(config)]` |
+| `openinference` | The spans Arize Phoenix stores | Export the trace's spans as JSON; only TOOL spans matter |
+| `crewai` | The crew's event log | A listener on the event bus, capturing `tool_usage_finished`, `tool_usage_error`, `task_completed` |
+| `letta` | Blocks, passages, and the memory-edit tool calls | `agents.blocks.list`, `agents.passages.list`, the tool calls from `agents.messages.list` |
+| `dbos` | A workflow's step stream | `{"workflow_id": ..., "steps": [{"step_name", "args", "result", "ok"}]}` |
+| `edits` | A coding agent's edit log | `{"initial_files": {...}, "edits": [{"tool": "str_replace_editor", "args": {...}, "ok": true}]}` |
+| `events` | The native op stream | One op per line: `{"op": "set", "kind": "file", "key": "a.py", "value": "...", "ok": true}` |
+
+Your tools have their own names. Map them once with `--map tools.json`:
+
+```json
+{"save_decision": {"op": "set", "kind": "decision", "key": "topic", "value": "text"},
+ "book_seat":     {"op": "add", "kind": "flight", "key": "seats", "value": "seat"},
+ "confirm_booking": {"op": "commit", "kind": "flight", "key": "booking"}}
+```
+
+## What it finds
+
+| Finding | The agent... |
+|---|---|
+| `stale_reference` | acts on a fact it already removed or renamed away |
+| `superseded_value` | writes or answers with a value it already replaced |
+| `authored_contradiction` | reintroduces a token into a record it had already migrated |
+| `residual` | ends the run with a record still carrying a value it replaced elsewhere |
+| `duplicate_commit` | adds an entity a collection already holds |
+| `post_commit_mutation` | changes a thing after committing it |
+
+Every finding cites the earlier step it contradicts, so the readout is a diff between what the agent decided and what it did.
+
+## How it reads
+
+The read folds the agent's successful actions into a ledger of committed facts and checks every later action against the ledger. Two rules make this a reconstruction rather than a transcript. A failed action is a no-op: an edit the tool rejected leaves nothing behind. And the read consults only the agent's own actions and their results, never an answer key, so it attaches the same way on any framework. The adapters and the CLI in this repository build the action stream; the read itself runs in ERA's service.
+
+## Use it from Python
+
+```python
+from fathom_read import Op, read
+
+ops = [
+    Op("set", "fact", "user.city", value="Denver"),
+    Op("set", "fact", "user.city", value="Austin"),
+    Op("answer", "fact", "user.city", value="The user lives in Denver."),
+]
+verdict = read(ops)          # uses FATHOM_API_KEY, or the demo key
+for f in verdict.findings:
+    print(f.kind, f.step, f.detail)
+# superseded_value 2 step 2 answers 'Denver' for fact 'user.city', a value the agent replaced with 'Austin' at step 1.
+```
+
+## What it does not do
+
+It does not run your agent, call a model, or need one. It does not say why the agent contradicted itself or which repair would fix it; that is the [design-partner engagement](https://embeddedriskanalytics.com/contact.html). It reads agents whose committed state lives in tool calls, checkpoints, memory writes, or edits; an agent that keeps state only in free-text logs is out of scope.
+
+## Research
+
+The read comes out of the Fathom program at [Embedded Risk Analytics](https://embeddedriskanalytics.com). Case studies on LangGraph, CrewAI, Letta, OpenHands, Agent-E, ContextPilot, and τ-bench are at [embeddedriskanalytics.com/research](https://embeddedriskanalytics.com/research.html). The theory is in [Records, Reflexive Modeling, and the Conditions for Stable Physical Histories](https://ssrn.com/abstract=6683578) (SSRN, 2026). See [CITATION.cff](CITATION.cff).
+
+## Send us a trace
+
+If you run long-horizon agents and want a readout on your own traces, send a batch: [embeddedriskanalytics.com/contact](https://embeddedriskanalytics.com/contact.html).
+
+## License
+
+MIT. Fathom is a trademark of Embedded Risk Analytics.

fathom_read-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+fathom_read/__init__.py,sha256=yEJUkK3h000k1UQ00hbSflS-wkA9wfk8m1SEOK8W4WY,777
+fathom_read/cli.py,sha256=jOHZ2voeziWLMa4MkvAn5kLdKqi2nwFOYyABngOT3tU,4902
+fathom_read/client.py,sha256=zTu7_kEqhBxwX_56OUqda0gVeJf65pbrbgCKAp9K5NQ,1962
+fathom_read/ops.py,sha256=CWCnTHjtomHNwPsV0or175GB_FcmSMw4BYky_LJAJMQ,2857
+fathom_read/adapters/__init__.py,sha256=L7KKRqmBoQ1h3KEmp7TwTP2VVtVGMguBayxMSUc3bho,1811
+fathom_read/adapters/_tools.py,sha256=NQBgpgJSXNOjy5cBhps85lJh8p3IpJ65_WnsMmLQqH4,4721
+fathom_read/adapters/crewai.py,sha256=mRowA7tvpJ7nZWi9xwNM4jldhYiKPl1OPo2vLdOQbzU,1620
+fathom_read/adapters/dbos.py,sha256=URURGonPjOFmDDXM46z9mRSBoqNBDRcQySxraGPOlH0,919
+fathom_read/adapters/edits.py,sha256=fgAiSf5kUCJCzg0afMZXurbwfruOXny4R0PHVCL6pY8,2259
+fathom_read/adapters/events.py,sha256=cK_pm3kBidXBhVj5CCmam9Z-9FivI7KJNz415AyJCrA,476
+fathom_read/adapters/langgraph.py,sha256=SeayEjcbKx8IPGZK0_6URj4TgBEftZvngFbq1GMKcBI,2411
+fathom_read/adapters/letta.py,sha256=efZT-iHEaDLgEJIrewP1pCE34W0XKt1rFloY-XH9o4s,1409
+fathom_read/adapters/openinference.py,sha256=RMAuPLaeQ1WeAlO6odHKPXpbrxSfAMexyCAThVK12J4,2270
+fathom_read/examples/crewai_events.json,sha256=8riBzsiF2F_vttHB8jFgxeDmU-oSvsfYTTFtMLLlueo,541
+fathom_read/examples/knowledge_update.json,sha256=0vNIjQNyx-5V7CNQaDgE8vk-oQ5oO9ww7I2p5X6gp_U,354
+fathom_read/examples/langgraph_history.json,sha256=5OFNIwOMMryZU5L7rOJDFl-mQJZr4MydiTTCmTUCrfQ,434
+fathom_read/examples/order_duplicate.json,sha256=FFxJWsBG0LFVejcDfbQqCtxv2mMbmPQIojbotWrfky4,369
+fathom_read/examples/rename_coherent.json,sha256=isolVJJCFTDICv1anPmqAt0l0WntWM3RqjwpvS4JN4c,1603
+fathom_read/examples/rename_starved.json,sha256=f2wdknFoZtC1f8i6yxOTx8rONQVW1hzOFKifiqaFJmQ,1392
+fathom_read-0.1.0.dist-info/licenses/LICENSE,sha256=FP92AThBYP1kWdoqHHyhJUxdYnXrFkfB86rt6HbvDmo,1096
+fathom_read-0.1.0.dist-info/METADATA,sha256=0bhD8oDDJCV_jR5CyrYESmWH5iY4uDmKPzpjPimr_1Y,8258
+fathom_read-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fathom_read-0.1.0.dist-info/entry_points.txt,sha256=VMyOrIeBi3IumcxLuwmPEceYZOeGXan1Y4dYoUS8wh0,48
+fathom_read-0.1.0.dist-info/top_level.txt,sha256=EWItbJ3VlJ7GJ9mx7pRCTK4eN2GQjAlEa6tixFHKvt4,12
+fathom_read-0.1.0.dist-info/RECORD,,

fathom_read-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fathom_read-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fathom = fathom_read.cli:main

fathom_read-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Galligan, Embedded Risk Analytics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fathom_read-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fathom_read