loopagent-gate 0.4.2__py3-none-any.whl

loopagent_gate-0.4.2.dist-info/METADATA

@@ -0,0 +1,374 @@
+Metadata-Version: 2.4
+Name: loopagent-gate
+Version: 0.4.2
+Summary: Accept agent work by proof, not by confidence: gates that print a marker and refuse to take the agent's word.
+Author: loopagent contributors
+License: MIT
+Project-URL: Repository, https://github.com/mjeksonpx/loopagent
+Project-URL: Issues, https://github.com/mjeksonpx/loopagent/issues
+Keywords: ai-agents,code-review,evidence,gates,ci,verification
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: contracts
+Requires-Dist: jsonschema>=4.18; extra == "contracts"
+Dynamic: license-file
+
+<div align="center">
+
+# loopagent
+
+### Accept agent work by proof, not by confidence.
+
+A stdlib-only gate that refuses to take an agent's word: it runs the commands, prints one marker,
+and exits non-zero until the evidence matches the claim. It ships as a pip package (`loopgate`) with the
+gates inside, plus a skill (`loop-engineering`) that tells an agent how to work inside the loop.
+
+[![license](https://img.shields.io/badge/license-MIT-3DA639?style=for-the-badge)](LICENSE)
+[![python](https://img.shields.io/badge/python-3.9%2B%20%7C%203.12-3776AB?style=for-the-badge&logo=python&logoColor=white)](#install)
+[![dependencies](https://img.shields.io/badge/dependencies-0-6E56CF?style=for-the-badge)](#install)
+[![dimensions](https://img.shields.io/badge/dimensions-14-0B7285?style=for-the-badge)](#the-fourteen-dimensions)
+[![falsifications](https://img.shields.io/badge/falsification%20cases-26-FF6B35?style=for-the-badge)](#sixty-seconds)
+
+</div>
+
+```
+$ python3 -m loopgate.gates.check_loop --strict   # abridged: fourteen dimensions, six shown here
+D01 contract_skill             [OK] .agents/skills/loop-engineering/SKILL.md contract complete
+D02 sources_of_truth           [OK] AGENTS.md + PLANS.md + README.md carry the contract and the gate command
+D03 loop_state                 [OK] artifacts/loop_state.json schema + monotone history ok
+D04 rounds                     [OK] 6 round artifact(s) with bound evidence
+D05 handoff                    [OK] handoff bound to the gate's machine report
+D06 guardrail_no_direct_cli    [OK] no direct CLI-agent invocation in repo code or pasteable commands
+...
+dims: 13 ok, 0 fail, 1 n/a (D08) (mandatory: 12, optional: 2)
+acceptance: strict-complete
+LOOP_ENGINEERING_PASS_0001
+```
+
+> **Two names, one project.** The repository is `loopagent`; the CLI and the Python package are
+> `loopgate` — the name it grew under. Stated once so nobody hunts for a missing package.
+
+---
+
+## Why it exists
+
+An agent produces a plausible pull request faster than a human can read it. *"Tests pass"* is the
+sentence that ends review, and it is not evidence: the tests may not have run, may have run against
+the old tree, may have been skipped, or may cover nothing that changed. The second failure is
+subtler — everything is green and the product does not start.
+
+This repository turns that discipline into commands. Not a checklist, not a prompt: a gate with
+fourteen dimensions, a marker, and an exit code.
+
+## Three verdicts, three questions
+
+| Verdict | Question it answers | Command |
+|---|---|---|
+| **Technical gate** | was the work actually done, on every gate this repository requires? | `python3 -m loopgate.gates.check_loop --strict` |
+| **Product gate** | can a user do their job with it? | `python3 -m loopgate.gates.check_product` |
+| **Change health** | did this change make the tree worse, even though every gate stayed green? | `python3 -m loopgate.gates.change_health` |
+
+Each verdict prints exactly one marker and one exit code. A marker is printed **only** by the gate that
+earned it — an agent that prints `LOOP_ENGINEERING_PASS_0001` itself is a bug, and one of the dimensions
+exists to catch that class of cheating.
+
+## The cycle
+
+```mermaid
+flowchart LR
+    A["Plan: contract filled"] --> B["Build: smallest honest change"]
+    B --> C{"Gate red?"}
+    C -->|"yes: name the dimension"| R["Repair: one gap per round"]
+    R --> C
+    C -->|"no: every dimension ok"| P["Prove: marker + exit 0"]
+    P --> V["Review: a different engine"]
+    V -->|"reject"| R
+    V -->|"accept"| H["Handoff: synthesis + signed anchor"]
+```
+
+`Build → Fail → Repair → Prove → Review → Handoff`. Every round leaves a file with the command, the
+verbatim output and the exit code; knowledge that stays only in a model's context dies with the
+context. The gate is read-only — it may write only when handed an explicit `--report` path — so a
+check can never repair the thing it is checking.
+
+## The fourteen dimensions
+
+| ID | Dimension | What must be true |
+|---|---|---|
+| `D01` | contract_skill | the run contract exists: goal, sources of truth, constraints, done-when, stop-if |
+| `D02` | sources_of_truth | `AGENTS.md`, `PLANS.md` and this README carry the contract and the gate command |
+| `D03` | loop_state | `artifacts/loop_state.json`: schema, `0..100` ranges, phase, marker |
+| `D04` | rounds | ≥3 round artifacts with `Gap / Change / Evidence / Metrics / Next` |
+| `D05` | handoff | handoff bound to the gate's machine report; hash recomputed without `D05` itself |
+| `D06` | guardrail_no_direct_cli | no direct CLI-agent invocation in code or pasteable commands |
+| `D07` | guardrail_no_secrets | no credential-shaped strings anywhere in the tree |
+| `D08` | course_corpus | the study corpus is assembled (N/A — not shipped in this tree) |
+| `D09` | roles_fanout | four role artifacts, each ≥300 chars, each attributed to a run |
+| `D10` | issue_bridge | the brief *inside* the task carries every gate, and the validator is attacked |
+| `D11` | product_gate | user scenarios, each with a `why`; the evaluator is mutated, not trusted |
+| `D12` | anchor_witness | the verdict is signed, and the anchor cannot certify itself |
+| `D13` | visual_gate | headless browser present, screenshots required, 23 fake pages rejected |
+| `D14` | change_health | countable metrics compared to a baseline, in the direction that means "worse" |
+
+A dimension is worth having only if it can fail: every one of them comes with an injection in
+`loopgate/gates/regressions.py` that reddens the gate on *that* dimension. A dimension with no falsification
+case is a slogan.
+
+## Install
+
+```bash
+git clone https://github.com/mjeksonpx/loopagent.git && cd loopagent
+python3 -m loopgate.gates.doctor                   # what this interpreter can run, before yellow is a mystery
+make check                                  # what CI runs: compile + code dimensions + regressions
+```
+
+Nothing to install: no third-party dependency in the core, no daemon, no database, no schema to
+migrate. Optional extras (`jsonschema` for one product scenario) degrade to a `SKIP` **with a stated
+reason**, never to a silent PASS.
+
+One machine prerequisite is not optional: the visual dimension (`D13`) needs **Chrome or Chromium**, and
+`make check` fails without it (`CI_DIMS_STOP_0001`). That is deliberate — a visual check that silently
+skips is worse than none — and `python3 -m loopgate.gates.doctor` names what this interpreter found before
+a red dimension looks like a mystery. `make check` also needs `make` and Python 3.9+.
+
+```bash
+python3 -m loopgate.gates.bootstrap_state --init   # first run: declare the cold start
+# -> LOOP_STATE_COLD_0001   wrote artifacts/loop_state.json: state=cold, round=0
+
+python3 -m loopgate.gates.check_loop --strict
+# -> 8 ok, 0 fail, 5 cold, 1 n/a
+#    cold start: 5 state dimension(s) cannot be proven in this tree (D03, D04, D05, D09, D12)
+#    LOOP_ENGINEERING_COLD_0001        exit 0
+```
+
+A fresh clone answers `COLD`, not `PASS`. That is the design: round artifacts, the handoff and the
+signed anchor are evidence of *a run*, not source, so they live in gitignored state. As soon as one
+round exists, the declaration is refused — a cold start cannot hide a broken loop behind an empty
+directory.
+
+```bash
+pip install -e ".[contracts]"               # optional: the `loopgate` command
+loopgate gate --strict                      # identical to the module; the command only names it
+loopgate status                             # both verdicts + the queue on one operator page
+loopgate --repo ../other gate --strict      # judge another project instead of the working directory
+```
+
+## Use it in another project
+
+The gates ship inside the package, so a project does not need a copy of this repository:
+
+```bash
+pip install loopagent-gate                                         # from PyPI
+# pip install "git+https://github.com/mjeksonpx/loopagent.git@v0.4.2"   # or straight from the tag
+cd your-project                              # a git repository, or one with AGENTS.md
+loopgate init                                # writes the contract skill, AGENTS.md / PLANS.md / README.md,
+                                             # and declares the cold start (never a fabricated PASS)
+loopgate gate --strict                       # -> STOP: names what the project still has to configure
+```
+
+The install names a tag on purpose: `git+…` without one follows `main`, so the code under you would change
+under your feet. Use `@v0.4.0` (or a later tag) and pin it in your own requirements.
+
+> **The distribution is `loopagent-gate`; the command is `loopgate`.** Neither `loopgate` (taken by an
+> unrelated project) nor `loopagent` (too similar to `loop-agent`) can be used on PyPI, so the name says both
+> things at once. `pip install loopgate` would install somebody else's code.
+
+`init` never overwrites an existing `AGENTS.md`, `PLANS.md` or `README.md`, and it writes no round, handoff
+or anchor: those are evidence of a run.
+
+### The first run is red, and that is the design
+
+A project that has just been through `init` answers `STOP`, exit 1, and lists what is missing:
+
+```
+D10 issue_bridge               [FAIL] issue bridge incomplete
+       - configs/repo_profiles.json missing
+D11 product_gate               [FAIL] product gate incomplete
+...
+LOOP_ENGINEERING_STOP_0001
+```
+
+`COLD` is a different, rarer verdict: it appears only when every red dimension is *history* (D03–D05, D09,
+D12) and nothing else is wrong — that is a tree that has never run the loop. `STOP` here means the project's
+own facts are not configured yet, and no template can stand in for them:
+
+| Red dimension | What only the project can supply |
+|---|---|
+| `D10` | `configs/repo_profiles.json` — the commands a worker must prove |
+| `D11` | `configs/product_scenarios.json` — what a user must be able to do, and why it matters |
+| `D12` | `configs/allowed_signers` + `configs/anchor_witness.json` — the key that signs a verdict |
+| `D13` | `configs/visual_scenarios.json` — what a person must see; plus Chrome on the machine |
+| `D14` | `configs/change_health.json` + a recorded baseline — which direction of each metric is worse |
+
+A green gate is therefore work, not a default, and the gate says which work.
+
+### The skill
+
+`loopgate init` writes `.agents/skills/loop-engineering/SKILL.md`. It is the procedure an agent follows: when
+to start a loop, how to fill the run contract, how to repair one dimension per round, and when to stop.
+Read it before a task that needs more than one pass.
+
+Hermes loads project skills only from a trusted repository. The first run in a repo with project skills shows
+a notice; trust the repo once:
+
+```bash
+hermes skills trust                # from inside the project
+```
+
+Then start the session inside the project and ask for the task with the trigger words from the skill
+(`loop engineering`, `bounded loop`, `iterate until green`). The skill reads the gate; it does not replace it.
+
+Use the skill when the work needs rounds with evidence: a release gate, a refactor that must stay green,
+a multi-step fix. Skip it for a one-off edit that one command verifies.
+
+Python **3.9+** on paper, **3.12** in CI: one interpreter, so a green badge means "this runs", not
+"this may run somewhere". `loopgate <cmd>` forwards every argument to the gate of the same name —
+the command is a convenience, never a requirement.
+
+`--repo PATH` goes before the command name and runs the script that lives in that checkout, so the
+gate judges that tree instead of this one. It is deliberately not recognised after the command:
+`worker_brief.py` has its own `--repo` (the repository slug for the issue URL), and the wrapper must
+not steal it.
+
+## Sixty seconds
+
+```bash
+python3 -m loopgate.gates.check_loop
+#  -> prints every dimension. State that belongs to a run is red here, because this tree has never
+#     run: the strict marker is not something you can clone.
+
+python3 -m loopgate.gates.assert_dims --require D01 D02 D06 D07 D10 D11 D13
+#  -> CI_DIMS_PASS_0001. These depend only on the code — which is what CI can honestly assert.
+
+python3 -m loopgate.gates.regressions
+#  -> REGRESSION_SUITE_PASS_0001. 26 defects are injected into copies of this repository and the gate
+#     must redden on the expected dimension each time. A case that targets loop state prints [skip]
+#     with its reason in a tree without that state: never counted as a pass, never a fail.
+```
+
+The regression suite is the point of the project. It is easy to write a check that prints `OK`; it is
+rare to prove that the check can fail.
+
+## Wiring it into your repository
+
+1. **Describe your gates** in `configs/repo_profiles.json` (start from
+   `configs/repo_profiles.example.json`). The bundle is the machine-readable form of "a worker must
+   prove *every* gate this repository requires — not the subset it remembered", and it names the file
+   the gates were derived from, so the list is a floor rather than a claim of completeness.
+2. **Turn issues into cards** with the bundle inside them:
+
+   ```bash
+   python3 -m loopgate.gates.sync_issues_to_kanban --profile sample-service          # dry run
+   python3 -m loopgate.gates.sync_issues_to_kanban --profile sample-service --target backlog --apply
+   #   -> backlog/<key>.md: task spec + mandatory commands + transcript contract, in git
+   ```
+
+   `--target kanban` hands the card to the dispatcher instead; `--target backlog` needs no execution
+   backend at all. Issues do not have to come from GitHub: `--issues-file issues.json --exported-by jira`
+   declares a file the authoritative export of a named tracker, and its idempotency keys carry that name.
+3. **Check the transcript that comes back**:
+
+   ```bash
+   python3 -m loopgate.gates.worker_brief verify --profile sample-service --evidence /tmp/transcript.md
+   #  -> WORKER_EVIDENCE_PASS_0001 only when every mandatory command appears with its own exit code
+   ```
+
+   The format is deliberately dull: command, verbatim output, `exit=0` on its own line, per command.
+   One borrowed exit code at the end of the file proves nothing and is rejected.
+
+## What it is not
+
+- **not a test runner** — it does not replace your tests, it demands their transcripts;
+- **not a linter** — it does not judge style, it judges whether the claim matches the run;
+- **not a framework** — no daemon, no state to migrate; scripts and JSON;
+- **not a proof of correctness** — a gate proves the checks it names actually ran. Nothing more.
+
+## Honest comparison
+
+The "evidence bundle for an agent PR" idea is not novel, and this project is not the first:
+
+| Project | Focus | What loopgate adds, if anything |
+|---|---|---|
+| [Pramaan](https://github.com/marketplace/actions/pramaan-evidence-bundle-verifier) | receipt-first verification of a PR, GitHub Action, Rust CLI | our gate also attacks *itself* (26 injections), and it does not only look at the change |
+| [Assay](https://haserjian.github.io/assay/) | proof packs + a signed review decision per PR | we sign the **verdict over the loop's state**, not only over an artifact |
+| [hashgate](https://pypi.org/project/hashgate/) | fail-closed approval gate bound to a canonical hash | different question: ours is "did the work get proven", theirs is "is this the action I approved" |
+| [aelitium](https://github.com/aelitium-dev/aelitium-v3) | offline-verifiable bundles for recorded LLM interactions | ours is about code acceptance, not model interaction records |
+| [Backlog.md](https://github.com/MrLesk/Backlog.md) | markdown task ledger in git, three review checkpoints | complementary: `--target backlog` is a ledger; the gate is the proof layer on top |
+| [worktrunk](https://github.com/max-sixty/worktrunk) | git worktree lifecycle for parallel agents | complementary: isolation is their job, acceptance is ours |
+
+The three things that are actually ours: **a second verdict about the product** (start it, probe it,
+kill it, refuse a bad config — "green CI, broken product" is the failure nobody else gates on), **a
+third verdict about the direction of the tree** (a change that stays green while losing dimensions or
+gaining untested surface is refused, because "nothing broke" and "nothing got worse" are different
+sentences), and **a gate that proves it can fail**. If those do not matter to you, use one of the
+projects above.
+
+## Limits, stated plainly
+
+- **The strict marker is not reproducible from a clone, and a clone says so.** `bootstrap_state.py --init`
+  declares `cold`; the gate prints those dimensions as `COLD` and answers `LOOP_ENGINEERING_COLD_0001`,
+  never `PASS`. Proof of a run has to come from a run.
+- **The product gate needs a product.** Fail-closed: no product path → STOP, not a silent PASS. Point it
+  at your own service with `--repo-path` or the profile's `local_path_env`.
+- **The visual gate needs Chrome.** Headless Chrome/Chromium is required; absent → the check fails loudly
+  instead of skipping quietly. The default paths are macOS-first (`/Applications/...`).
+- **Money is not measured.** Token and call counts are readable per run; a price is not, because most
+  agent backends do not report it.
+- **`AGENTS.md`, `PLANS.md` and the skill under `.agents/` are the operator's notes (Russian).** They ship
+  because they are the contract this gate grew out of; the tool itself is documented in English.
+
+## Where the project stands
+
+Eleven stages are closed in [PLANS.md](PLANS.md) — from the skeleton and the role fan-out to the second
+and third verdicts, publication, and parity between two checkouts. The acceptance criterion for the whole
+project is not a sentence in a plan: it is `python3 -m loopgate.gates.check_loop --strict` printing
+`LOOP_ENGINEERING_PASS_0001` with `exit 0` on a tree that carries the loop's state.
+
+## Layout
+
+<details>
+<summary>19 scripts, one dispatcher, JSON configs — expand</summary>
+
+```
+loopgate/gates/check_loop.py            technical gate: 14 dimensions, STOP/PASS marker, read-only
+loopgate/gates/check_product.py         product gate: user-facing scenarios with a stated consequence
+loopgate/gates/check_visual.py          visual gate: headless screenshot + DOM rules
+loopgate/gates/change_health.py         third verdict: countable metrics against a baseline or a git ref
+loopgate/gates/regressions.py           26 injections: proves the gate reddens on real defects
+loopgate/gates/assert_dims.py           CI: assert named dimensions are OK
+loopgate/gates/worker_brief.py          renders/verifies a worker brief (evidence bundle inside)
+loopgate/gates/sync_issues_to_kanban.py issues -> queue (--target kanban | backlog)
+loopgate/gates/review_pr.py             second-level review of a PR, with a print-only verdict
+loopgate/gates/guard_card.py            per-card budget: tokens, runs, the progress clock
+loopgate/gates/anchor_witness.py        signs the verdict; publishes its digest to an external journal
+loopgate/gates/tree_parity.py           two checkouts must not drift — a command, not an observation
+loopgate/gates/estimate_task.py         measured p50/p90 -> a runtime cap for the queue
+loopgate/gates/loop_watch.py            fingerprints the gate; silent unless something changed (cron-friendly)
+loopgate/gates/render_status_page.py    both verdicts and the queue as one operator page
+loopgate/gates/render_task_ledger.py    finished cards -> backlog/*.md (git is the memory)
+loopgate/gates/export_public.py         assembles a publication-ready tree, fail-closed
+loopgate/gates/bootstrap_state.py       cold start for a clean clone: state=cold, not a fake history
+loopgate/gates/doctor.py                interpreter, jsonschema, Chrome, gh, git — before yellow reads as a defect
+configs/                         repository profiles, scenarios, rules, example identities
+loopgate/                        the `loopgate` command: names for the scripts above
+```
+
+</details>
+
+## Contributing
+
+The one rule: **a claim without a command is not accepted** — not from a human, not from an agent, not
+from a pull request description. [CONTRIBUTING.md](CONTRIBUTING.md) says what CI runs, how to add a
+dimension (check + falsification case + table row, in that order), and which habits keep the suite
+honest. Security reports: [SECURITY.md](SECURITY.md).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

loopagent_gate-0.4.2.dist-info/RECORD

@@ -0,0 +1,40 @@
+loopagent_gate-0.4.2.dist-info/licenses/LICENSE,sha256=ADaH17Fadzx_Sw6fk0bqf-ee4EwI32lXbZUAODO4cxY,1079
+loopgate/__init__.py,sha256=ZfEJvP9AZdwTa6s3c4m8nOtkI06rJg65f37ccwv9V88,297
+loopgate/__main__.py,sha256=WQyHiFnQeODATYpr9D-kqB2kG-TgRnAoYjFsh5Lwszw,167
+loopgate/cli.py,sha256=x3d5w_Tookwpe9aPmO1JvuC17S3KNNWK_cPejXw1VdE,6559
+loopgate/init.py,sha256=56bMOKqjOeQ6V6L2nkw5hd7y89tXLgyuO1FjOw_AnHA,6604
+loopgate/paths.py,sha256=I_uUDTDJppZ0ytxVo8HT6W1RH0eUuYvo2v7WRqTFxX4,1733
+loopgate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loopgate/gates/anchor_witness.py,sha256=RDeL1OhRwGj-6KWIkAXWaKTxptXPVuOu3BC_0yWVJ54,12512
+loopgate/gates/assert_dims.py,sha256=rwOPAMdohbZLhzrwjHbqlYe2G3sK5oiP4Ft11yjqkxY,3369
+loopgate/gates/bootstrap_state.py,sha256=FX_ptqG68ncEZxjmPGbK0YwiYh5Mp-7Ey7tz0EgsKis,4651
+loopgate/gates/change_health.py,sha256=Kojk3e7zNTIzeHJacZGu5GspL_s11G7q-DthTMU711c,10496
+loopgate/gates/check_loop.py,sha256=QGCjTNW1SWjTzObF1m3vQXOhTxBTYOAU13tygTiCyNI,67775
+loopgate/gates/check_product.py,sha256=KOMEPkYibF-QqVz2r0ccQcHYWrkeFM8HBC9uSbdLztE,21212
+loopgate/gates/check_visual.py,sha256=DNFMWaWFvjlfd7l-bOuLbdZjRnTTv2L-HZLJ4knn0Xs,9873
+loopgate/gates/doctor.py,sha256=zx95199ekWQXn-8SmW47FnpwXC-pgjQVIb4G7aUEJmI,5135
+loopgate/gates/estimate_task.py,sha256=Cu-9fskA001N8DRxxNo0N4_QuuEcfEGIKEWCZC7gMt0,5855
+loopgate/gates/export_public.py,sha256=pNpF0rNDgbhpevD2Jr_CyVa2DZTDicTgyz7P-LAeg5o,12887
+loopgate/gates/guard_card.py,sha256=NaVD6tytq3AJXVkE2j60qixqcp5LFnCiqqfIZWVUOzc,24755
+loopgate/gates/loop_watch.py,sha256=hEMu0uyRjLGhv5Fgvm0qZHczeVs47Eig6SB7isVa8MM,4651
+loopgate/gates/regressions.py,sha256=S6YbAo7BKInFquvyXQ8tHDurYFsaRHu59rkH4Rgiack,24808
+loopgate/gates/render_status_page.py,sha256=dq_Gbsb3ax5vPgAdvGTAiAnQmMzDZfHK_7V99WGt0S0,6656
+loopgate/gates/render_task_ledger.py,sha256=nF2Pe0e8dahaIExUflxWhh1hbSp2ibfQoxxkD9LtQhI,11537
+loopgate/gates/review_pr.py,sha256=5bbU6KssFzkcYC_TMh8nMdX3IBxlW_qN81kON-WeSAs,18384
+loopgate/gates/sync_issues_to_kanban.py,sha256=6VcyY8au8kYz4Yf8wOTORVCne06Px4WBJ3CNRdJM9To,29351
+loopgate/gates/tree_parity.py,sha256=lNT81NOmxrMZ31BV8zuDS8tDwsPGBmVS-l3tExVAJFw,14333
+loopgate/gates/worker_brief.py,sha256=uaoO4eAN4BD5y7mplq72YIJ7fyvbxm4PwjBJCGRFQ1U,20154
+loopgate/templates/__init__.py,sha256=A-bv5IXVr0b-6E2WdgDgSbjp8EEETJfz0sFqegtQ4ho,95
+loopgate/templates/configs/anchor_witness.example.json,sha256=8NVpxyG84z9LBYNsxaz1zEvH_s5LHjm5JS2sALzKZ2s,957
+loopgate/templates/configs/repo_profiles.example.json,sha256=m_za0GcVFl2-v_aJm7-dvGT82niJCAhtPn4YkqPOy7Y,2719
+loopgate/templates/configs/tree_parity.example.json,sha256=ugMGwS3u-65nW9UfV4Po0OGVg-v961UfGTFgR5gVHMU,1047
+loopgate/templates/configs/fixtures/issues_sample.json,sha256=CvWeyuB_zlT4iCxeoJ2tsDotj5HLZBpLySi3FNaTnn0,3287
+loopgate/templates/configs/fixtures/review_approve.json,sha256=w_rLfFu6LMp9WbjWDWEauN_fSjiUzqXFo01eKIjWtsQ,318
+loopgate/templates/configs/fixtures/review_changes.json,sha256=bK8Sc1ibp3RibmFIHepbswOfXJd6Qm2uJyrGTNc_qFs,400
+loopgate/templates/configs/fixtures/review_no_verdict.json,sha256=eGFmyzPgA8R-DBdX4Hc1741XFc2y5eqQpINBMfWyiW0,224
+loopgate/templates/skills/loop-engineering/SKILL.md,sha256=ajCdQiuntFDhpEYWcVNQ4wqDFquc-vQbFp1ICxA5VnM,32916
+loopagent_gate-0.4.2.dist-info/METADATA,sha256=vIuXbMYuQ0IYWVD04KZ1JjlJsy8ztjUK8bmO88Py1VI,21246
+loopagent_gate-0.4.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+loopagent_gate-0.4.2.dist-info/entry_points.txt,sha256=4srAkKQ38EuS9YJAbG6WbN2MKetK3eA6s2_ocnq8e7o,47
+loopagent_gate-0.4.2.dist-info/top_level.txt,sha256=UKbjU7cVUcG8pdkd82Xf4U7MZ_WpDwvU9I3eH6U-EYw,9
+loopagent_gate-0.4.2.dist-info/RECORD,,

loopagent_gate-0.4.2.dist-info/WHEEL

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

loopagent_gate-0.4.2.dist-info/entry_points.txt

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

loopagent_gate-0.4.2.dist-info/licenses/LICENSE

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

loopagent_gate-0.4.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+loopgate

loopgate/__init__.py

@@ -0,0 +1,7 @@
+"""loopgate — gates that accept agent work by proof, not by confidence.
+
+The gates live in ``loopgate.gates`` and run as modules (``python -m loopgate.gates.check_loop``). The
+``loopgate`` command names them and runs them against the project in the working directory.
+"""
+
+__version__ = "0.4.2"

loopgate/__main__.py

@@ -0,0 +1,8 @@
+"""Allow `python -m loopgate <command>` without installing the package."""
+
+import sys
+
+from loopgate.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

loopgate/cli.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Single entry point for every gate and tool.
+
+The gates are packaged under ``loopgate.gates``; this module only gives them one discoverable name and
+runs them as modules. It never re-implements a check: it forwards the arguments and returns the exit code.
+
+Usage:
+    loopgate                       # list the commands
+    loopgate init                  # add the contract, the skill and cold-start state to this project
+    loopgate gate --strict         # technical gate   -> LOOP_ENGINEERING_PASS_0001
+    loopgate product               # product verdict  -> PRODUCT_ACCEPTANCE_PASS_0001
+    loopgate regress               # the gate's own regression suite
+    loopgate --repo ../other gate  # judge another project instead of the working directory
+
+``--repo`` is global and must come *before* the command name. Without it the project is the nearest
+ancestor of the working directory that holds ``.git`` or ``AGENTS.md`` (``loopgate.paths.project_root``).
+Unknown arguments are forwarded verbatim, so ``loopgate gate --help`` is the gate's own help.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+from loopgate import __version__
+from loopgate.paths import gate_module, project_root
+
+# command -> (module under loopgate.gates, one-line description)
+COMMANDS: dict[str, tuple[str, str]] = {
+    "gate": ("check_loop",
+             "technical gate: is the loop disciplined? -> LOOP_ENGINEERING_PASS_0001 / _STOP_0001"),
+    "product": ("check_product",
+                "product gate: can a user do their job? -> PRODUCT_ACCEPTANCE_PASS_0001 / _STOP_0001"),
+    "visual": ("check_visual",
+               "visual gate: headless screenshot + DOM rules -> VISUAL_CHECK_PASS_0001"),
+    "regress": ("regressions",
+                "inject defects into a copy: the gate must redden on the expected dimension"),
+    "brief": ("worker_brief",
+              "render/verify a worker brief (the evidence bundle is inside it)"),
+    "bridge": ("sync_issues_to_kanban",
+               "issues -> queue: --target kanban (dispatcher) or --target backlog (markdown ledger)"),
+    "estimate": ("estimate_task",
+                 "measured p50/p90 -> a per-role runtime cap"),
+    "status": ("render_status_page",
+               "render both verdicts and the queue into one operator page"),
+    "witness": ("anchor_witness",
+                "sign/verify/publish the verdict anchor (external witness)"),
+    "watch": ("loop_watch",
+              "fingerprint the gate; stay silent unless it changed (cron-friendly)"),
+    "dims": ("assert_dims",
+             "assert that named dimensions are OK in a gate run (used by CI)"),
+    "doctor": ("doctor",
+               "report what this interpreter can run: jsonschema, Chrome, gh, git"),
+    "guard": ("guard_card",
+              "report (or --enforce) cards that exceed their token/run/progress budget"),
+    "ledger": ("render_task_ledger",
+               "render board cards into backlog/<task-id>.md (git is the memory)"),
+    "health": ("change_health",
+               "third verdict: compare countable metrics against the baseline or a git ref"),
+    "review": ("review_pr",
+               "second-level review of a pull request through ywcrew (--post to leave it on the PR)"),
+    "parity": ("tree_parity",
+               "two checkouts must not drift -> TREE_PARITY_PASS_0001 (--policy <json>)"),
+    "export": ("export_public",
+               "build a publication-ready tree with the private parts removed"),
+}
+
+
+def usage() -> str:
+    width = max(len(name) for name in list(COMMANDS) + ["init"])
+    lines = [f"loopgate {__version__} — gates that accept work by proof, not by confidence", "",
+             "usage: loopgate [--repo PATH] <command> [args...]", "",
+             f"  {'init':<{width}}  add the contract, the skill and cold-start state to this project"]
+    for name, (_, doc) in sorted(COMMANDS.items()):
+        lines.append(f"  {name:<{width}}  {doc}")
+    lines += ["",
+              "Each command forwards every extra argument to the underlying gate.",
+              "--repo PATH judges that project instead of the one found from the working directory;",
+              "it goes before the command name (after it, --repo belongs to the gate)."]
+    return "\n".join(lines)
+
+
+def split_repo_flag(args: list[str]) -> tuple[str | None, list[str], str | None]:
+    """Consume a leading ``--repo <path>`` / ``--repo=<path>``.
+
+    Only the global position is recognised: ``worker_brief`` declares its own ``--repo`` (the repository
+    slug for the issue URL), so scanning the forwarded tail would silently steal that argument.
+    """
+    repo: str | None = None
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        if arg == "--repo":
+            if index + 1 >= len(args):
+                return None, args, "--repo needs a path"
+            repo = args[index + 1]
+            index += 2
+            continue
+        if arg.startswith("--repo="):
+            repo = arg.split("=", 1)[1]
+            index += 1
+            continue
+        break
+    if repo is not None and not repo.strip():
+        return None, args, "--repo needs a path"
+    return repo, args[index:], None
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    repo, args, repo_error = split_repo_flag(args)
+    if repo_error:
+        print(repo_error, file=sys.stderr)
+        return 2
+    if not args or args[0] in {"-h", "--help", "help"}:
+        print(usage())
+        return 0 if args else 2
+    if args[0] in {"--version", "version"}:
+        print(__version__)
+        return 0
+    name, rest = args[0], args[1:]
+
+    if repo is not None:
+        root = os.path.abspath(os.path.expanduser(repo))
+        if not os.path.isdir(root):
+            print(f"--repo is not a directory: {root}", file=sys.stderr)
+            return 2
+    else:
+        root = project_root()
+
+    if name == "init":
+        from loopgate.init import init_project
+        return init_project(root, rest)
+
+    entry = COMMANDS.get(name)
+    if entry is None:
+        print(f"unknown command: {name}", file=sys.stderr)
+        print(usage(), file=sys.stderr)
+        return 2
+    # The gate code comes from this installed package (`-m` resolves it from the interpreter); the
+    # project's own files (configs/, artifacts/, handoff/, AGENTS.md) are read from `root`, the cwd.
+    return subprocess.call([sys.executable, "-m", gate_module(entry[0]), *rest], cwd=root)
+
+
+if __name__ == "__main__":
+    sys.exit(main())