awgit 1.2.0__tar.gz → 1.3.0__tar.gz

{awgit-1.2.0 → awgit-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awgit
-Version: 1.2.0
+Version: 1.3.0
 Summary: Aither World-Graph git — semantic version control on top of git: edit-ops keyed on stable node ids, content-addressed bodies, differential sync.
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/Aitherium/awgit
@@ -264,3 +264,66 @@ cd awgit && python -m pytest tests/ -q
 ## License
 
 Apache-2.0. Built by Aitherium — the git that scales to agents.
+
+---
+
+<!-- aither-ecosystem:start GENERATED from the ecosystem registry. Edits here are overwritten; change the registry instead. -->
+
+## The aw family
+
+Standalone tools that share one idea: **replace something you would otherwise have to _trust_ with something you can _check_.**
+
+Each installs on its own, works offline, and needs no account.
+
+| | instead of trusting | you check |
+|---|---|---|
+| [awdk](https://github.com/Aitherium/awdk) | a framework's idea of how your agents should run | one loop you can read, pointed at a backend you already pay for |
+| [awskills](https://github.com/Aitherium/awskills) | that an agent knows your procedure | the procedure written down, versioned, and loadable by any agent |
+| [awm](https://github.com/Aitherium/awm) | that memory stayed in its lane | tenant:user:project scopes, so a write cannot cross a boundary |
+| [awnode](https://github.com/Aitherium/awnode) | a vendor's cloud with every prompt | a local gateway routing to backends you chose |
+| [awgraph](https://github.com/Aitherium/awgraph) | that grep found everything | an AST + tree-sitter call graph an agent can traverse |
+| **awgit** _(you are here)_ | that no one else is editing this file | a lease, refused at commit time if you do not hold it |
+| [awseal](https://github.com/Aitherium/awseal) | that the artifact came from who you think | an Ed25519 seal — the key that verifies is not the key that forges |
+| [awshare](https://github.com/Aitherium/awshare) | that the download is intact | content-addressed bundles, verified on fetch |
+| [awnest](https://github.com/Aitherium/awnest) | that there is a person on the other end | a verdict with evidence, where "we could not tell" is not "yes" |
+| [awnboard](https://github.com/Aitherium/awnboard) | a share link anyone who sees it can use | an invitation addressed to one person, for one gate, revocable |
+| [awnix](https://github.com/Aitherium/awnix) | that the box is what you left it as | an immutable image you built, with atomic rollback |
+| [awrecover](https://github.com/Aitherium/awrecover) | that the restore worked | a restore that fully lands or does not land at all |
+| [awrelay](https://github.com/Aitherium/awrelay) | a SaaS in the middle of your agents | findings, alerts and coordination over your own transport |
+| [awmail](https://github.com/Aitherium/awmail) | a mailbox somebody else can read | mail your agents send and receive over your own server |
+| [awfind](https://github.com/Aitherium/awfind) | one vendor's idea of the web | results from whichever providers you configured |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | that the page said what you were told | the render, the DOM and the requests it made |
+| [aitherkvcache](https://github.com/Aitherium/aitherkvcache) | a vendor's quantisation defaults | sub-byte KV cache kernels you can benchmark yourself |
+| [AitherZero](https://github.com/Aitherium/AitherZero) | a pile of scripts nobody has numbered | numbered, discoverable automation with declarative playbooks |
+| [AitherConnect](https://github.com/Aitherium/AitherConnect) | what a page tells your browser to do | a federated search and desktop bridge you host |
+
+[**awnix**](https://github.com/Aitherium/awnix) is the ground floor — A Linux you can hand to an agent — immutable base, capabilities included.
+
+## The Aitherium ecosystem
+
+Every repository here is public. Each publishes an `aither-manifest.json` beside its page, so any surface can read every sibling's — the network is browsable from any node in it.
+
+| repo | what it is | pages |
+|---|---|---|
+| [awdk](https://github.com/Aitherium/awdk) | Build AI agent fleets — 3 lines, any backend, local or cloud | [docs](https://aitherium.github.io/awdk/) |
+| [awskills](https://github.com/Aitherium/awskills) | Portable agent skills — self-contained procedures an agent loads on demand | [docs](https://aitherium.github.io/awskills/) |
+| [awm](https://github.com/Aitherium/awm) | A portable, scoped agent memory | [docs](https://aitherium.github.io/awm/) |
+| [awnode](https://github.com/Aitherium/awnode) | A lightweight local gateway — bridges your apps to the AI backends you chose | [docs](https://aitherium.github.io/awnode/) |
+| [awrun](https://github.com/Aitherium/awrun) | A priority-aware queue and dispatcher for agentic runs and ad-hoc CI builds | [docs](https://aitherium.github.io/awrun/) |
+| [awgraph](https://github.com/Aitherium/awgraph) | A semantic code graph for agents — AST + tree-sitter, call graphs | [docs](https://aitherium.github.io/awgraph/) |
+| **awgit** _(you are here)_ | Semantic version control on top of git — edit-ops and leases | [docs](https://aitherium.github.io/awgit/) |
+| [awseal](https://github.com/Aitherium/awseal) | Sign an artifact so a stranger can verify it | [docs](https://aitherium.github.io/awseal/) |
+| [awshare](https://github.com/Aitherium/awshare) | Publish an artifact and fetch it back verified | [docs](https://aitherium.github.io/awshare/) |
+| [awnest](https://github.com/Aitherium/awnest) | Prove there is a human before you let them into the nest | — |
+| [awnboard](https://github.com/Aitherium/awnboard) | A front gate you can put in front of anything, and hand someone the key to | — |
+| [awnix](https://github.com/Aitherium/awnix) | A Linux you can hand to an agent — immutable base, capabilities included | [docs](https://aitherium.github.io/awnix/) |
+| [awrecover](https://github.com/Aitherium/awrecover) | Labelled snapshots with an all-or-nothing restore | [docs](https://aitherium.github.io/awrecover/) |
+| [awrelay](https://github.com/Aitherium/awrelay) | Portable agent messaging — findings, alerts, coordination | [docs](https://aitherium.github.io/awrelay/) |
+| [awmail](https://github.com/Aitherium/awmail) | Give an agent an email address — send, and actually receive | — |
+| [awfind](https://github.com/Aitherium/awfind) | A portable search client — query, results, ranking | — |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | A portable browser client — navigate, console, network, DOM, screenshot | — |
+| [aitherkvcache](https://github.com/Aitherium/aitherkvcache) | Near-optimal KV cache quantization for LLM inference — sub-byte compression | [docs](https://aitherium.github.io/aitherkvcache/) |
+| [AitherZero](https://github.com/Aitherium/AitherZero) | PowerShell 7+ automation framework — numbered, self-describing scripts | [docs](https://aitherium.github.io/AitherZero/) |
+| [AitherConnect](https://github.com/Aitherium/AitherConnect) | Browser extension — federated AI search, page context, and the Living OS overlay | — |
+
+<!-- aither-ecosystem:end -->

{awgit-1.2.0 → awgit-1.3.0}/README.md

@@ -247,3 +247,66 @@ cd awgit && python -m pytest tests/ -q
 ## License
 
 Apache-2.0. Built by Aitherium — the git that scales to agents.
+
+---
+
+<!-- aither-ecosystem:start GENERATED from the ecosystem registry. Edits here are overwritten; change the registry instead. -->
+
+## The aw family
+
+Standalone tools that share one idea: **replace something you would otherwise have to _trust_ with something you can _check_.**
+
+Each installs on its own, works offline, and needs no account.
+
+| | instead of trusting | you check |
+|---|---|---|
+| [awdk](https://github.com/Aitherium/awdk) | a framework's idea of how your agents should run | one loop you can read, pointed at a backend you already pay for |
+| [awskills](https://github.com/Aitherium/awskills) | that an agent knows your procedure | the procedure written down, versioned, and loadable by any agent |
+| [awm](https://github.com/Aitherium/awm) | that memory stayed in its lane | tenant:user:project scopes, so a write cannot cross a boundary |
+| [awnode](https://github.com/Aitherium/awnode) | a vendor's cloud with every prompt | a local gateway routing to backends you chose |
+| [awgraph](https://github.com/Aitherium/awgraph) | that grep found everything | an AST + tree-sitter call graph an agent can traverse |
+| **awgit** _(you are here)_ | that no one else is editing this file | a lease, refused at commit time if you do not hold it |
+| [awseal](https://github.com/Aitherium/awseal) | that the artifact came from who you think | an Ed25519 seal — the key that verifies is not the key that forges |
+| [awshare](https://github.com/Aitherium/awshare) | that the download is intact | content-addressed bundles, verified on fetch |
+| [awnest](https://github.com/Aitherium/awnest) | that there is a person on the other end | a verdict with evidence, where "we could not tell" is not "yes" |
+| [awnboard](https://github.com/Aitherium/awnboard) | a share link anyone who sees it can use | an invitation addressed to one person, for one gate, revocable |
+| [awnix](https://github.com/Aitherium/awnix) | that the box is what you left it as | an immutable image you built, with atomic rollback |
+| [awrecover](https://github.com/Aitherium/awrecover) | that the restore worked | a restore that fully lands or does not land at all |
+| [awrelay](https://github.com/Aitherium/awrelay) | a SaaS in the middle of your agents | findings, alerts and coordination over your own transport |
+| [awmail](https://github.com/Aitherium/awmail) | a mailbox somebody else can read | mail your agents send and receive over your own server |
+| [awfind](https://github.com/Aitherium/awfind) | one vendor's idea of the web | results from whichever providers you configured |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | that the page said what you were told | the render, the DOM and the requests it made |
+| [aitherkvcache](https://github.com/Aitherium/aitherkvcache) | a vendor's quantisation defaults | sub-byte KV cache kernels you can benchmark yourself |
+| [AitherZero](https://github.com/Aitherium/AitherZero) | a pile of scripts nobody has numbered | numbered, discoverable automation with declarative playbooks |
+| [AitherConnect](https://github.com/Aitherium/AitherConnect) | what a page tells your browser to do | a federated search and desktop bridge you host |
+
+[**awnix**](https://github.com/Aitherium/awnix) is the ground floor — A Linux you can hand to an agent — immutable base, capabilities included.
+
+## The Aitherium ecosystem
+
+Every repository here is public. Each publishes an `aither-manifest.json` beside its page, so any surface can read every sibling's — the network is browsable from any node in it.
+
+| repo | what it is | pages |
+|---|---|---|
+| [awdk](https://github.com/Aitherium/awdk) | Build AI agent fleets — 3 lines, any backend, local or cloud | [docs](https://aitherium.github.io/awdk/) |
+| [awskills](https://github.com/Aitherium/awskills) | Portable agent skills — self-contained procedures an agent loads on demand | [docs](https://aitherium.github.io/awskills/) |
+| [awm](https://github.com/Aitherium/awm) | A portable, scoped agent memory | [docs](https://aitherium.github.io/awm/) |
+| [awnode](https://github.com/Aitherium/awnode) | A lightweight local gateway — bridges your apps to the AI backends you chose | [docs](https://aitherium.github.io/awnode/) |
+| [awrun](https://github.com/Aitherium/awrun) | A priority-aware queue and dispatcher for agentic runs and ad-hoc CI builds | [docs](https://aitherium.github.io/awrun/) |
+| [awgraph](https://github.com/Aitherium/awgraph) | A semantic code graph for agents — AST + tree-sitter, call graphs | [docs](https://aitherium.github.io/awgraph/) |
+| **awgit** _(you are here)_ | Semantic version control on top of git — edit-ops and leases | [docs](https://aitherium.github.io/awgit/) |
+| [awseal](https://github.com/Aitherium/awseal) | Sign an artifact so a stranger can verify it | [docs](https://aitherium.github.io/awseal/) |
+| [awshare](https://github.com/Aitherium/awshare) | Publish an artifact and fetch it back verified | [docs](https://aitherium.github.io/awshare/) |
+| [awnest](https://github.com/Aitherium/awnest) | Prove there is a human before you let them into the nest | — |
+| [awnboard](https://github.com/Aitherium/awnboard) | A front gate you can put in front of anything, and hand someone the key to | — |
+| [awnix](https://github.com/Aitherium/awnix) | A Linux you can hand to an agent — immutable base, capabilities included | [docs](https://aitherium.github.io/awnix/) |
+| [awrecover](https://github.com/Aitherium/awrecover) | Labelled snapshots with an all-or-nothing restore | [docs](https://aitherium.github.io/awrecover/) |
+| [awrelay](https://github.com/Aitherium/awrelay) | Portable agent messaging — findings, alerts, coordination | [docs](https://aitherium.github.io/awrelay/) |
+| [awmail](https://github.com/Aitherium/awmail) | Give an agent an email address — send, and actually receive | — |
+| [awfind](https://github.com/Aitherium/awfind) | A portable search client — query, results, ranking | — |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | A portable browser client — navigate, console, network, DOM, screenshot | — |
+| [aitherkvcache](https://github.com/Aitherium/aitherkvcache) | Near-optimal KV cache quantization for LLM inference — sub-byte compression | [docs](https://aitherium.github.io/aitherkvcache/) |
+| [AitherZero](https://github.com/Aitherium/AitherZero) | PowerShell 7+ automation framework — numbered, self-describing scripts | [docs](https://aitherium.github.io/AitherZero/) |
+| [AitherConnect](https://github.com/Aitherium/AitherConnect) | Browser extension — federated AI search, page context, and the Living OS overlay | — |
+
+<!-- aither-ecosystem:end -->

{awgit-1.2.0 → awgit-1.3.0}/awgit/cli.py

@@ -107,6 +107,48 @@ def _cmd_capture(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_data(args: argparse.Namespace) -> int:
+    """Row-level diff of two tabular files (see awgit/tabular.py)."""
+    import json  # function-local, matching the convention in this module
+
+    from . import tabular
+
+    if args.data_cmd != "diff":  # pragma: no cover - argparse enforces this
+        print(f"awgit: unknown data subcommand {args.data_cmd!r}", file=sys.stderr)
+        return 2
+
+    try:
+        d = tabular.diff_files(args.old, args.new, args.key)
+    except tabular.UnreadableTableError as exc:
+        # Exit 2, never 0-with-empty-output: a table we could not read must not
+        # be reported as a table with no differences.
+        print(f"awgit: {exc}", file=sys.stderr)
+        return 2
+
+    if args.as_json:
+        print(json.dumps({
+            "summary": d.summary(),
+            "added": d.added,
+            "removed": d.removed,
+            "modified": [{"before": b, "after": a} for b, a in d.modified],
+        }, indent=2, default=str))
+        return 0
+
+    s = d.summary()
+    if d.keyless:
+        print("no --key given: content set-diff only; MODIFIED rows cannot be "
+              "distinguished from an add plus a remove.")
+    else:
+        print(f"keyed on: {', '.join(d.keys)}")
+    for col in s["columns_added"]:
+        print(f"  + column {col}")
+    for col in s["columns_removed"]:
+        print(f"  - column {col}")
+    print(f"  {s['added']} added, {s['removed']} removed, "
+          f"{s['modified']} modified, {s['unchanged']} unchanged")
+    return 0
+
+
 def _cmd_diff(args: argparse.Namespace) -> int:
     try:
         changes = diff_git(args.a, args.b)
@@ -446,28 +488,6 @@ def staged_but_not_committed(repo: Path) -> List[str]:
     except OSError:
         return []
 
-    # An index the OPERATOR supplied is not the sweep this rule is about — it is
-    # the documented DEFENCE against it (concurrent-safe-git rule 1a: seed a
-    # private index from HEAD so a peer's staging cannot reach your commit). It
-    # was being rejected by the very gate that recommends it, and the rejection
-    # message told the committer to do what they were already doing, so the only
-    # ways forward were --no-verify or the sweep. Measured 2026-08-15 on a commit
-    # whose alternative was shipping a peer's half-finished route-manifest
-    # refactor that DELETES three RBAC mappings — i.e. the gate was pushing
-    # toward the exact outcome it exists to prevent.
-    #
-    # The discriminator is WHERE the index lives, and it cannot be evaded:
-    # `git commit -- <pathspec>` and `git commit -a` build their temp index
-    # INSIDE the git dir (`next-index-<pid>.lock`, `index.lock`), and they do so
-    # even when GIT_INDEX_FILE is already set to something else — verified
-    # against a real throwaway repo, both forms, with and without a private
-    # index exported. So an index outside the git dir can only have come from
-    # the operator, and what they are committing is what they chose.
-    try:
-        Path(temp_index).resolve().relative_to(Path(git_dir).resolve())
-    except (ValueError, OSError):
-        return []  # operator-supplied private index — rule 1a, not a sweep
-
     # The paths AT RISK are the ones really staged — `_staged_files` would read
     # the temp index here, for the same GIT_INDEX_FILE reason as above.
     paths = [
@@ -574,66 +594,48 @@ def _cmd_stage_mine(args: argparse.Namespace) -> int:
     return 1 if failed else 0
 
 
-def merge_authored_files(repo: Path, staged: List[str]) -> List[str]:
-    """During a MERGE, the files the committer actually authored.
-
-    A merge commit brings in every file the other side changed — already-committed
-    history that no lease could sensibly cover. The lease plane exists to stop one
-    session clobbering another's UNCOMMITTED work, and a merge cannot do that: git
-    refuses to merge over dirty files it would overwrite. So demanding a lease for
-    incoming history is asking for something that is neither possible nor useful.
+def _merge_hand_resolved(repo: Path, staged: List[str]) -> List[str]:
+    """During a merge, the files the COMMITTER actually decided.
 
-    Measured 2026-08-11: merging origin/develop into a feature branch demanded
-    leases for ~250 files, and `lease acquire --staged --adopt` could only pick up
-    7 because is_guarded() filters the rest — leaving no way to complete a merge
-    except switching enforcement off, which is exactly how a gate stops being used.
+    A merge commit legitimately stages everything the other lineage touched. On
+    this repo that is 1,266 files for a single recovery merge, and demanding a
+    lease on each is not a safety property -- it is a wall. Measured 2026-08-19:
+    `lease acquire --staged --adopt` granted zero, and acquiring them in batches
+    ran past six minutes without finishing, so a legitimate merge could not be
+    recorded at all.
 
-    What IS still guarded: the conflict RESOLUTIONS. A staged blob that matches
-    neither parent is text the committer wrote by hand, and that is a real edit on
-    a shared file. Everything taken verbatim from either side is inherited.
+    The gate exists to stop one session sweeping another's IN-FLIGHT edit. A file
+    taken verbatim from either parent is nobody's in-flight edit -- git chose it,
+    not the committer. Only a file whose staged blob differs from BOTH parents was
+    hand-resolved, and those are exactly the committer's own work, so those are
+    what still require a lease.
 
-    Returns `staged` unchanged when this is not a merge.
+    Returns the staged paths when this is not a merge, so the normal path is
+    unchanged.
     """
-    try:
-        git_dir = subprocess.run(
-            ["git", "rev-parse", "--absolute-git-dir"], cwd=str(repo),
-            capture_output=True, text=True, encoding="utf-8", errors="replace",
-        ).stdout.strip()
-    except OSError:
-        return staged
-    if not git_dir or not (Path(git_dir) / "MERGE_HEAD").is_file():
+    git_dir = subprocess.run(
+        ["git", "rev-parse", "--git-dir"], cwd=str(repo),
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+    ).stdout.strip()
+    if not git_dir or not (Path(repo) / git_dir / "MERGE_HEAD").exists()             and not Path(git_dir, "MERGE_HEAD").exists():
         return staged
 
-    def blobs(rev: str) -> dict:
+    def _differs(ref: str) -> set:
         out = subprocess.run(
-            ["git", "ls-tree", "-r", rev, "--", *staged], cwd=str(repo),
+            ["git", "diff", "--cached", "--name-only", ref], cwd=str(repo),
             capture_output=True, text=True, encoding="utf-8", errors="replace",
         ).stdout
-        found = {}
-        for line in out.splitlines():
-            meta, _, path = line.partition("	")
-            parts = meta.split()
-            if len(parts) >= 3 and path:
-                found[path] = parts[2]
-        return found
-
-    if not staged:
-        return staged
-    ours, theirs = blobs("HEAD"), blobs("MERGE_HEAD")
-    index = {}
-    out = subprocess.run(
-        ["git", "ls-files", "--stage", "--", *staged], cwd=str(repo),
-        capture_output=True, text=True, encoding="utf-8", errors="replace",
-    ).stdout
-    for line in out.splitlines():
-        meta, _, path = line.partition("	")
-        parts = meta.split()
-        if len(parts) >= 2 and path:
-            index[path] = parts[1]
+        return {ln for ln in out.splitlines() if ln.strip()}
 
-    authored = [p for p in staged
-                if index.get(p) not in (ours.get(p), theirs.get(p))]
-    return authored
+    ours, theirs = _differs("HEAD"), _differs("MERGE_HEAD")
+    if not ours and not theirs:
+        # Could not read either parent -> judge nothing away; fall back to the
+        # full staged set rather than exempting everything.
+        return staged
+    hand = sorted(set(staged) & ours & theirs)
+    print(f"vcs: merge in progress -- {len(staged)} staged, {len(hand)} hand-resolved; "
+          f"a lease is required on the hand-resolved files only")
+    return hand
 
 
 def _requests_store():
@@ -734,7 +736,7 @@ def _cmd_lease_check(args: argparse.Namespace) -> int:
     if who == "unknown":
         print("vcs: lease-check requires AITHER_ACTOR (or --actor)", file=sys.stderr)
         return 1
-    gap = coverage_gap(merge_authored_files(repo, _staged_files(repo)), who)
+    gap = coverage_gap(_merge_hand_resolved(repo, _staged_files(repo)), who)
     if gap:
         print(
             "vcs: commit rejected — no active lease covering: " + ", ".join(gap),
@@ -1652,6 +1654,23 @@ def build_parser() -> argparse.ArgumentParser:
     p_diff.add_argument("b", help="target sha")
     p_diff.add_argument("--json", action="store_true", dest="as_json")
 
+    # `data` is its own verb rather than an overload of `diff`: `awgit diff`
+    # means NODE diff and keeps that meaning (the MCP handler, two skills, the
+    # hooks and two blog posts all depend on its shape), so a tabular diff gets
+    # its own noun instead of silently changing an existing contract.
+    p_data = sub.add_parser("data", help="row-level operations on tabular files")
+    data_sub = p_data.add_subparsers(dest="data_cmd", required=True)
+    p_data_diff = data_sub.add_parser(
+        "diff", help="row-level diff of two CSV/TSV/parquet files")
+    p_data_diff.add_argument("old", help="baseline table")
+    p_data_diff.add_argument("new", help="target table")
+    p_data_diff.add_argument(
+        "--key", action="append", default=[], metavar="COL",
+        help="key column giving each row its identity; repeatable. Without one "
+             "the diff falls back to a content set-diff and cannot report "
+             "MODIFIED rows.")
+    p_data_diff.add_argument("--json", action="store_true", dest="as_json")
+
     p_status = sub.add_parser("status", help="op-log status")
     p_status.add_argument("--json", action="store_true", dest="as_json")
     p_graph = sub.add_parser(
@@ -2058,6 +2077,8 @@ def main(argv: Optional[List[str]] = None) -> int:
         return _cmd_capture(args)
     if args.cmd == "diff":
         return _cmd_diff(args)
+    if args.cmd == "data":
+        return _cmd_data(args)
     if args.cmd == "status":
         return _cmd_status(args)
     if args.cmd == "merge-preview":

{awgit-1.2.0 → awgit-1.3.0}/awgit/evidence.py

@@ -83,16 +83,6 @@ def gather(data_root=None, since: Optional[str] = None) -> dict:
     ambiguous = [c for c in collisions if _agent_sessions(c["actors"]) < 2]
     total = len(ops)
     multi_actor = len(actors) > 1
-
-    # Optional host enrichment: the op-log says what changed and who changed it,
-    # never why. A host holding the agents' reasoning traces can answer that.
-    # Absent is the normal state and yields no key at all — an explicit zero
-    # would claim these agents worked without reasoning, which is a different
-    # and false statement.
-    from awgit import plugins as _plugins
-
-    reasoning = _plugins.thoughts(sorted(actors))
-
     return {
         "ops": total,
         "node_changes": nodes,
@@ -111,8 +101,6 @@ def gather(data_root=None, since: Optional[str] = None) -> dict:
         # The honesty flag. Every collision number below is meaningless without
         # it, and a reader who does not know that will over-read a zero.
         "can_detect_collisions": multi_actor,
-        # Present only when a host registered the THOUGHTS hook.
-        **({"reasoning": reasoning} if reasoning else {}),
     }
 
 
@@ -135,14 +123,6 @@ def render(ev: dict) -> str:
                f"{ev.get('confirmed_multi_agent_collisions', 0)} CONFIRMED "
                f"(two distinct agent sessions), "
                f"{ev.get('ambiguous_collisions', 0)} ambiguous")
-    reasoning = ev.get("reasoning")
-    if reasoning:
-        traces = reasoning.get("traces")
-        linked = reasoning.get("linked_actors")
-        detail = f"{traces} trace(s)" if traces is not None else "available"
-        if linked is not None:
-            detail += f" across {linked} actor(s)"
-        out.append(f"  reasoning captured  {detail}")
     if not ev["can_detect_collisions"]:
         out.append("")
         out.append("  NOTE: only ONE actor appears in this op-log, so a collision")

{awgit-1.2.0 → awgit-1.3.0}/awgit/guard.py

@@ -144,6 +144,123 @@ def check(actor: str, cwd: Optional[Path] = None) -> Verdict:
     return Verdict(True, basis="no other actor holds a lease in this worktree")
 
 
+#: The branch a PUBLISHED artifact is supposed to come from. Overridable, because
+#: a product with its own release branch is a real thing -- but it has a default,
+#: because "which branch should this have been built from" is not a question the
+#: person mid-deploy should have to answer.
+DEFAULT_DEPLOY_REF = "origin/develop"
+
+
+@dataclass
+class ShipVerdict:
+    """Is this working tree fit to build a PUBLISHED artifact from?
+
+    Separate from `Verdict` on purpose: that one asks whether rewriting history
+    here would destroy a peer's work, this one asks whether shipping from here
+    would publish something old. Same tree, different danger.
+    """
+
+    ok: bool
+    behind: int = 0
+    ahead: int = 0
+    ref: str = DEFAULT_DEPLOY_REF
+    head: str = ""
+    reasons: List[str] = field(default_factory=list)
+    fix: List[str] = field(default_factory=list)
+    #: True when the question could not be ANSWERED (no such ref, not a repo).
+    #: Callers must treat this as a refusal, never as a pass -- an unanswerable
+    #: staleness check is exactly the state that let a stale build ship.
+    unknown: bool = False
+
+    def report(self) -> str:
+        head, *rest = self.reasons or ["unfit to publish from"]
+        lines = [f"awgit: refusing to publish — {head}"]
+        lines += [f"awgit: {r}" for r in rest]
+        lines += [f"awgit: {f}" for f in self.fix]
+        return "\n".join(lines)
+
+
+def behind_deploy_ref(
+    cwd: Optional[Path] = None, ref: str = DEFAULT_DEPLOY_REF
+) -> ShipVerdict:
+    """How far the current checkout is behind the branch releases come from.
+
+    🚨 WHY THIS EXISTS, measured 2026-08-20. Two customer-facing sites were
+    published from a feature branch **587 commits behind the deploy branch**. The build succeeded, every gate
+    passed, the export was byte-valid, and the sites came up looking right. What
+    shipped was a desktop carrying a bug that had been FIXED on develop earlier
+    that same day (the Aeon window could not be dragged, because its body was not
+    a containing block, so app content painted over the only drag handle).
+
+    Nothing in the pipeline could see it. A build does not know what it is missing;
+    `git status` is clean on a stale branch; and the artifact is *correct*, just
+    old. The only signal was the owner recognising a bug he had already had fixed.
+
+    Two hours of that session were also spent re-deriving fixes that already
+    existed on develop -- the same route exclusion, the same malformed blog post.
+    Staleness does not only ship old code, it burns the time spent rebuilding what
+    someone already built.
+
+    Answers from the LOCAL ref: this must be usable in a publish path that may have
+    no network, and a fetch that silently fails would turn "up to date" into a lie.
+    `stale_ref_age_days` reports how old the local ref is so a caller can insist on
+    a fetch when it matters, rather than this function pretending to know.
+    """
+    repo = repo_root(cwd)
+    if repo is None:
+        return ShipVerdict(
+            ok=False, unknown=True, ref=ref,
+            reasons=["not inside a git repository, so staleness cannot be judged"],
+            fix=["run this from the repo, or pass an explicit --allow-stale reason"],
+        )
+
+    head = _git(repo, "rev-parse", "--short", "HEAD").strip()
+    # `rev-list --count A..B` counts commits in B not in A.
+    raw = _git(repo, "rev-list", "--left-right", "--count", f"HEAD...{ref}").strip()
+    parts = raw.split()
+    if len(parts) != 2 or not all(x.isdigit() for x in parts):
+        return ShipVerdict(
+            ok=False, unknown=True, ref=ref, head=head,
+            reasons=[f"could not compare HEAD against {ref} (is it fetched?)"],
+            fix=[f"git fetch origin && retry, or pass --allow-stale with a reason"],
+        )
+    ahead, behind = int(parts[0]), int(parts[1])
+    if behind == 0:
+        return ShipVerdict(ok=True, behind=0, ahead=ahead, ref=ref, head=head)
+
+    return ShipVerdict(
+        ok=False, behind=behind, ahead=ahead, ref=ref, head=head,
+        reasons=[
+            f"HEAD ({head}) is {behind} commit(s) BEHIND {ref}",
+            "a build from here succeeds and ships code that was already fixed —"
+            " there is no other signal, because the artifact is correct, just old",
+        ],
+        fix=[
+            f"fix: git fetch origin && git merge {ref}   (or rebuild from {ref})",
+            "override only with a stated reason: --allow-stale '<why>'",
+        ],
+    )
+
+
+def stale_ref_age_days(cwd: Optional[Path] = None,
+                       ref: str = DEFAULT_DEPLOY_REF) -> Optional[float]:
+    """Age in days of the LOCAL copy of `ref`, or None if it cannot be read.
+
+    `behind_deploy_ref` compares against whatever was last fetched. A ref fetched
+    a week ago can report "0 behind" and be badly wrong, so the age is the second
+    half of the answer and callers should surface it.
+    """
+    repo = repo_root(cwd)
+    if repo is None:
+        return None
+    out = _git(repo, "log", "-1", "--format=%ct", ref).strip()
+    if not out.isdigit():
+        return None
+    import time
+
+    return max(0.0, (time.time() - int(out)) / 86400.0)
+
+
 def require(actor: str, cwd: Optional[Path] = None) -> Optional[int]:
     """``None`` when a rewrite may proceed, else an exit code after reporting.
 

{awgit-1.2.0 → awgit-1.3.0}/awgit/plugins.py

@@ -42,7 +42,6 @@ PARSER = "parser"                # (bytes, str) -> graph with .chunks
 BLAST_RADIUS = "blast_radius"    # (node_id, symbol, path) -> dict
 EXTEND_PARSER = "extend_parser"  # (argparse subparsers action) -> None
 GATES = "gates"                  # (list[str] changed paths) -> dict
-THOUGHTS = "thoughts"            # (list[str] actors) -> dict
 
 _hooks: Dict[str, Callable[..., Any]] = {}
 _multi: Dict[str, List[Callable[..., Any]]] = {}
@@ -142,23 +141,6 @@ def extend_parser(subparsers: Any) -> None:
     call_all(EXTEND_PARSER, subparsers)
 
 
-def thoughts(actors: List[str]) -> Dict[str, Any]:
-    """Reasoning-trace enrichment for an evidence report; ``{}`` when absent.
-
-    Standalone awgit records WHAT changed and WHO changed it. A host that also
-    keeps the agents' reasoning can answer WHY, and that is the one question an
-    op-log structurally cannot. Absent here means the evidence report simply
-    does not mention reasoning — never a zero, which would assert that these
-    agents did their work without any.
-
-    The hook is handed only the actor labels already in the report; it must not
-    be given anything that would make an evidence report depend on a host being
-    present to be correct.
-    """
-    out = call(THOUGHTS, list(actors), default={})
-    return out if isinstance(out, dict) else {}
-
-
 def self_test() -> int:
     """Prove the seam still behaves: default, override, and failure-is-soft."""
     failures = 0

{awgit-1.2.0 → awgit-1.3.0}/awgit/worktree.py

@@ -86,6 +86,7 @@ def _is_zombie(path: Path, cwd: Optional[Path]) -> bool:
     that traps a later ``cd`` into it: any git command run there finds no
     local ``.git``, walks up, and silently resolves to whatever repo happens
     to contain it, which is why this is asserted rather than assumed.
+    to contain it.
     """
     if not path.is_dir() or (path / ".git").exists():
         return False

{awgit-1.2.0 → awgit-1.3.0}/awgit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awgit
-Version: 1.2.0
+Version: 1.3.0
 Summary: Aither World-Graph git — semantic version control on top of git: edit-ops keyed on stable node ids, content-addressed bodies, differential sync.
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/Aitherium/awgit
@@ -264,3 +264,66 @@ cd awgit && python -m pytest tests/ -q
 ## License
 
 Apache-2.0. Built by Aitherium — the git that scales to agents.
+
+---
+
+<!-- aither-ecosystem:start GENERATED from the ecosystem registry. Edits here are overwritten; change the registry instead. -->
+
+## The aw family
+
+Standalone tools that share one idea: **replace something you would otherwise have to _trust_ with something you can _check_.**
+
+Each installs on its own, works offline, and needs no account.
+
+| | instead of trusting | you check |
+|---|---|---|
+| [awdk](https://github.com/Aitherium/awdk) | a framework's idea of how your agents should run | one loop you can read, pointed at a backend you already pay for |
+| [awskills](https://github.com/Aitherium/awskills) | that an agent knows your procedure | the procedure written down, versioned, and loadable by any agent |
+| [awm](https://github.com/Aitherium/awm) | that memory stayed in its lane | tenant:user:project scopes, so a write cannot cross a boundary |
+| [awnode](https://github.com/Aitherium/awnode) | a vendor's cloud with every prompt | a local gateway routing to backends you chose |
+| [awgraph](https://github.com/Aitherium/awgraph) | that grep found everything | an AST + tree-sitter call graph an agent can traverse |
+| **awgit** _(you are here)_ | that no one else is editing this file | a lease, refused at commit time if you do not hold it |
+| [awseal](https://github.com/Aitherium/awseal) | that the artifact came from who you think | an Ed25519 seal — the key that verifies is not the key that forges |
+| [awshare](https://github.com/Aitherium/awshare) | that the download is intact | content-addressed bundles, verified on fetch |
+| [awnest](https://github.com/Aitherium/awnest) | that there is a person on the other end | a verdict with evidence, where "we could not tell" is not "yes" |
+| [awnboard](https://github.com/Aitherium/awnboard) | a share link anyone who sees it can use | an invitation addressed to one person, for one gate, revocable |
+| [awnix](https://github.com/Aitherium/awnix) | that the box is what you left it as | an immutable image you built, with atomic rollback |
+| [awrecover](https://github.com/Aitherium/awrecover) | that the restore worked | a restore that fully lands or does not land at all |
+| [awrelay](https://github.com/Aitherium/awrelay) | a SaaS in the middle of your agents | findings, alerts and coordination over your own transport |
+| [awmail](https://github.com/Aitherium/awmail) | a mailbox somebody else can read | mail your agents send and receive over your own server |
+| [awfind](https://github.com/Aitherium/awfind) | one vendor's idea of the web | results from whichever providers you configured |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | that the page said what you were told | the render, the DOM and the requests it made |
+| [aitherkvcache](https://github.com/Aitherium/aitherkvcache) | a vendor's quantisation defaults | sub-byte KV cache kernels you can benchmark yourself |
+| [AitherZero](https://github.com/Aitherium/AitherZero) | a pile of scripts nobody has numbered | numbered, discoverable automation with declarative playbooks |
+| [AitherConnect](https://github.com/Aitherium/AitherConnect) | what a page tells your browser to do | a federated search and desktop bridge you host |
+
+[**awnix**](https://github.com/Aitherium/awnix) is the ground floor — A Linux you can hand to an agent — immutable base, capabilities included.
+
+## The Aitherium ecosystem
+
+Every repository here is public. Each publishes an `aither-manifest.json` beside its page, so any surface can read every sibling's — the network is browsable from any node in it.
+
+| repo | what it is | pages |
+|---|---|---|
+| [awdk](https://github.com/Aitherium/awdk) | Build AI agent fleets — 3 lines, any backend, local or cloud | [docs](https://aitherium.github.io/awdk/) |
+| [awskills](https://github.com/Aitherium/awskills) | Portable agent skills — self-contained procedures an agent loads on demand | [docs](https://aitherium.github.io/awskills/) |
+| [awm](https://github.com/Aitherium/awm) | A portable, scoped agent memory | [docs](https://aitherium.github.io/awm/) |
+| [awnode](https://github.com/Aitherium/awnode) | A lightweight local gateway — bridges your apps to the AI backends you chose | [docs](https://aitherium.github.io/awnode/) |
+| [awrun](https://github.com/Aitherium/awrun) | A priority-aware queue and dispatcher for agentic runs and ad-hoc CI builds | [docs](https://aitherium.github.io/awrun/) |
+| [awgraph](https://github.com/Aitherium/awgraph) | A semantic code graph for agents — AST + tree-sitter, call graphs | [docs](https://aitherium.github.io/awgraph/) |
+| **awgit** _(you are here)_ | Semantic version control on top of git — edit-ops and leases | [docs](https://aitherium.github.io/awgit/) |
+| [awseal](https://github.com/Aitherium/awseal) | Sign an artifact so a stranger can verify it | [docs](https://aitherium.github.io/awseal/) |
+| [awshare](https://github.com/Aitherium/awshare) | Publish an artifact and fetch it back verified | [docs](https://aitherium.github.io/awshare/) |
+| [awnest](https://github.com/Aitherium/awnest) | Prove there is a human before you let them into the nest | — |
+| [awnboard](https://github.com/Aitherium/awnboard) | A front gate you can put in front of anything, and hand someone the key to | — |
+| [awnix](https://github.com/Aitherium/awnix) | A Linux you can hand to an agent — immutable base, capabilities included | [docs](https://aitherium.github.io/awnix/) |
+| [awrecover](https://github.com/Aitherium/awrecover) | Labelled snapshots with an all-or-nothing restore | [docs](https://aitherium.github.io/awrecover/) |
+| [awrelay](https://github.com/Aitherium/awrelay) | Portable agent messaging — findings, alerts, coordination | [docs](https://aitherium.github.io/awrelay/) |
+| [awmail](https://github.com/Aitherium/awmail) | Give an agent an email address — send, and actually receive | — |
+| [awfind](https://github.com/Aitherium/awfind) | A portable search client — query, results, ranking | — |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | A portable browser client — navigate, console, network, DOM, screenshot | — |
+| [aitherkvcache](https://github.com/Aitherium/aitherkvcache) | Near-optimal KV cache quantization for LLM inference — sub-byte compression | [docs](https://aitherium.github.io/aitherkvcache/) |
+| [AitherZero](https://github.com/Aitherium/AitherZero) | PowerShell 7+ automation framework — numbered, self-describing scripts | [docs](https://aitherium.github.io/AitherZero/) |
+| [AitherConnect](https://github.com/Aitherium/AitherConnect) | Browser extension — federated AI search, page context, and the Living OS overlay | — |
+
+<!-- aither-ecosystem:end -->

{awgit-1.2.0 → awgit-1.3.0}/awgit.egg-info/SOURCES.txt

@@ -65,4 +65,5 @@ tests/test_owners_and_proof.py
 tests/test_push_is_the_pull_request.py
 tests/test_restack_repairs_orphans.py
 tests/test_review_threads_survive_moves.py
+tests/test_tabular.py
 tests/test_worktree_zombie_detection.py

{awgit-1.2.0 → awgit-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "awgit"
-version = "1.2.0"
+version = "1.3.0"
 description = "Aither World-Graph git — semantic version control on top of git: edit-ops keyed on stable node ids, content-addressed bodies, differential sync."
 readme = "README.md"
 requires-python = ">=3.10"

awgit-1.3.0/tests/test_tabular.py

@@ -0,0 +1,273 @@
+"""Row-level tabular diff — the properties that make it worth having."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+import pytest
+from awgit.tabular import (
+    Table,
+    UnreadableTableError,
+    diff_files,
+    diff_tables,
+    is_tabular,
+    row_content,
+    row_identity,
+)
+
+
+def _csv(tmp_path: Path, name: str, columns, rows) -> Path:
+    p = tmp_path / name
+    with open(p, "w", encoding="utf-8", newline="") as fh:
+        w = csv.DictWriter(fh, fieldnames=columns)
+        w.writeheader()
+        for r in rows:
+            w.writerow(r)
+    return p
+
+
+def _t(columns, rows) -> Table:
+    return Table(columns=list(columns), rows=[dict(r) for r in rows])
+
+
+# --- the encoding property everything else rests on -------------------------
+
+def test_encoding_is_injective_across_field_boundaries():
+    """Two different rows must never share a content address.
+
+    The values below are chosen so that a naive `name + value` concatenation
+    produces the SAME byte string for both rows — the second row's value absorbs
+    the next column's name:
+
+        x="ay", y="b"  -> "x" "ay" "y" "b"  -> xayyb
+        x="a",  y="yb" -> "x" "a"  "y" "yb" -> xayyb
+
+    Oxen appends cell bytes into a buffer with no delimiter at all, so it is
+    vulnerable to this class; a real edit hashes as "unchanged". Length-prefixing
+    each name and value makes the encoding injective.
+
+    The first version of this test used ("ab","c") vs ("a","bc"), which does NOT
+    collide once column names are interleaved — it passed even with the encoder
+    deliberately broken. A mutation run caught it. An assertion that cannot fail
+    is worse than no assertion, because it reads as coverage.
+    """
+    cols = ["x", "y"]
+    a = row_content({"x": "ay", "y": "b"}, cols)
+    b = row_content({"x": "a", "y": "yb"}, cols)
+    assert a != b
+
+
+def test_null_collides_with_nothing():
+    """A null must differ from an empty cell AND from the literal text "None".
+
+    The second half is the one that needs the sentinel. Without it, `None` falls
+    through to `str(None)` and hashes as the four characters "None" — so a data
+    cell whose value really is the string "None" (common in exported CSVs, and
+    in any column of Python reprs) becomes indistinguishable from a missing
+    value. A first version of this test asserted only `None != ""`, which passes
+    even with the sentinel removed; a mutation run caught that it proved nothing.
+    """
+    cols = ["x"]
+    null = row_content({"x": None}, cols)
+    assert null != row_content({"x": ""}, cols)
+    assert null != row_content({"x": "None"}, cols)
+
+
+def test_content_is_order_stable_but_column_sensitive():
+    assert row_content({"a": 1, "b": 2}, ["a", "b"]) == row_content({"b": 2, "a": 1}, ["a", "b"])
+    assert row_content({"a": 1, "b": 2}, ["a", "b"]) != row_content({"a": 1, "b": 2}, ["b", "a"])
+
+
+# --- identity ---------------------------------------------------------------
+
+def test_identity_ignores_non_key_columns():
+    keys = ["id"]
+    assert row_identity({"id": "7", "v": "a"}, keys) == row_identity({"id": "7", "v": "b"}, keys)
+
+
+def test_identity_is_none_without_keys():
+    """The Oxen tie-break: no keys means NO identity, not identity==content.
+
+    Collapsing the two would make every edit look like an unrelated add+remove
+    while still claiming to be a keyed diff.
+    """
+    assert row_identity({"a": 1}, []) is None
+
+
+# --- the diff ---------------------------------------------------------------
+
+def test_reordering_rows_is_not_a_change():
+    """The whole point. A line diff calls this a total rewrite."""
+    old = _t(["id", "v"], [{"id": "1", "v": "a"}, {"id": "2", "v": "b"}])
+    new = _t(["id", "v"], [{"id": "2", "v": "b"}, {"id": "1", "v": "a"}])
+    d = diff_tables(old, new, ["id"])
+    assert not d.changed
+    assert d.unchanged == 2
+
+
+def test_modified_row_is_modified_not_add_plus_remove():
+    old = _t(["id", "v"], [{"id": "1", "v": "a"}])
+    new = _t(["id", "v"], [{"id": "1", "v": "b"}])
+    d = diff_tables(old, new, ["id"])
+    assert len(d.modified) == 1 and not d.added and not d.removed
+    before, after = d.modified[0]
+    assert before["v"] == "a" and after["v"] == "b"
+
+
+def test_add_and_remove_are_detected():
+    old = _t(["id"], [{"id": "1"}, {"id": "2"}])
+    new = _t(["id"], [{"id": "2"}, {"id": "3"}])
+    d = diff_tables(old, new, ["id"])
+    assert [r["id"] for r in d.added] == ["3"]
+    assert [r["id"] for r in d.removed] == ["1"]
+    assert d.unchanged == 1
+
+
+def test_column_change_is_reported_separately_from_rows():
+    """Adding a column must not make every row read as MODIFIED-for-no-reason...
+
+    ...but it IS a change to the rows that gain a value, so it shows in both
+    places: the schema delta names the column, and the affected rows appear as
+    modified. Silence in either place would be the bug.
+    """
+    old = _t(["id"], [{"id": "1"}])
+    new = _t(["id", "extra"], [{"id": "1", "extra": "x"}])
+    d = diff_tables(old, new, ["id"])
+    assert d.columns_added == ["extra"] and d.columns_removed == []
+    assert len(d.modified) == 1
+
+
+def test_keyless_diff_is_honest_about_what_it_cannot_see():
+    """With no keys: content set diff, and `modified` stays EMPTY by design."""
+    old = _t(["v"], [{"v": "a"}])
+    new = _t(["v"], [{"v": "b"}])
+    d = diff_tables(old, new, [])
+    assert d.keyless is True
+    assert len(d.added) == 1 and len(d.removed) == 1
+    assert d.modified == []
+
+
+def test_key_column_absent_from_both_sides_raises():
+    """Rather than reporting every row added+removed, which looks like data loss."""
+    old = _t(["a"], [{"a": "1"}])
+    new = _t(["a"], [{"a": "2"}])
+    with pytest.raises(UnreadableTableError):
+        diff_tables(old, new, ["nope"])
+
+
+# --- file level -------------------------------------------------------------
+
+def test_diff_files_roundtrip(tmp_path: Path):
+    old = _csv(tmp_path, "old.csv", ["id", "v"], [{"id": "1", "v": "a"},
+                                                  {"id": "2", "v": "b"}])
+    new = _csv(tmp_path, "new.csv", ["id", "v"], [{"id": "2", "v": "B"},
+                                                  {"id": "3", "v": "c"}])
+    d = diff_files(old, new, ["id"])
+    s = d.summary()
+    # id=1 gone -> removed; id=2 value changed -> modified; id=3 new -> added.
+    assert (s["added"], s["removed"], s["modified"], s["unchanged"]) == (1, 1, 1, 0)
+    assert d.added[0]["id"] == "3"
+    assert d.removed[0]["id"] == "1"
+    before, after = d.modified[0]
+    assert before["v"] == "b" and after["v"] == "B"
+
+
+def test_headerless_file_raises_rather_than_reporting_zero_rows(tmp_path: Path):
+    p = tmp_path / "empty.csv"
+    p.write_text("", encoding="utf-8")
+    with pytest.raises(UnreadableTableError):
+        diff_files(p, p, ["id"])
+
+
+def test_missing_file_raises(tmp_path: Path):
+    with pytest.raises(UnreadableTableError):
+        diff_files(tmp_path / "nope.csv", tmp_path / "nope.csv", [])
+
+
+def test_tracking_type_split():
+    assert is_tabular("a/b/data.csv") and is_tabular("x.PARQUET") and is_tabular("t.tsv")
+    assert not is_tabular("module.py") and not is_tabular("photo.png")
+
+
+# --- the guards that prove the guards ---------------------------------------
+#
+# Every assertion above is only worth what it CATCHES. Two of them were vacuous
+# when first written — they passed with the code deliberately broken — and that
+# was found by mutating the module by hand, once, in a throwaway script. A guard
+# that ran once is not a guard, so the mutants live here and run on every suite.
+#
+# This is the same shape as dev/tests/test_event_loop_offload_contract.py, whose
+# every claim carries a mutation reproducing the old defect.
+
+_MUTANTS = {
+    # The encoding property. Reverting to Oxen's delimiter-free concatenation
+    # must break the injectivity test.
+    "naive concat (no length prefix)": (
+        'return b"%d:%s=%d:%s;" % (len(n), n, len(v), v)',
+        "return n + v",
+    ),
+    # The NULL sentinel. Without it None falls through to str(None) == "None".
+    "null falls through to str()": (
+        "if value is None:",
+        "if False:",
+    ),
+    # Identity must read the KEY columns, not the whole row.
+    "identity ignores the key list": (
+        "return _digest((k, row.get(k)) for k in keys)",
+        "return _digest((c, row.get(c)) for c in sorted(row))",
+    ),
+    # No keys must mean NO identity, not a constant one.
+    "keyless fabricates an identity": (
+        "if not keys:\n        return None",
+        "if not keys:\n        return _digest([])",
+    ),
+    # A changed row must not be counted as unchanged.
+    "modified counted as unchanged": (
+        "out.modified.append((old_row, new_row))",
+        "out.unchanged += 1",
+    ),
+}
+
+
+@pytest.mark.parametrize("label", sorted(_MUTANTS))
+def test_suite_catches_mutant(label: str, tmp_path: Path):
+    """Break the module one way; the rest of this file must go red.
+
+    Runs the suite in a SUBPROCESS against a mutated copy of the package, so the
+    already-imported module in this process is untouched and the mutation cannot
+    leak into another test.
+    """
+    import shutil
+    import subprocess
+    import sys
+
+    import awgit.tabular as mod
+
+    old, new = _MUTANTS[label]
+    original = Path(mod.__file__).read_text(encoding="utf-8")
+    assert old in original, (
+        f"mutation anchor for {label!r} no longer matches the source — the "
+        f"mutant silently became a no-op, which is how a mutation suite starts "
+        f"proving nothing"
+    )
+
+    pkg_root = Path(mod.__file__).resolve().parents[1]
+    sandbox = tmp_path / "sandbox"
+    shutil.copytree(pkg_root, sandbox / "awgit",
+                    ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+    shutil.copy2(Path(__file__), sandbox / "test_tabular.py")
+    (sandbox / "awgit" / "tabular.py").write_text(
+        original.replace(old, new, 1), encoding="utf-8")
+
+    # -k excludes THIS test, or the subprocess would recurse into itself.
+    proc = subprocess.run(
+        [sys.executable, "-m", "pytest", "test_tabular.py", "-q",
+         "-k", "not catches_mutant", "-p", "no:cacheprovider"],
+        cwd=sandbox, capture_output=True, text=True,
+        encoding="utf-8", errors="replace", timeout=180,
+    )
+    assert proc.returncode != 0, (
+        f"MUTANT SURVIVED: {label}. The suite passed with the module broken this "
+        f"way, so whichever assertion covers it is vacuous.\n{proc.stdout[-1500:]}"
+    )