flockwork 0.1.0__tar.gz

flockwork-0.1.0/LICENSE

@@ -0,0 +1,162 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by the
+      copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the legal entity that controls or is
+      controlled by such Legal Entity and any entities that control or are
+      controlled by such Legal Entity, or are under common control with such Legal
+      Entity. For the purposes of this definition, "control" means (i) the power,
+      direct or indirect, to cause the direction or management of such Legal
+      Entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+      (50%) or more of the outstanding shares, or (iii) beneficial ownership.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received for inclusion in
+      the Work by the copyright owner or other entity authorized to grant
+      such rights on behalf of the copyright owner.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the
+      Work, where such license applies to patent claims infringed by
+      the Work or any Contribution incorporated in the Work.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the
+      Licensor, except as required for reasonable and customary use in
+      describing the origin of the Work and reproducing the
+      inclusion of the Work in derivative works.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise, unless
+      required by applicable law (such as deliberate and gross
+      negligence) or agreed to in writing, shall any Contributor be liable
+      to You for damages, including any direct, indirect, special, incidental,
+      or consequential damages of any character arising from the use of or
+      inability to use the Work (or any other breach of this License), even
+      if advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing the
+      Work or Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other liability
+      obligations and/or rights consistent with this License. However, in
+      accepting such obligations, You act on Your own behalf, on Your sole
+      responsibility, not on behalf of any Contributor.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. Don't include
+      the brackets!  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included in the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 jlam
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

