awgit 1.2.0__tar.gz → 1.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awgit
-Version: 1.2.0
+Version: 1.4.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
@@ -17,6 +17,16 @@ Dynamic: license-file
 
 # awgit — the git that knows a function from a line
 
+<!-- aither-header:start GENERATED from the ecosystem registry. Edits here are overwritten; change the registry instead. -->
+
+**[Docs](https://aitherium.github.io/awgit/)**  ·  [Source](https://github.com/Aitherium/awgit)  ·  `pip install awgit`  ·  [The Aither World](https://aitherium.github.io/)
+
+> **The Aither World** is an operating system for agents — a Linux you can hand to one, the runtimes it works in, and the tools it works with. [awnix](https://github.com/Aitherium/awnix) is the Linux underneath it; **awgit** is one of its 33 bricks — each installs on its own, runs offline, and needs no account.
+>
+> **Start here:** Take a lease on a file before you edit it in a shared checkout.
+
+<!-- aither-header:end -->
+
 Git has no world model. It knows which lines moved, not what a function is — so
 "which commit owns this edit", "did this change conflict with mine", and "is
 this the same change I pushed before" are all answered by heuristics over text.
@@ -264,3 +274,91 @@ 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 |
+| [awkno](https://github.com/Aitherium/awkno) | that the docs site is up, or that you remember the family | the whole ecosystem in your terminal, with no network 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 |
+| [awreason](https://github.com/Aitherium/awreason) | a confident paragraph | the phases it went through, and every tool call it made to get there |
+| [awrecurse](https://github.com/Aitherium/awrecurse) | that everything you pasted in was actually read | which slices it opened, and what it concluded from each |
+| [awprism](https://github.com/Aitherium/awprism) | the first explanation that fits | the ranked alternatives, and the observation that separates them |
+| [awrepl](https://github.com/Aitherium/awrepl) | what the agent believes the value is | the value, printed from the live session |
+| [awresearch](https://github.com/Aitherium/awresearch) | a summary of pages nobody opened | every claim against the source it came from |
+| [awpredict](https://github.com/Aitherium/awpredict) | a model because it trained without erroring | its prediction against a self-updating lookup, on the rows that are actually novel |
+| [awkno](https://github.com/Aitherium/awkno) | that the docs site is up, or that you remember the family | the whole ecosystem in your terminal, with no network at all |
+
+[**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/) |
+| [awdit](https://github.com/Aitherium/awdit) | An append-only audit trail whose gaps are DETECTABLE | [docs](https://aitherium.github.io/awdit/) |
+| [awbac](https://github.com/Aitherium/awbac) | Role-based access control that fails closed and explains itself | [docs](https://aitherium.github.io/awbac/) |
+| [awiam](https://github.com/Aitherium/awiam) | Who is this caller? A directory and session store that fails honestly | [docs](https://aitherium.github.io/awiam/) |
+| [awtunnel](https://github.com/Aitherium/awtunnel) | Reach a service that has no public address | [docs](https://aitherium.github.io/awtunnel/) |
+| [awnest](https://github.com/Aitherium/awnest) | Prove there is a human before you let them into the nest | [docs](https://aitherium.github.io/awnest/) |
+| [awnboard](https://github.com/Aitherium/awnboard) | A front gate you can put in front of anything, and hand someone the key to | [docs](https://aitherium.github.io/awnboard/) |
+| [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/) |
+| [awkno](https://github.com/Aitherium/awkno) | The man page for the Aither World — every brick, stack and law, offline | [docs](https://aitherium.github.io/awkno/) |
+| [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 | [docs](https://aitherium.github.io/awmail/) |
+| [awnet](https://github.com/Aitherium/awnet) | The agentic web — agents host a mesh, and agents join one | [docs](https://aitherium.github.io/awnet/) |
+| [awfind](https://github.com/Aitherium/awfind) | A portable search client — query, results, ranking | [docs](https://aitherium.github.io/awfind/) |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | A portable browser client — navigate, console, network, DOM, screenshot | [docs](https://aitherium.github.io/awbrowse/) |
+| [awknowledge](https://github.com/Aitherium/awknowledge) | How to run a coding agent so the result survives — the laws, with evidence | [docs](https://aitherium.github.io/awknowledge/) |
+| [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 | [docs](https://aitherium.github.io/AitherConnect/) |
+| [awreason](https://github.com/Aitherium/awreason) | A portable reasoning client — sessions, phases, thoughts, and the chain that produced the answer | [docs](https://aitherium.github.io/awreason/) |
+| [awrecurse](https://github.com/Aitherium/awrecurse) | Answer a question over a context far larger than the window — recursively, with the trace kept | [docs](https://aitherium.github.io/awrecurse/) |
+| [awprism](https://github.com/Aitherium/awprism) | Turn a failure into ranked hypotheses — and say what would confirm each one | [docs](https://aitherium.github.io/awprism/) |
+| [awrepl](https://github.com/Aitherium/awrepl) | A REPL an agent can actually use — state that survives between turns | [docs](https://aitherium.github.io/awrepl/) |
+| [awresearch](https://github.com/Aitherium/awresearch) | Ask a research question, get a cited report you can check | [docs](https://aitherium.github.io/awresearch/) |
+| [awpredict](https://github.com/Aitherium/awpredict) | Predict what your environment does next, and how surprised you were | [docs](https://aitherium.github.io/awpredict/) |
+| [awkno](https://github.com/Aitherium/awkno) | The man page for the Aither World — every brick, stack and law, offline | [docs](https://aitherium.github.io/awkno/) |
+
+<div id="aither-constellation" data-self="awgit"></div>
+<script src="aither-constellation.js"></script>
+
+<!-- aither-ecosystem:end -->

awgit-1.4.0/README.md

@@ -0,0 +1,347 @@
+# awgit — the git that knows a function from a line
+
+<!-- aither-header:start GENERATED from the ecosystem registry. Edits here are overwritten; change the registry instead. -->
+
+**[Docs](https://aitherium.github.io/awgit/)**  ·  [Source](https://github.com/Aitherium/awgit)  ·  `pip install awgit`  ·  [The Aither World](https://aitherium.github.io/)
+
+> **The Aither World** is an operating system for agents — a Linux you can hand to one, the runtimes it works in, and the tools it works with. [awnix](https://github.com/Aitherium/awnix) is the Linux underneath it; **awgit** is one of its 33 bricks — each installs on its own, runs offline, and needs no account.
+>
+> **Start here:** Take a lease on a file before you edit it in a shared checkout.
+
+<!-- aither-header:end -->
+
+Git has no world model. It knows which lines moved, not what a function is — so
+"which commit owns this edit", "did this change conflict with mine", and "is
+this the same change I pushed before" are all answered by heuristics over text.
+
+**awgit rides on top of git** (git stays the byte-truth, the transport, the
+history) and adds the layer above it: a **world model as the database**,
+**semantic edit-ops as transactions**, **stacked commits with one pull request
+each**, **verified identity**, and **leases** so several agents can work in one
+tree without overwriting each other.
+
+```bash
+pip install awgit
+awgit init            # verify the actor, install the capture hooks
+```
+
+Needs Python 3.10+ and `git`. `gh` (the GitHub CLI) is needed for `push` and
+`pr`, and for the verified identity — everything else works without it.
+
+## The model in one screen
+
+```bash
+awgit stack                  # your commits above trunk — one PR each
+awgit commit -m "fix parser" # git commit, lease-checked and captured
+awgit push                   # one pull request per commit (dry run; --apply)
+awgit absorb                 # route pending edits into the commits they belong to
+awgit pr wait 42 --for merged
+```
+
+There is no `awgit pr create`. **Push is how a pull request is opened**, and
+pushing again after `commit --amend` adds a REVISION to the same PR rather than
+opening a second one.
+
+## Stacked commits
+
+Work is a stack of commits between trunk and HEAD, each one a reviewable change
+that becomes its own pull request, diffed against the commit below it. A
+reviewer reads one logical change instead of a 900-line branch, and the bottom
+of a stack can land while the top is still being argued about.
+
+| | |
+|---|---|
+| `awgit stack` / `awgit sl` | the stack, newest first, with each commit's Change-Id |
+| `awgit prev` / `awgit next` | move down / up the stack |
+| `awgit push` | publish it — one PR per commit |
+| `awgit absorb` | fold pending edits into the commits that own them |
+| `awgit uncommit` | undo the last commit, keep its changes |
+| `awgit restack` / `awgit pull` | rebase onto trunk (`pull` fetches first) |
+| `awgit worktree new` (also `list`, `rm`) | a checkout of your own |
+
+### Identity that survives a rewrite
+
+Every commit carries an `Awgit-Change-Id` trailer, written once by a
+`prepare-commit-msg` hook. A sha identifies a *snapshot*; the Change-Id
+identifies the *change*, and it survives `--amend`, `rebase` and `cherry-pick` —
+which is what lets `push` find the pull request you already opened instead of
+opening another one.
+
+```bash
+awgit change-id show          # this commit's change id
+awgit change-id find I3f2a…   # every commit carrying it
+```
+
+### absorb routes by node, not by line
+
+git answers "which commit owns this change" per LINE, so reindenting a function
+makes every line blame the reformat. awgit asks which commit last changed **this
+node**, so the answer survives reindentation and line movement, and a rename
+within a file. (A function moved to a *different* file gets a new node id —
+capture's rename detection is per-file — so absorb sees a delete and an add.)
+
+```bash
+awgit absorb                 # show the routing
+awgit absorb --apply         # create the fixups and autosquash
+```
+
+Generated and minified files are skipped and reported — they have no node
+identity, and one bundle can stall a parser indefinitely.
+
+## Review that survives the code moving
+
+```bash
+awgit review show                                   # threads on this change
+awgit review comment --node <id> -b "needs a bound" # a DRAFT
+awgit review submit                                 # publish them all at once
+awgit review resolve <thread>
+```
+
+A comment is anchored to a **node**, not to a line. The line number is computed
+each time from where the node is now, so a thread follows the function down the
+file as code is inserted above it, survives a rebase and a reformat, and is
+re-found when the function moves to another file. A thread whose node was
+DELETED is shown as `[orphaned]` with its text intact — "the function you
+objected to is gone" is a review outcome, not a reason to hide the objection.
+
+Comments are drafts until `submit`, so you can read a whole diff and publish
+once. **Unresolved threads block `awgit pr merge`**: "merge and follow up" is
+how an objection becomes a TODO nobody files.
+
+Node ids come from capture, so comment on a node the diff showed you
+(`awgit diff <a> <b> --json`).
+
+## Big repositories
+
+```bash
+awgit clone <url> <dest> --paths AitherOS/lib   # history now, contents on demand
+awgit sparse add apps/web                       # materialise more
+awgit sparse status                             # is this clone ACTUALLY lazy?
+```
+
+`awgit clone` uses git's own partial clone (`--filter=blob:none`) with a cone
+sparse-checkout: history and trees arrive immediately, file content is fetched
+the first time something reads it, and the working tree holds only the
+directories you asked for.
+
+This is deliberately not a virtual filesystem. A VFS means FUSE on Linux and
+ProjFS on Windows — and Microsoft, who wrote both ProjFS and VFSforGit, retired
+that approach in favour of exactly this pair. Reimplementing what its own author
+walked away from would trade a supported git feature for a kernel-adjacent
+dependency on the platform where it is least reliable.
+
+**`sparse status` reads the repository, not the flag you passed.**
+`git clone --filter` succeeds and warns when a server declines to filter — you
+get a full clone and exit 0. awgit reports lazy only when the filter is really
+in the config and a promisor remote really exists to backfill from.
+
+## Landing it: evidence, ownership, the queue
+
+```bash
+awgit prove                  # what this change touched, and what checked it
+awgit owners <path>          # who owns it — declared AND measured
+awgit code def <symbol>      # where it is defined
+awgit queue enqueue 42       # GitHub's merge queue
+awgit ci status
+```
+
+**`awgit prove` is proof-carrying review.** A pull request normally arrives as a
+diff and an assertion; "all checks passed" and "no checks ran" render almost
+identically. `prove` attaches the nodes the change touched and what each gate
+actually returned — and it never reports success without evidence: a gate that
+exits 1 is a violation, a gate that exits 2 *could not judge*, and no gates at
+all is **not proved** (exit 2), because "nothing verified this" must not be
+spelled the same way as "verified". `--markdown` renders it as a PR comment.
+
+Your gate runner attaches through the plugin seam, so awgit never has to know
+what your checks are:
+
+```python
+from awgit import plugins
+plugins.register(plugins.GATES, lambda paths: [{"name": "ruff", "status": "ok"}])
+```
+
+**`awgit owners` shows both answers.** CODEOWNERS says who *should* review;
+the op-log knows who actually changed those nodes, weighted so ownership decays
+(someone who last touched a module a year ago is not who you want reviewing it).
+When the two disagree, that is the useful part — usually the file is stale.
+
+`awgit queue` drives **GitHub's** merge queue rather than reimplementing one: it
+already rebases, re-tests and lands, and a second implementation would be a
+service that disagrees with it.
+
+## Working next to other people (and other agents)
+
+A lease says "I am editing this". Take one **before** you edit: the baseline it
+captures is what lets `stage-mine` separate your work from a peer's.
+
+```bash
+awgit lease list                    # who holds what right now
+awgit lease acquire <paths>         # claim files, TTL-renewed
+awgit stage-mine <path>             # stage only YOUR edits to a shared file
+```
+
+History rewrites (`absorb`, `uncommit`, `restack`, `pull`) refuse when another
+actor holds a lease in the same worktree, and point you at `awgit worktree new`.
+A solo checkout has no other actors and rewrites freely; set
+`AWGIT_ALLOW_UNSAFE_REWRITE=1` to override.
+
+## The world model
+
+Every commit is captured as an `EditOp`: which functions/classes/methods
+changed, their old and new bodies by content address, the actor, the parent
+chain. Ops key on **stable node ids** that survive renames and moves.
+
+```bash
+awgit status                  # op-log status
+awgit diff <sha> <sha>        # NODE-level diff (not a text diff — see below)
+awgit graph --format mermaid  # the op-log as a graph
+awgit ledger --sha <sha>      # who changed what, under a verified identity
+awgit evidence                # the measurable claim, from your own op-log
+awgit bodies --get <sha>      # read a body from the content-addressed store
+awgit dedupe --scan <trees>   # quantify duplication; --reclaim to hard-link
+```
+
+- **Merge** at node granularity: disjoint node sets merge clean by
+  construction, and a genuine collision escalates naming the exact function
+  (`awgit merge-preview`, `awgit merge-conflicts`, `awgit resolve-conflict`).
+- **Differential sync**: `awgit sync export` emits the ops a peer is missing
+  plus the bodies they reference; `awgit sync import` applies idempotently.
+
+## It speaks git
+
+Everyday verbs forward to git untouched — `awgit log`, `awgit add`,
+`awgit show`, `awgit rebase`, and about twenty more — and `awgit git -- <args>`
+runs anything else.
+
+**No verb is repurposed.** `awgit diff` has always meant a node-level diff and
+still does; git's own diff is `awgit git diff`. `awgit status` reports the
+op-log. Silently changing what an existing command returns would break callers
+in ways that surface far from the change.
+
+## For agents
+
+```bash
+awgit commands --json    # the entire CLI as JSON: every command, flag and type
+```
+
+Read it once instead of scraping `--help`. It is introspected from the live
+parser, so a command cannot be described unless it exists. Every read-only
+command takes `--json`.
+
+`awgit pr wait <n> --for merged` exits **0** when the condition holds and
+**124** on timeout, so a loop can tell "it happened" from "I gave up".
+
+## Set up
+
+```bash
+awgit init                # verify the actor, install hooks, report the store
+awgit hooks install       # chained hooks — preserves any you already have
+                          #   post-commit  -> `awgit capture` (records the op)
+                          #   pre-commit   -> `awgit lease-check` (the lease gate)
+                          #   prepare-commit-msg -> stamps the Change-Id
+awgit hooks uninstall     # restore them
+awgit version --json
+```
+
+The durable store lives **outside** the git tree at `~/.aither/awgit/data`
+(override with `VCS_DATA_ROOT`), so the op-log and body store never pollute your
+repository or your clones.
+
+## Tests
+
+```bash
+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 |
+| [awkno](https://github.com/Aitherium/awkno) | that the docs site is up, or that you remember the family | the whole ecosystem in your terminal, with no network 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 |
+| [awreason](https://github.com/Aitherium/awreason) | a confident paragraph | the phases it went through, and every tool call it made to get there |
+| [awrecurse](https://github.com/Aitherium/awrecurse) | that everything you pasted in was actually read | which slices it opened, and what it concluded from each |
+| [awprism](https://github.com/Aitherium/awprism) | the first explanation that fits | the ranked alternatives, and the observation that separates them |
+| [awrepl](https://github.com/Aitherium/awrepl) | what the agent believes the value is | the value, printed from the live session |
+| [awresearch](https://github.com/Aitherium/awresearch) | a summary of pages nobody opened | every claim against the source it came from |
+| [awpredict](https://github.com/Aitherium/awpredict) | a model because it trained without erroring | its prediction against a self-updating lookup, on the rows that are actually novel |
+| [awkno](https://github.com/Aitherium/awkno) | that the docs site is up, or that you remember the family | the whole ecosystem in your terminal, with no network at all |
+
+[**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/) |
+| [awdit](https://github.com/Aitherium/awdit) | An append-only audit trail whose gaps are DETECTABLE | [docs](https://aitherium.github.io/awdit/) |
+| [awbac](https://github.com/Aitherium/awbac) | Role-based access control that fails closed and explains itself | [docs](https://aitherium.github.io/awbac/) |
+| [awiam](https://github.com/Aitherium/awiam) | Who is this caller? A directory and session store that fails honestly | [docs](https://aitherium.github.io/awiam/) |
+| [awtunnel](https://github.com/Aitherium/awtunnel) | Reach a service that has no public address | [docs](https://aitherium.github.io/awtunnel/) |
+| [awnest](https://github.com/Aitherium/awnest) | Prove there is a human before you let them into the nest | [docs](https://aitherium.github.io/awnest/) |
+| [awnboard](https://github.com/Aitherium/awnboard) | A front gate you can put in front of anything, and hand someone the key to | [docs](https://aitherium.github.io/awnboard/) |
+| [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/) |
+| [awkno](https://github.com/Aitherium/awkno) | The man page for the Aither World — every brick, stack and law, offline | [docs](https://aitherium.github.io/awkno/) |
+| [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 | [docs](https://aitherium.github.io/awmail/) |
+| [awnet](https://github.com/Aitherium/awnet) | The agentic web — agents host a mesh, and agents join one | [docs](https://aitherium.github.io/awnet/) |
+| [awfind](https://github.com/Aitherium/awfind) | A portable search client — query, results, ranking | [docs](https://aitherium.github.io/awfind/) |
+| [awbrowse](https://github.com/Aitherium/awbrowse) | A portable browser client — navigate, console, network, DOM, screenshot | [docs](https://aitherium.github.io/awbrowse/) |
+| [awknowledge](https://github.com/Aitherium/awknowledge) | How to run a coding agent so the result survives — the laws, with evidence | [docs](https://aitherium.github.io/awknowledge/) |
+| [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 | [docs](https://aitherium.github.io/AitherConnect/) |
+| [awreason](https://github.com/Aitherium/awreason) | A portable reasoning client — sessions, phases, thoughts, and the chain that produced the answer | [docs](https://aitherium.github.io/awreason/) |
+| [awrecurse](https://github.com/Aitherium/awrecurse) | Answer a question over a context far larger than the window — recursively, with the trace kept | [docs](https://aitherium.github.io/awrecurse/) |
+| [awprism](https://github.com/Aitherium/awprism) | Turn a failure into ranked hypotheses — and say what would confirm each one | [docs](https://aitherium.github.io/awprism/) |
+| [awrepl](https://github.com/Aitherium/awrepl) | A REPL an agent can actually use — state that survives between turns | [docs](https://aitherium.github.io/awrepl/) |
+| [awresearch](https://github.com/Aitherium/awresearch) | Ask a research question, get a cited report you can check | [docs](https://aitherium.github.io/awresearch/) |
+| [awpredict](https://github.com/Aitherium/awpredict) | Predict what your environment does next, and how surprised you were | [docs](https://aitherium.github.io/awpredict/) |
+| [awkno](https://github.com/Aitherium/awkno) | The man page for the Aither World — every brick, stack and law, offline | [docs](https://aitherium.github.io/awkno/) |
+
+<div id="aither-constellation" data-self="awgit"></div>
+<script src="aither-constellation.js"></script>
+
+<!-- aither-ecosystem:end -->

awgit-1.4.0/awgit/__main__.py

@@ -0,0 +1,31 @@
+"""`python -m awgit` — the invocation that still works when the console shim does not.
+
+WHY THIS EXISTS
+
+Measured 2026-08-21: `awgit.exe` on this host exits 126 from bash and, asked directly,
+PowerShell says why -- "An Application Control policy has blocked this file". WDAC blocks
+the freshly generated shim, so `pip install -e` cannot repair it: reinstalling regenerates
+the same blocked binary.
+
+That matters more than a broken convenience. The pre-commit lease gate is invoked as
+`awgit lease acquire <file>`, so with the shim blocked EVERY commit in this repo either
+fails the gate or has to be talked around one file at a time -- while `pip show`, `import
+awgit` and `shutil.which('awgit')` all report the tool perfectly healthy. That is the
+"looks installed, fails on first real use" shape the tooling checker was written for, one
+level below where it was looking; ATI006 now asserts the shim actually RUNS.
+
+A module entry point needs no shim, no new executable and no security-policy exception:
+`python -m awgit ...` goes through the interpreter, which is already trusted. Anything
+that shells the console script keeps working unchanged where the policy allows it.
+
+Kept to a delegation on purpose -- the CLI lives in `cli.py` and having two entry points
+that can disagree about argument handling is its own defect.
+"""
+from __future__ import annotations
+
+import sys
+
+from awgit.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

awgit-1.4.0/awgit/_doctor.py

@@ -0,0 +1,139 @@
+"""Stack-aware `doctor` for awgit.
+
+GENERATED BY gen_aw_doctor.py -- DO NOT EDIT.
+Regenerate it with the generator named above; a hand-edit here is reverted by
+the next run and fails the parity gate.
+
+Why a doctor exists at all: the aw* bricks are designed to COMPOSE, so the
+interesting failures live BETWEEN them. "awgit is installed" is not the useful
+fact -- "awgit is installed and the thing it pairs with is not" is. This reports
+the whole stack, not just itself.
+
+stdlib only, on purpose: a diagnostic that cannot run because a dependency is
+missing is worthless precisely when you need it.
+"""
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+import sys
+
+#: Frozen from AitherOS/config/ecosystem.yaml at generation time. A shipped
+#: package cannot read the registry, and a doctor that guessed at the family
+#: would go stale in silence. Regenerate to update.
+SELF = 'awgit'
+FAMILY = ['awask', 'awask', 'awbac', 'awbrowse', 'awdit', 'awevolve', 'awevolve', 'awfind', 'awgraph', 'awiam', 'awkno', 'awm', 'awmail', 'awnboard', 'awnest', 'awnet', 'awnode', 'awpredict', 'awprism', 'awreason', 'awrecover', 'awrecurse', 'awrelay', 'awrepl', 'awresearch', 'awrun', 'awseal', 'awshare', 'awtunnel']
+PAIRS_WITH = ['awgraph', 'awrelay']
+
+#: This brick's OWN config, read out of its source at generation time.
+#: ENV_REQUIRED is `os.environ["X"]` -- absent, that is a KeyError the moment
+#: the line runs. ENV_OPTIONAL is `os.getenv("X")`, which returns None and lets
+#: the caller cope. Only this brick's namespace is listed: reporting the
+#: platform-wide vars it also touches would be noise, and a doctor that floods
+#: gets ignored.
+ENV_REQUIRED = []
+ENV_OPTIONAL = []
+
+
+def _installed(mod: str) -> "str | None":
+    """Version if importable, else None. Never raises -- a broken sibling must
+    not take the diagnostic down with it."""
+    try:
+        if importlib.util.find_spec(mod) is None:
+            return None
+    except (ImportError, ValueError):
+        return None
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+        try:
+            return version(mod)
+        except PackageNotFoundError:
+            return "installed"
+    except Exception:
+        return "installed"
+
+
+def report(out=None) -> int:
+    """Print the stack picture. 0 = this brick and its pairs are present."""
+    out = out or sys.stdout
+    print(f"{SELF} doctor", file=out)
+
+    mine = _installed(SELF)
+    print(f"  self       {SELF} {mine or 'NOT IMPORTABLE'}", file=out)
+    shim = shutil.which(SELF)
+    print(f"  command    {shim or 'not on PATH'}", file=out)
+
+    # The stack. Siblings this brick pairs with are called out separately,
+    # because a missing pair is a REASON, while a missing unrelated brick is
+    # just a fact about your machine.
+    missing_pairs, present = [], []
+    for name in FAMILY:
+        v = _installed(name)
+        if v:
+            present.append(name)
+        elif name in PAIRS_WITH:
+            missing_pairs.append(name)
+    print(f"  stack      {len(present)}/{len(FAMILY)} aw* packages installed",
+          file=out)
+    if present:
+        print(f"             {' '.join(sorted(present))}", file=out)
+
+    missing_req = [v for v in ENV_REQUIRED if not os.environ.get(v)]
+    if ENV_REQUIRED or ENV_OPTIONAL:
+        have = sum(1 for v in ENV_REQUIRED + ENV_OPTIONAL if os.environ.get(v))
+        total = len(ENV_REQUIRED) + len(ENV_OPTIONAL)
+        print(f"  config     {have}/{total} of this brick's own vars set", file=out)
+        if missing_req:
+            # Not a preference. os.environ[...] raises the moment it runs.
+            print(f"             MISSING REQUIRED: {' '.join(missing_req)}", file=out)
+
+    local = _local_checks()
+    for line in local:
+        print(f"  {line}", file=out)
+
+    if mine is None:
+        print(f"\nverdict: {SELF} itself is not importable. Reinstall it before "
+              f"anything else here means much.", file=out)
+        return 1
+    if missing_req:
+        print(f"\nverdict: {SELF} is missing required config "
+              f"({', '.join(missing_req)}). Those are read with os.environ[...], "
+              f"so the code path that needs them raises rather than degrades.",
+              file=out)
+        return 1
+    if missing_pairs:
+        print(f"\nverdict: {SELF} works, but pairs with "
+              f"{', '.join(sorted(missing_pairs))} which "
+              f"{'is' if len(missing_pairs) == 1 else 'are'} not installed. "
+              f"That is a capability you are missing, not an error.", file=out)
+        return 0
+    print(f"\nverdict: {SELF} and everything it pairs with are present.", file=out)
+    return 0
+
+
+def _local_checks() -> "list[str]":
+    """Per-brick checks, if this package defines them.
+
+    Kept as a HOOK rather than generated guesses: the generator knows the family
+    from the registry, but it does not know what awgit needs at runtime, and a
+    doctor that invented config requirements would be confidently wrong. A
+    package supplies `_doctor_local()` returning display lines; absent, the
+    stack picture above still stands on its own.
+    """
+    try:
+        mod = importlib.import_module(f"{SELF}.doctor_local")
+    except Exception:
+        return []
+    try:
+        return list(mod._doctor_local())
+    except Exception as exc:                       # noqa: BLE001
+        return [f"local     checks raised {type(exc).__name__}: {exc}"]
+
+
+def main(argv: "list[str] | None" = None) -> int:
+    return report()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())