relayloom 0.3.0__tar.gz

relayloom-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sriharsan B S
+
+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.

relayloom-0.3.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: relayloom
+Version: 0.3.0
+Summary: Pay for what arrived. Prove it. Accounts payable that counts the goods with open weight Meta models (Muse Glimmer, SAM 3.1) on your own machine.
+Author: Sriharsan B S
+License-Expression: MIT
+Project-URL: Homepage, https://relayloom.vercel.app
+Project-URL: Documentation, https://relayloom.vercel.app/developers
+Project-URL: Source, https://github.com/Sriharsan/relayloom
+Project-URL: Issues, https://github.com/Sriharsan/relayloom/issues
+Project-URL: Changelog, https://github.com/Sriharsan/relayloom/blob/main/CHANGELOG.md
+Keywords: accounts payable,three-way match,invoice,receiving,SAM 3.1,Muse Glimmer,signed receipts,offline,local-first
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=44
+Requires-Dist: PyMuPDF>=1.26
+Requires-Dist: opencv-python-headless>=4.10
+Requires-Dist: numpy>=1.26
+Requires-Dist: Pillow>=10
+Provides-Extra: models
+Requires-Dist: ultralytics>=8.3; extra == "models"
+Requires-Dist: huggingface_hub>=0.26; extra == "models"
+Provides-Extra: qr
+Requires-Dist: segno>=1.6; extra == "qr"
+Dynamic: license-file
+
+# Relayloom
+
+**Pay for what arrived. Prove it.**
+
+Relayloom matches a supplier bill with the purchase order and with what was actually counted on the dock, holds any payment the goods do not support, and writes **signed receipts** you can verify with the network off. Muse Glimmer and SAM 3.1, open weight Meta models, run on your own machine.
+
+The paperwork says 50. The dock got 46. `relayloom check` says HELD, and says why.
+
+```bash
+python -m pip install relayloom
+relayloom doctor
+```
+
+## Try it in a minute, no models needed
+
+`bill.json` (what the bill says), `po.json` (what was ordered), and a count of what arrived:
+
+```bash
+relayloom check --bill-json bill.json --po po.json --counted 46
+relayloom verify relayloom-out/receipts.jsonl
+```
+
+```text
+Bill CAL-0990: billed 50, counted 46. Result: HELD
+  - CARTON-HD: billed 50 with 0 already billed, received 46
+Signed receipts: relayloom-out/receipts.jsonl   Verify: relayloom verify relayloom-out/receipts.jsonl
+```
+
+Exit code `0` means clear to enter, `3` means held, `2` means it could not run. Add `--json` for scripts.
+
+## Count the goods from photos
+
+```bash
+python -m pip install "relayloom[models]"
+python -m pip install git+https://github.com/ultralytics/CLIP.git   # text prompts for SAM 3.1 (a Git-only dependency, so it is not bundled)
+export HF_TOKEN=...            # your own Hugging Face read token (SAM 3.1 needs the access request)
+relayloom models pull          # one time; after this everything runs offline
+relayloom models serve         # Muse Glimmer on 127.0.0.1, in another terminal
+relayloom check --bill bill.pdf --photos dock/ --po po.json --agent
+```
+
+With `--agent`, Muse Glimmer proposes the words to look for, calls SAM 3.1 as a tool, and looks at the numbered overlay itself. **Code owns the number**: it is only ever the masks SAM returned, and a count is accepted only when two different words agree, or when Glimmer has looked at the overlay and no other count contradicts it. Otherwise the bill is held for a person.
+
+## What it does not do
+
+- It does not send a bill, a photo or a number anywhere. `relayloom doctor` and `verify` make no network calls at all.
+- It does not pay anything. It decides, with evidence, and a person approves what the policy says needs approval.
+- It does not claim real time on a CPU. Counting a photo takes about 40 seconds and reading a bill several minutes on a laptop CPU; measured timings are on the [Proof page](https://relayloom.vercel.app/proof).
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `relayloom check` | match a bill, a purchase order and the goods; write signed receipts |
+| `relayloom verify RECEIPTS` | check signatures, hashes and chain order offline |
+| `relayloom doctor` | say what is ready and the one command that fixes what is not |
+| `relayloom models pull` / `serve` | download the models with your own token / start Muse Glimmer locally |
+| `relayloom serve` | the demo app and phone alerts (needs a clone of the repository) |
+
+Docs, the policy file and the receipt format: https://relayloom.vercel.app/developers. Source and threat model: https://github.com/Sriharsan/relayloom. MIT licensed.

relayloom-0.3.0/README.md

@@ -0,0 +1,165 @@
+# Relayloom
+
+**Relayloom: autonomous accounts payable that checks the goods, not just the paperwork.**
+
+Agents read the bill, look at what actually arrived, investigate any gap with evidence, and pay only what
+the books and the goods both support. Runs inside the company's own network on Meta open weight models.
+
+The paperwork says 50. The dock got 46. Relayloom is for the receiving and accounts payable team of a
+manufacturer or distributor that buys physical goods. The example company in this repository is
+Northgate Components, with fictional suppliers and demo records only.
+
+**Live site and proof:** https://relayloom.vercel.app. On a demo set of 30 deliveries built by us, paperwork only caught
+5 of 17 bad bills and paperwork plus goods caught 17 of 17 with no wrong payment ([docs/BENCHMARK.md](docs/BENCHMARK.md)).
+
+## Install the command line
+
+```sh
+python -m pip install git+https://github.com/Sriharsan/relayloom.git     # a PyPI release of the same package follows
+relayloom doctor                                                         # what is ready on this machine, and the command that fixes the rest
+relayloom check --bill-json bill.json --po po.json --counted 46          # no models needed: HELD or clear, with signed receipts
+relayloom check --bill bill.pdf --photos dock/ --po po.json --agent      # Muse Glimmer proposes the words, SAM 3.1 counts, Glimmer looks at the overlay
+relayloom verify relayloom-out/receipts.jsonl                            # verify the receipts offline
+```
+
+```sh
+pip install -r requirements-ap.txt
+python -m pytest -q                                   # 127 tests
+python -m relayloom.ap.benchmark --counter recorded   # the benchmark on saved SAM 3.1 counts, a few seconds
+python scripts/export_bench_run.py out.json           # the seven cases on the real agents, with signed receipts
+python -m relayloom.ap --batch                        # the app on http://127.0.0.1:8800 (replays the saved readings)
+python -m relayloom.ap --batch --phone                # also prints a link for alerts on a phone on the same Wi-Fi
+python scripts/security_report.py                     # runs and times every security control
+python scripts/record_demo_video.py                    # records the captioned picture of the live site to speak over
+python scripts/add_voice.py my-voice.m4a              # puts your own voice on that picture and checks the three minute limit
+python scripts/video_demo.py                          # a dock clip becomes a held delivery, from saved frames and counts
+```
+
+Recorded mode replays outputs from real runs on one laptop with their date, route and timings on screen, and uses a small
+built in ledger. `--live` runs the models on your own machine and uses ERPNext (see below).
+
+## What it does
+
+1. **Reads the bill.** Muse Glimmer 30B turns a bill into a strict schema. Private numbers (GSTIN, bank account,
+   IFSC, phone, email) are masked first. Text hidden in the PDF is found and never reaches the model.
+2. **Looks at what arrived.** SAM 3.1 counts the goods in every photo of every delivery. Repeated photos are counted once.
+   A purchase order can have several receiving events, and they add up as a running total.
+3. **Matches.** Code compares order, bill and goods received, with tolerances from a policy file the model cannot change.
+4. **Investigates every mismatch before a person sees it.** The Investigator recounts from every photo, adds up all deliveries
+   on the order, checks the order price and the last price paid, looks for a duplicate bill, and checks the supplier's
+   past shortfalls. Every statement in its finding cites a record, a photo or a recount, and code checks every citation
+   and every number before the finding is shown. It then names the likely cause (short delivery, price above the order, duplicate bill,
+   or the two counts disagree, or unclear), how sure the records let it be, and what to do next, and it proposes an action. The policy decides.
+5. **Enters and checks.** A matching bill is entered by the Clerk, and a separate Checker reads it back and compares every
+   field. Only then does the case say "entered and checked". Payment details only ever come from the supplier master.
+6. **Waits for the owner where it matters.** Disputes, mismatches, bills above the owner's limit and new suppliers wait in
+   the approval inbox. Muse Glimmer drafts the dispute and a browser agent files it in a local supplier portal.
+7. **Keeps a file.** When a case ends, the Archivist writes a case file (cause, reasons, decision, the supplier's record) and puts its hash in
+   the receipts. Later investigations of that supplier read the supplier file.
+8. **Proves it.** Every step writes a signed receipt, chained per case, that anyone can verify offline. The audit trail is tamper-evident:
+   change any recorded decision and the chain breaks at that step.
+
+## Autonomy
+
+Levels live in [`relayloom/ap/policy.json`](relayloom/ap/policy.json), read once at start. Bills, photos, model output
+and requests cannot change them.
+
+- **Runs alone:** read bills, count goods, match, investigate mismatches, enter matching bills, check the readback, reconcile after reconnect.
+- **Waits for the owner:** any mismatch, any bill above the owner's amount limit, sending a dispute, a new supplier or changed bank details.
+- **Never:** change bank details from invoice text, enter a bill whose readback failed, change the books while offline.
+
+## What is real and what is labelled
+
+| Part | Status |
+| --- | --- |
+| Muse Glimmer 30B reading bills and writing disputes | Real runs on a laptop CPU: 9 Northgate bill readings, all valid, 4 min 33 s to 8 min 51 s each, and 2 dispute drafts, plus 7 readings on the first bill set ([docs/RESULTS.md](docs/RESULTS.md)). Findings in recorded mode are written by code from the evidence. |
+| SAM 3.1 counting photos | Real runs on the same CPU, 115 saved in `fixtures/recorded/sam` with the numbered overlays. 101 of the 102 counts the system uses match the delivery record. |
+| ERPNext ledger | Real, in Docker on localhost. A built in ledger with the same calls is used in recorded mode. Each run says which ran. |
+| Benchmark | Demo set built by us, real SAM 3.1 counts. See [docs/BENCHMARK.md](docs/BENCHMARK.md). In it the bills come from the generator and the findings are written by code. |
+| Network boundary | **Tested in Docker on 3 November 2026, all checks pass** ([docs/boundary-result.json](docs/boundary-result.json)): the agents run on a network with no route out, direct connections fail, the gateway refuses hosts that are not in the policy and logs each refusal, and all seven cases pass inside. Verification with the laptop itself switched offline is one command, `python scripts/offline_check.py`, which writes a dated report. |
+| Phone alerts | Built: `python -m relayloom.ap --phone`. A separate read only page on your local network, behind a random token, no internet. Covered by unit tests and verified end to end in a phone sized browser. |
+| Security controls | 11 of 11 pass their checks and add about 30 ms to a case ([docs/SECURITY_CHECKS.md](docs/SECURITY_CHECKS.md)). |
+| Video evidence | Built: `python scripts/dock_watch.py clip.mp4` (or a camera number or stream address). A delivery is detected 0.25 s after the first movement at 0.35 ms of compute per frame, the steady views become photographs, and SAM 3.1 counts them. Verified on a recorded demo clip (28 and 18 counted, 46 of 50 billed). The clip is demo. |
+| Real photos | Builder-provided test photos, a mix of free-licence stock and the builder's own, not a claim about real deliveries. 18 photos counted by SAM 3.1 with two words each, 8 with hand counts: at the old setting the total error was 33 items and at 0.5 it was 12 ([docs/REAL_GOODS.md](docs/REAL_GOODS.md), [docs/CONFIDENCE.md](docs/CONFIDENCE.md)). The default confidence is 0.5 because of this. |
+| Real orders | 85 real purchase orders from the State of California open data, 369 cases with the exception types published accounts payable sources describe, all pass ([docs/REAL_WORLD_CHECK.md](docs/REAL_WORLD_CHECK.md)). Running it found and fixed real problems: quantities above 100,000, fractional counts, multi-line orders, unit of measure differences, concurrent receipt writes. |
+| Package | `relayloom` 0.3.0 builds, passes the PyPI check, and installs and runs in a clean environment with the network blocked, 18 of 18 steps ([docs/PACKAGE_CHECK.md](docs/PACKAGE_CHECK.md)), plus 44 command line scenarios ([docs/PACKAGE_SCENARIOS.md](docs/PACKAGE_SCENARIOS.md)). Not yet published to PyPI. |
+| Languages | Phone alerts and the approval screen in English, Tamil and Hindi, 135 strings, every one listed for a native check in [docs/LANGUAGES.md](docs/LANGUAGES.md). A Hindi and a Tamil bill were read by Muse Glimmer with every field correct ([docs/LANGUAGE_BILL_RESULT.md](docs/LANGUAGE_BILL_RESULT.md)). |
+| Real cases | Eleven documented cases from courts, audits and news, each read at its source, not Relayloom users ([docs/SOURCES.md](docs/SOURCES.md)). |
+| Sensors | Out of scope. Nothing is simulated. |
+
+Timings on the screen are real. On this laptop Muse Glimmer needs several minutes per bill and SAM 3.1 about a minute
+per photo. That is why the app runs bills as a background batch.
+
+## Run the cases
+
+Each case is one command that prints PASS or FAIL per check and says which models and which ledger ran. They read bills from
+the saved Muse Glimmer readings and count from the saved SAM 3.1 runs, so all seven pass from a clean clone in seconds.
+`python scripts/export_bench_run.py out.json` runs them with signed receipts. To record fresh readings, run
+`python scripts/record_glimmer.py` (about 1 hour on a laptop CPU).
+
+```sh
+python -m relayloom.ap.cases match       # a matching delivery, entered and checked, no person involved
+python -m relayloom.ap.cases short       # paperwork says 50, the dock got 46: investigation, approval, dispute
+python -m relayloom.ap.cases price       # rate above the order
+python -m relayloom.ap.cases injection   # hidden text asking to change the bank account
+python -m relayloom.ap.cases netcut      # network cut mid batch, reconnect, no duplicate
+python -m relayloom.ap.cases duplicate   # same goods billed again under a new number
+python -m relayloom.ap.cases split       # one order, two deliveries, one bill
+python -m relayloom.ap.benchmark         # the benchmark on the demo set
+```
+
+Add `--live` to run Muse Glimmer and SAM 3.1 on your machine and the ledger in ERPNext.
+
+## Running it live
+
+1. **Muse Glimmer:** download `Muse-Glimmer-30B-KQuant-17GB-Q4_K_M.gguf` from `meta-models/Muse-Glimmer-30B-GGUF` and serve it with
+   llama.cpp b10353 or newer (`llama-server --jinja`). Put its address in `.env` as `GLIMMER_URL`.
+2. **SAM 3.1:** the weights are gated on Hugging Face. Request access, put a read token in `.env` as `HF_TOKEN`, and run
+   `python scripts/record_sam.py`. It needs Ultralytics 8.4 or newer in the Python named by `RELAYLOOM_SAM_PYTHON`.
+3. **ERPNext:** `docker compose -f pwd.yml up -d` from `frappe/frappe_docker`, then `python scripts/setup_erpnext.py`.
+   It replaces the default password, creates an API user and seeds the demo records.
+
+Keys live only in `.env`, which git ignores. The paid Meta Model API adapter in `relayloom/meta.py` is kept and stays off.
+
+## Tests
+
+```sh
+python -m pytest -q                                   # 127 Python tests
+node --test tests/ui.test.cjs tests/verify.test.cjs   # 14 Node tests
+```
+
+The site is built from `site-src` (`npm install`, `npm run data`, `npm run build`) into `site/`.
+
+## Repository map
+
+| Where | What |
+| --- | --- |
+| `relayloom/ap/` | The product: policy, masking, schema, matcher, Investigator, ledger, receipts, gateway, agents. |
+| `fixtures/` | Demo bills, delivery photos and the benchmark set, plus `fixtures/recorded/` with real SAM 3.1 and Muse Glimmer outputs. |
+| `docs/RESULTS.md`, `docs/BENCHMARK.md` | The evidence: timings, counts, the seven cases and the benchmark. |
+| `site-src/` and `site/` | The website: source and the built version served on Vercel. |
+| `scripts/` | Recording, exporting, fixtures and the boundary probe. |
+| `deploy/` | The Docker network with no route out. |
+| `relayloom/` (controller, server) and `web/` | The first workroom from 28 to 30 October. The accounts payable system reuses its approval, limit and receipt ideas. |
+
+Built on Meta open weights and the official open-weight cookbook: the Reader uses the structured output and reasoning
+effort recipes for Muse Glimmer ([sources](docs/SOURCES.md)). Theme: Push the Frontier.
+
+## Hackathon
+
+Meta Global AI Developer Hackathon, Startups track. The building period is 27 October to 4 November 2026 (ET).
+Everything in this repository was built inside it; see [docs/HACKATHON_UPDATES.md](docs/HACKATHON_UPDATES.md) for each
+commit and what it added. The shared revision workroom from 28 to 30 October is still here (`python -m relayloom`); the
+accounts payable system is built on its approval, limit and receipt ideas.
+
+## Read more
+
+- [Benchmark](docs/BENCHMARK.md) · [Results from our own runs](docs/RESULTS.md) · [Sources](docs/SOURCES.md) · [Submission text](docs/SUBMISSION_FORM_TEXT.md)
+- [Hackathon updates by commit](docs/HACKATHON_UPDATES.md) · [Submission notes](SUBMISSION_META.md) · [Video script](docs/VIDEO_SCRIPT.md)
+- [Submission checklist](docs/SUBMIT_CHECKLIST.md) · [X post](docs/X_POST.md) · [Autonomy](docs/AUTONOMY.md) · [Product and architecture](docs/PRODUCT.md) · [Security](SECURITY.md)
+
+Use demo information only. This is a loopback app, not a hosting service; do not expose its port.
+
+## License and authorship
+
+MIT. Original work by Sriharsan B S. No customers, pilots, revenue or funding are claimed.

relayloom-0.3.0/README_PYPI.md

@@ -0,0 +1,60 @@
+# Relayloom
+
+**Pay for what arrived. Prove it.**
+
+Relayloom matches a supplier bill with the purchase order and with what was actually counted on the dock, holds any payment the goods do not support, and writes **signed receipts** you can verify with the network off. Muse Glimmer and SAM 3.1, open weight Meta models, run on your own machine.
+
+The paperwork says 50. The dock got 46. `relayloom check` says HELD, and says why.
+
+```bash
+python -m pip install relayloom
+relayloom doctor
+```
+
+## Try it in a minute, no models needed
+
+`bill.json` (what the bill says), `po.json` (what was ordered), and a count of what arrived:
+
+```bash
+relayloom check --bill-json bill.json --po po.json --counted 46
+relayloom verify relayloom-out/receipts.jsonl
+```
+
+```text
+Bill CAL-0990: billed 50, counted 46. Result: HELD
+  - CARTON-HD: billed 50 with 0 already billed, received 46
+Signed receipts: relayloom-out/receipts.jsonl   Verify: relayloom verify relayloom-out/receipts.jsonl
+```
+
+Exit code `0` means clear to enter, `3` means held, `2` means it could not run. Add `--json` for scripts.
+
+## Count the goods from photos
+
+```bash
+python -m pip install "relayloom[models]"
+python -m pip install git+https://github.com/ultralytics/CLIP.git   # text prompts for SAM 3.1 (a Git-only dependency, so it is not bundled)
+export HF_TOKEN=...            # your own Hugging Face read token (SAM 3.1 needs the access request)
+relayloom models pull          # one time; after this everything runs offline
+relayloom models serve         # Muse Glimmer on 127.0.0.1, in another terminal
+relayloom check --bill bill.pdf --photos dock/ --po po.json --agent
+```
+
+With `--agent`, Muse Glimmer proposes the words to look for, calls SAM 3.1 as a tool, and looks at the numbered overlay itself. **Code owns the number**: it is only ever the masks SAM returned, and a count is accepted only when two different words agree, or when Glimmer has looked at the overlay and no other count contradicts it. Otherwise the bill is held for a person.
+
+## What it does not do
+
+- It does not send a bill, a photo or a number anywhere. `relayloom doctor` and `verify` make no network calls at all.
+- It does not pay anything. It decides, with evidence, and a person approves what the policy says needs approval.
+- It does not claim real time on a CPU. Counting a photo takes about 40 seconds and reading a bill several minutes on a laptop CPU; measured timings are on the [Proof page](https://relayloom.vercel.app/proof).
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `relayloom check` | match a bill, a purchase order and the goods; write signed receipts |
+| `relayloom verify RECEIPTS` | check signatures, hashes and chain order offline |
+| `relayloom doctor` | say what is ready and the one command that fixes what is not |
+| `relayloom models pull` / `serve` | download the models with your own token / start Muse Glimmer locally |
+| `relayloom serve` | the demo app and phone alerts (needs a clone of the repository) |
+
+Docs, the policy file and the receipt format: https://relayloom.vercel.app/developers. Source and threat model: https://github.com/Sriharsan/relayloom. MIT licensed.

relayloom-0.3.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "relayloom"
+dynamic = ["version"]
+description = "Pay for what arrived. Prove it. Accounts payable that counts the goods with open weight Meta models (Muse Glimmer, SAM 3.1) on your own machine."
+readme = "README_PYPI.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Sriharsan B S" }]
+keywords = ["accounts payable", "three-way match", "invoice", "receiving", "SAM 3.1", "Muse Glimmer", "signed receipts", "offline", "local-first"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Financial :: Accounting",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+    "Typing :: Typed",
+]
+dependencies = ["cryptography>=44", "PyMuPDF>=1.26", "opencv-python-headless>=4.10", "numpy>=1.26", "Pillow>=10"]
+
+[project.optional-dependencies]
+models = ["ultralytics>=8.3", "huggingface_hub>=0.26"]
+qr = ["segno>=1.6"]
+
+[project.scripts]
+relayloom = "relayloom.cli:main"
+
+[project.urls]
+Homepage = "https://relayloom.vercel.app"
+Documentation = "https://relayloom.vercel.app/developers"
+Source = "https://github.com/Sriharsan/relayloom"
+Issues = "https://github.com/Sriharsan/relayloom/issues"
+Changelog = "https://github.com/Sriharsan/relayloom/blob/main/CHANGELOG.md"
+
+[tool.setuptools]
+packages = ["relayloom", "relayloom.ap"]
+
+[tool.setuptools.dynamic]
+version = { attr = "relayloom.__version__" }
+
+[tool.setuptools.package-data]
+relayloom = ["policy.json", "py.typed"]
+"relayloom.ap" = ["policy.json", "py.typed"]

relayloom-0.3.0/relayloom/__init__.py

@@ -0,0 +1,3 @@
+"""Relayloom: accounts payable that checks the goods, not just the paperwork."""
+
+__version__ = "0.3.0"

relayloom-0.3.0/relayloom/__main__.py

@@ -0,0 +1,39 @@
+"""Start Relayloom. Rehearsal is the default; Meta requires explicit opt-in."""
+import argparse
+from pathlib import Path
+
+from .controller import Controller
+from .server import LocalServer
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--port", type=int, default=8800)
+    parser.add_argument("--database", type=Path, default=Path("data/relayloom.sqlite3"))
+    parser.add_argument("--enable-meta-synthetic", action="store_true", help="Allow billable Meta calls only after explicit environment configuration; synthetic fixture only")
+    args = parser.parse_args()
+    if not 1 <= args.port <= 65535:
+        parser.error("port must be between 1 and 65535")
+    if args.enable_meta_synthetic:
+        from .meta import MetaWorker
+        try:
+            worker = MetaWorker.from_environment()
+        except (ValueError, OSError) as error:
+            parser.error(str(error))
+        controller = Controller(args.database, worker=worker)
+    else:
+        controller = Controller(args.database)
+    server = LocalServer(("127.0.0.1", args.port), controller)
+    print(f"Relayloom {controller.mode} mode: http://127.0.0.1:{args.port}")
+    print("Synthetic specialist outputs. No live inference or external actions." if controller.mode == "rehearsal" else "Meta enabled for the bundled fictional fixture. Run specialists may consume credits. No external actions.")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        controller.close()
+
+
+if __name__ == "__main__":
+    main()

relayloom-0.3.0/relayloom/ap/__main__.py

@@ -0,0 +1,3 @@
+from .app import main
+
+main()