flockwork-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: flockwork
+Version: 0.1.0
+Summary: A worker swarm whose entire coordination substrate is git itself.
+Author: jlam
+License: Apache-2.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flockwork — the swarm that runs like clockwork
+
+**flockwork** is a worker swarm whose **entire coordination substrate is
+git itself**: no server, no database, no queue daemon — a shared origin's
+refs under `refs/swarm/` carry task briefs, claims, returns, and
+verdicts, and every guarantee (exactly-once work, honest outcomes,
+bounded retries) reduces to a git property you can verify with
+`ls-remote` and `cat-file`. This repo doubles as its own substrate
+(**D-INREPO**): the machinery lives in `l2/inrepo.py`, and workers
+coordinate through refs on the project's own origin. (The code, CLI, and
+repo internals keep the working name `swarmo` — same product.)
+
+> **New to swarms, git refs, or both?** `docs/00-ORIENTATION.md` is the
+> zero-context orientation: the project in 15 sentences, how the pieces
+> relate, which doc to open for which job, what a verdict means, and a
+> full glossary.
+
+Run it yourself in five minutes: `QUICKSTART.md` (scratch board, zero
+model spend).
+
+## The refs model (one diagram)
+
+```
+  origin  (any git remote — a bare repo; e.g. a local bare repo under /tmp)
+  ├── refs/heads/main                      the product: landed fixes
+  └── refs/swarm/*                         the coordination lane
+      ├── specs/<task>      the brief      operator seeds it (root commit,
+      │                                    body carries the task + `verify:` line)
+      ├── claims/<task>     the lease      create-once CAS push — exactly one
+      │                                    worker wins; duplicates are rejected
+      ├── tasks/<task>      the return     points at the fix, on main's lineage
+      ├── verdicts/<task>   the outcome    root commit: task/attempt/fixed/host/rc
+      └── archive/<kind>/<task>@<att>      dead attempts, preserved (never deleted)
+```
+
+Claim and verdict commits are ROOT commits, so their objects never
+leak into consumer clones or fetches; the whole lane is evictable with
+a one-transaction namespace delete.
+
+## The five verbs
+
+1. **seed** — the operator declares a task: `python3 l2/inrepo.py seed
+   spec.json` pushes `refs/swarm/specs/<task>` carrying the brief; a
+   `verify:` line in the brief is the task's oracle.
+2. **claim** — a worker leases a task: a create-once CAS push
+   (`push --force-with-lease=<ref>:`) to `refs/swarm/claims/<task>`.
+   Git itself rejects the second claim — exactly-once is not a lock
+   file, it is the ref database.
+3. **work** — the claim winner clones the origin, dispatches the brief
+   to the model, and the `verify:` line (or host pytest) judges the
+   tree. A pass lands the fix on main and points the return ref at it;
+   a fail touches nothing but the verdict.
+4. **verdict** — the attempt closes as a root commit at
+   `refs/swarm/verdicts/<task>`: `fixed: true|false`, host, dispatch
+   and oracle exit codes. The refs alone must separate environmental
+   deaths from honest merit failures.
+5. **evict** — `sweep`/`reconcile` archive dead attempts to
+   `refs/swarm/archive/<kind>/<task>@<att>` and free the live refs in
+   one atomic transaction, so the task re-enters the queue; eviction
+   is bounded (one heir per death, then a final honest `fixed:false`).
+
+## The honesty laws (what keeps the lane truthful)
+
+Claim and verdict commits are ROOT commits so their objects never leak
+into consumer fetches, and eviction is a one-transaction namespace
+delete. Four honesty laws keep the lane truthful. **Claim-loss
+honesty:** a failed claim is classified — a lost race (`! [rejected]
+(stale info)`) is healthy contention to re-scan, a structurally broken
+origin is reported — and bounded by `SWARM_WORKER_MAX_FAILS` so a sick
+host exits instead of spinning. **Law-freshness gate:** each worker
+refuses to claim when its running `l2/inrepo.py` blob differs from
+origin main's published copy, so stale code never writes to the
+substrate. **Environmental honesty:** a dispatch death (timeout, or
+failure with an empty tree) is never recorded as a fix — the attempt is
+archived and requeued to one heir, then closed with a final honest
+`fixed:false`. **Main-push honesty:** a fix is a fix only if its commit
+actually lands on main, else the task requeues under the same bounded
+machinery — and a change that fails its oracle never lands at all: a
+merit failure publishes only its final honest verdict, never to main.
+
+**No-default-origin law:** there is **no** default `SWARM_ORIGIN`. Every
+origin resolution is explicit-arg > `SWARM_ORIGIN` at call time > the
+import-time `ORIGIN` > a typed `OriginUnsetError` naming the fix. A
+write or read leg with no origin anywhere refuses *before* any git/ssh
+contact, so a forgotten config can never push into a production board.
+
+`python3 l2/inrepo.py audit` is the board's health instrument
+(`h1_pass`: every live claim has a matching return + verdict);
+`reconcile` is the TTL backstop for stale claims; `correction-graph`
+reconstructs the multi-model attempt graph from refs alone.
+
+## Observability (opt-in, zero wire change)
+
+- `FLOCKWORK_METRICS=1` turns on a JSONL observer over the lane's own
+  results; `python3 -m l2.metrics [files]` summarizes counts,
+  reject-rate, and claim→verdict latency. `--dora` adds the DORA five
+  over the same stream.
+- `FLOCKWORK_KEEP_TREE=1` preserves a merit-failed attempt's tree so a
+  failure is auditable.
+
+## Layout
+
+```
+l2/inrepo.py      the lane law: seed/claim/work/verdict/evict + review/gate + audit
+l2/metrics.py     the opt-in JSONL observer + DORA judge
+l2/gates.py       the verdict-count gate (n-of-m reviewer agreement)
+l2/refschema.py   minimal required-field schemas; loud typed refusals
+tests/            the suite (hermetic: scratch boards, no network, no default origin)
+demo/             the scripted end-to-end (owner_test.sh) + the raw CAS demo
+docs/             00-ORIENTATION (start here), GATES, SCRATCH-BOARDS
+```
+
+## License
+
+Apache-2.0. See `LICENSE`.

flockwork-0.1.0/README.md

@@ -0,0 +1,115 @@
+# flockwork — the swarm that runs like clockwork
+
+**flockwork** is a worker swarm whose **entire coordination substrate is
+git itself**: no server, no database, no queue daemon — a shared origin's
+refs under `refs/swarm/` carry task briefs, claims, returns, and
+verdicts, and every guarantee (exactly-once work, honest outcomes,
+bounded retries) reduces to a git property you can verify with
+`ls-remote` and `cat-file`. This repo doubles as its own substrate
+(**D-INREPO**): the machinery lives in `l2/inrepo.py`, and workers
+coordinate through refs on the project's own origin. (The code, CLI, and
+repo internals keep the working name `swarmo` — same product.)
+
+> **New to swarms, git refs, or both?** `docs/00-ORIENTATION.md` is the
+> zero-context orientation: the project in 15 sentences, how the pieces
+> relate, which doc to open for which job, what a verdict means, and a
+> full glossary.
+
+Run it yourself in five minutes: `QUICKSTART.md` (scratch board, zero
+model spend).
+
+## The refs model (one diagram)
+
+```
+  origin  (any git remote — a bare repo; e.g. a local bare repo under /tmp)
+  ├── refs/heads/main                      the product: landed fixes
+  └── refs/swarm/*                         the coordination lane
+      ├── specs/<task>      the brief      operator seeds it (root commit,
+      │                                    body carries the task + `verify:` line)
+      ├── claims/<task>     the lease      create-once CAS push — exactly one
+      │                                    worker wins; duplicates are rejected
+      ├── tasks/<task>      the return     points at the fix, on main's lineage
+      ├── verdicts/<task>   the outcome    root commit: task/attempt/fixed/host/rc
+      └── archive/<kind>/<task>@<att>      dead attempts, preserved (never deleted)
+```
+
+Claim and verdict commits are ROOT commits, so their objects never
+leak into consumer clones or fetches; the whole lane is evictable with
+a one-transaction namespace delete.
+
+## The five verbs
+
+1. **seed** — the operator declares a task: `python3 l2/inrepo.py seed
+   spec.json` pushes `refs/swarm/specs/<task>` carrying the brief; a
+   `verify:` line in the brief is the task's oracle.
+2. **claim** — a worker leases a task: a create-once CAS push
+   (`push --force-with-lease=<ref>:`) to `refs/swarm/claims/<task>`.
+   Git itself rejects the second claim — exactly-once is not a lock
+   file, it is the ref database.
+3. **work** — the claim winner clones the origin, dispatches the brief
+   to the model, and the `verify:` line (or host pytest) judges the
+   tree. A pass lands the fix on main and points the return ref at it;
+   a fail touches nothing but the verdict.
+4. **verdict** — the attempt closes as a root commit at
+   `refs/swarm/verdicts/<task>`: `fixed: true|false`, host, dispatch
+   and oracle exit codes. The refs alone must separate environmental
+   deaths from honest merit failures.
+5. **evict** — `sweep`/`reconcile` archive dead attempts to
+   `refs/swarm/archive/<kind>/<task>@<att>` and free the live refs in
+   one atomic transaction, so the task re-enters the queue; eviction
+   is bounded (one heir per death, then a final honest `fixed:false`).
+
+## The honesty laws (what keeps the lane truthful)
+
+Claim and verdict commits are ROOT commits so their objects never leak
+into consumer fetches, and eviction is a one-transaction namespace
+delete. Four honesty laws keep the lane truthful. **Claim-loss
+honesty:** a failed claim is classified — a lost race (`! [rejected]
+(stale info)`) is healthy contention to re-scan, a structurally broken
+origin is reported — and bounded by `SWARM_WORKER_MAX_FAILS` so a sick
+host exits instead of spinning. **Law-freshness gate:** each worker
+refuses to claim when its running `l2/inrepo.py` blob differs from
+origin main's published copy, so stale code never writes to the
+substrate. **Environmental honesty:** a dispatch death (timeout, or
+failure with an empty tree) is never recorded as a fix — the attempt is
+archived and requeued to one heir, then closed with a final honest
+`fixed:false`. **Main-push honesty:** a fix is a fix only if its commit
+actually lands on main, else the task requeues under the same bounded
+machinery — and a change that fails its oracle never lands at all: a
+merit failure publishes only its final honest verdict, never to main.
+
+**No-default-origin law:** there is **no** default `SWARM_ORIGIN`. Every
+origin resolution is explicit-arg > `SWARM_ORIGIN` at call time > the
+import-time `ORIGIN` > a typed `OriginUnsetError` naming the fix. A
+write or read leg with no origin anywhere refuses *before* any git/ssh
+contact, so a forgotten config can never push into a production board.
+
+`python3 l2/inrepo.py audit` is the board's health instrument
+(`h1_pass`: every live claim has a matching return + verdict);
+`reconcile` is the TTL backstop for stale claims; `correction-graph`
+reconstructs the multi-model attempt graph from refs alone.
+
+## Observability (opt-in, zero wire change)
+
+- `FLOCKWORK_METRICS=1` turns on a JSONL observer over the lane's own
+  results; `python3 -m l2.metrics [files]` summarizes counts,
+  reject-rate, and claim→verdict latency. `--dora` adds the DORA five
+  over the same stream.
+- `FLOCKWORK_KEEP_TREE=1` preserves a merit-failed attempt's tree so a
+  failure is auditable.
+
+## Layout
+
+```
+l2/inrepo.py      the lane law: seed/claim/work/verdict/evict + review/gate + audit
+l2/metrics.py     the opt-in JSONL observer + DORA judge
+l2/gates.py       the verdict-count gate (n-of-m reviewer agreement)
+l2/refschema.py   minimal required-field schemas; loud typed refusals
+tests/            the suite (hermetic: scratch boards, no network, no default origin)
+demo/             the scripted end-to-end (owner_test.sh) + the raw CAS demo
+docs/             00-ORIENTATION (start here), GATES, SCRATCH-BOARDS
+```
+
+## License
+
+Apache-2.0. See `LICENSE`.

flockwork-0.1.0/flockwork.egg-info/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: flockwork
+Version: 0.1.0
+Summary: A worker swarm whose entire coordination substrate is git itself.
+Author: jlam
+License: Apache-2.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flockwork — the swarm that runs like clockwork
+
+**flockwork** is a worker swarm whose **entire coordination substrate is
+git itself**: no server, no database, no queue daemon — a shared origin's
+refs under `refs/swarm/` carry task briefs, claims, returns, and
+verdicts, and every guarantee (exactly-once work, honest outcomes,
+bounded retries) reduces to a git property you can verify with
+`ls-remote` and `cat-file`. This repo doubles as its own substrate
+(**D-INREPO**): the machinery lives in `l2/inrepo.py`, and workers
+coordinate through refs on the project's own origin. (The code, CLI, and
+repo internals keep the working name `swarmo` — same product.)
+
+> **New to swarms, git refs, or both?** `docs/00-ORIENTATION.md` is the
+> zero-context orientation: the project in 15 sentences, how the pieces
+> relate, which doc to open for which job, what a verdict means, and a
+> full glossary.
+
+Run it yourself in five minutes: `QUICKSTART.md` (scratch board, zero
+model spend).
+
+## The refs model (one diagram)
+
+```
+  origin  (any git remote — a bare repo; e.g. a local bare repo under /tmp)
+  ├── refs/heads/main                      the product: landed fixes
+  └── refs/swarm/*                         the coordination lane
+      ├── specs/<task>      the brief      operator seeds it (root commit,
+      │                                    body carries the task + `verify:` line)
+      ├── claims/<task>     the lease      create-once CAS push — exactly one
+      │                                    worker wins; duplicates are rejected
+      ├── tasks/<task>      the return     points at the fix, on main's lineage
+      ├── verdicts/<task>   the outcome    root commit: task/attempt/fixed/host/rc
+      └── archive/<kind>/<task>@<att>      dead attempts, preserved (never deleted)
+```
+
+Claim and verdict commits are ROOT commits, so their objects never
+leak into consumer clones or fetches; the whole lane is evictable with
+a one-transaction namespace delete.
+
+## The five verbs
+
+1. **seed** — the operator declares a task: `python3 l2/inrepo.py seed
+   spec.json` pushes `refs/swarm/specs/<task>` carrying the brief; a
+   `verify:` line in the brief is the task's oracle.
+2. **claim** — a worker leases a task: a create-once CAS push
+   (`push --force-with-lease=<ref>:`) to `refs/swarm/claims/<task>`.
+   Git itself rejects the second claim — exactly-once is not a lock
+   file, it is the ref database.
+3. **work** — the claim winner clones the origin, dispatches the brief
+   to the model, and the `verify:` line (or host pytest) judges the
+   tree. A pass lands the fix on main and points the return ref at it;
+   a fail touches nothing but the verdict.
+4. **verdict** — the attempt closes as a root commit at
+   `refs/swarm/verdicts/<task>`: `fixed: true|false`, host, dispatch
+   and oracle exit codes. The refs alone must separate environmental
+   deaths from honest merit failures.
+5. **evict** — `sweep`/`reconcile` archive dead attempts to
+   `refs/swarm/archive/<kind>/<task>@<att>` and free the live refs in
+   one atomic transaction, so the task re-enters the queue; eviction
+   is bounded (one heir per death, then a final honest `fixed:false`).
+
+## The honesty laws (what keeps the lane truthful)
+
+Claim and verdict commits are ROOT commits so their objects never leak
+into consumer fetches, and eviction is a one-transaction namespace
+delete. Four honesty laws keep the lane truthful. **Claim-loss
+honesty:** a failed claim is classified — a lost race (`! [rejected]
+(stale info)`) is healthy contention to re-scan, a structurally broken
+origin is reported — and bounded by `SWARM_WORKER_MAX_FAILS` so a sick
+host exits instead of spinning. **Law-freshness gate:** each worker
+refuses to claim when its running `l2/inrepo.py` blob differs from
+origin main's published copy, so stale code never writes to the
+substrate. **Environmental honesty:** a dispatch death (timeout, or
+failure with an empty tree) is never recorded as a fix — the attempt is
+archived and requeued to one heir, then closed with a final honest
+`fixed:false`. **Main-push honesty:** a fix is a fix only if its commit
+actually lands on main, else the task requeues under the same bounded
+machinery — and a change that fails its oracle never lands at all: a
+merit failure publishes only its final honest verdict, never to main.
+
+**No-default-origin law:** there is **no** default `SWARM_ORIGIN`. Every
+origin resolution is explicit-arg > `SWARM_ORIGIN` at call time > the
+import-time `ORIGIN` > a typed `OriginUnsetError` naming the fix. A
+write or read leg with no origin anywhere refuses *before* any git/ssh
+contact, so a forgotten config can never push into a production board.
+
+`python3 l2/inrepo.py audit` is the board's health instrument
+(`h1_pass`: every live claim has a matching return + verdict);
+`reconcile` is the TTL backstop for stale claims; `correction-graph`
+reconstructs the multi-model attempt graph from refs alone.
+
+## Observability (opt-in, zero wire change)
+
+- `FLOCKWORK_METRICS=1` turns on a JSONL observer over the lane's own
+  results; `python3 -m l2.metrics [files]` summarizes counts,
+  reject-rate, and claim→verdict latency. `--dora` adds the DORA five
+  over the same stream.
+- `FLOCKWORK_KEEP_TREE=1` preserves a merit-failed attempt's tree so a
+  failure is auditable.
+
+## Layout
+
+```
+l2/inrepo.py      the lane law: seed/claim/work/verdict/evict + review/gate + audit
+l2/metrics.py     the opt-in JSONL observer + DORA judge
+l2/gates.py       the verdict-count gate (n-of-m reviewer agreement)
+l2/refschema.py   minimal required-field schemas; loud typed refusals
+tests/            the suite (hermetic: scratch boards, no network, no default origin)
+demo/             the scripted end-to-end (owner_test.sh) + the raw CAS demo
+docs/             00-ORIENTATION (start here), GATES, SCRATCH-BOARDS
+```
+
+## License
+
+Apache-2.0. See `LICENSE`.

flockwork-0.1.0/flockwork.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+flockwork.egg-info/PKG-INFO
+flockwork.egg-info/SOURCES.txt
+flockwork.egg-info/dependency_links.txt
+flockwork.egg-info/entry_points.txt
+flockwork.egg-info/top_level.txt
+l2/__init__.py
+l2/gates.py
+l2/inrepo.py
+l2/metrics.py
+l2/refschema.py
+tests/test_gates.py
+tests/test_inrepo_gate.py
+tests/test_keep_tree.py
+tests/test_metrics.py
+tests/test_origin_refusal.py
+tests/test_packaging.py
+tests/test_refschema.py

flockwork-0.1.0/flockwork.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flockwork-0.1.0/flockwork.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flockwork = l2.inrepo:main

flockwork-0.1.0/flockwork.egg-info/top_level.txt

@@ -0,0 +1 @@
+l2

flockwork-0.1.0/l2/__init__.py

@@ -0,0 +1,5 @@
+"""flockwork lane — the git-refs coordination substrate.
+
+The CLI lives in l2/inrepo.py; the opt-in observer in l2/metrics.py;
+the verdict-count gate in l2/gates.py; the ref schemas in l2/refschema.py.
+"""