simplicio-loop 3.9.1__tar.gz → 3.11.0__tar.gz

{simplicio_loop-3.9.1/simplicio_loop.egg-info → simplicio_loop-3.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.9.1
+Version: 3.11.0
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (6 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -26,17 +26,6 @@ Requires-Dist: pytest>=7; extra == "dev"
 Provides-Extra: ml
 Requires-Dist: model2vec>=0.3; extra == "ml"
 Requires-Dist: numpy>=1.21; extra == "ml"
-Provides-Extra: onnx
-Requires-Dist: onnxruntime>=1.16; extra == "onnx"
-Requires-Dist: huggingface_hub>=0.20; extra == "onnx"
-Requires-Dist: tokenizers>=0.15; extra == "onnx"
-Requires-Dist: numpy>=1.21; extra == "onnx"
-Requires-Dist: pillow>=9; extra == "onnx"
-Provides-Extra: kompress
-Requires-Dist: onnxruntime>=1.16; extra == "kompress"
-Requires-Dist: huggingface_hub>=0.20; extra == "kompress"
-Requires-Dist: tokenizers>=0.15; extra == "kompress"
-Requires-Dist: numpy>=1.21; extra == "kompress"
 Dynamic: license-file
 
 # simplicio-loop

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/README.md

@@ -9,9 +9,10 @@
   <a href="#-the-11-skills--accelerators"><img src="https://img.shields.io/badge/skills-11-7C3AED" alt="11 skills"></a>
   <a href="#-source-adapters"><img src="https://img.shields.io/badge/source%20adapters-5-00E08A" alt="5 source adapters"></a>
   <a href="#-11-runtimes-one-protocol"><img src="https://img.shields.io/badge/runtimes-11-2563EB" alt="11 runtimes"></a>
-  <a href="#-the-44-extension-points"><img src="https://img.shields.io/badge/extension%20points-44-00E08A" alt="44 extension points"></a>
-  <a href="#-token-economy"><img src="https://img.shields.io/badge/tokens-up%20to%2096%25%20fewer-green" alt="Up to 96% fewer tokens"></a>
+  <a href="#-the-48-extension-points"><img src="https://img.shields.io/badge/extension%20points-48-00E08A" alt="48 extension points"></a>
+  <a href="#-token-economy"><img src="https://img.shields.io/badge/tokens-up%20to%2096%25%20fewer-green" alt="Up to 90% fewer tokens"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="License"></a>
+  <a href="https://discord.gg/wM6tr7xVb"><img src="https://img.shields.io/badge/Discord-Join%20Simplicio-5865F2?logo=discord&logoColor=white" alt="Join the Simplicio Discord"></a>
 </p>
 
 <p align="center">
@@ -62,7 +63,7 @@ loop that **runs the code (not just compiles it)**, opens PRs, resolves CI/revie
 and keeps watching **24/7** for new work — all behind safety gates and a hard cost kill-switch.
 
 ```text
-/simplicio-tasks termine as issues abertas
+/simplicio-tasks finish all open issues
 → identity + pre-flight (kill-switch, auth, watcher)
 → discover 50 issues · dedup · build dependency DAG
 → autoscale fleet = 14 · pipeline implement→review→merge
@@ -74,22 +75,26 @@ and keeps watching **24/7** for new work — all behind safety gates and a hard
 Three things make it different: it is a **super-plugin of focused skills**, it runs the **same
 protocol on 11 runtimes**, and it does all of this with **aggressive, honest token economy**.
 
+<p align="center">
+  <img src="assets/simplicio-loop-infographic.png" alt="simplicio-loop — the whole system at a glance: 6 core skills, 5 satellites, 5 accelerators, 48 extension points, 11 runtimes, up to 90% fewer tokens" width="920" />
+</p>
+
 ---
 
-## 📘 Official capability record (v3.4.0)
+## 📘 Official capability record (v3.10.2)
 
 The complete, official roster of what `simplicio-tasks` ships — every capability below is **real,
-runnable, and tested** (`python3 scripts/check.py`: claims-audit 4/4 + 24 tests). Each links to its
+runnable, and tested** (`python3 scripts/check.py`: claims-audit 4/4 + 28 tests). Each links to its
 deep section and its worker.
 
 | Capability | What it does | Proof / worker | Details |
 |---|---|---|---|
-| 🎬 **Video evidence** (`video_evidence`) | Renders a **deterministic MP4** demo of a screen/feature with [hyperframes](https://github.com/heygen-com/hyperframes) — fulfils `/simplicio-tasks faça um vídeo demonstrativo da tela X` and doubles as CI-reproducible proof a UI change works | `scripts/video_evidence.py` · BLOCKED (never fake-pass) without Node 22+/FFmpeg | [§ Video evidence](#-video-evidence--demo-videos-via-hyperframes) |
+| 🎬 **Video evidence** (`video_evidence`) | Records the **real browser session** as moving proof a UI change works (Playwright, default); renders a **deterministic captioned MP4** with [hyperframes](https://github.com/heygen-com/hyperframes) for an explicit explainer request (`/simplicio-tasks make a video of screen X`) | `scripts/video_evidence.py` · BLOCKED (never fake-pass) without the toolchain | [§ Video evidence](#-video-evidence--playwright-by-default-hyperframes-on-request) |
 | 🧠 **Attempt memory + stall detector** | A durable run-journal (`.orchestrator/loop/journal.jsonl`) + a stall detector so the loop **changes strategy instead of oscillating**; incremental triage (`since`) reads only the delta each turn | `scripts/loop_journal.py` · `selftest` 9/9 | [§ Anti-oscillation](#-attempt-memory--stall-detector-anti-oscillation) |
+| 🧭 **Repo conventions** (`repo_conventions`) | **Learns the repo's own playbook** — mines git history + merged PRs + static config into `.orchestrator/conventions.json` so every new branch/commit/PR mirrors the team's established style; worktree-per-item isolation is the default | `scripts/repo_conventions.py` · `selftest` 19/19 | [§ The full flow](#️-the-full-flow--from-demand-to-delivery) |
 | 🔒 **Fail-closed safety gate** (`action_gate`) | A `PreToolUse`/git-pre-push hook that **mechanically blocks** force-push, history rewrite, mass-delete, destructive DDL, infra teardown, and secret-laden commits/pushes — Step 5 made executable, not prose | `hooks/action_gate.py` · `selftest` 15/15 | [§ Safety](#-safety-non-negotiable) |
 | 🔬 **Local verification** | A test suite (worker selftests + an **e2e of the loop driver** proving evidence-gated exit) + a **claims-audit** (referenced scripts exist · counts consistent · `_bundle ≡ source`) — all local, **no paid CI** | `scripts/check.py` · `scripts/claims_audit.py` · `tests/` | [§ Tests & local checks](#-tests--local-checks-no-paid-ci) |
 | ✅ **Honest savings** | The savings line is now **evidence-gated, not mandatory** — a number is shown only with a measured receipt (clamp/signatures/cache/`deterministic_edit`/ledger); never fabricated | token-economy contract | [§ Token economy](#-token-economy) |
-| 💳 **Open-core billing** | A deterministic, privacy-preserving meter→invoice over the metering the loop already produces (kill-switch + `savings_ledger`) — three tiers (seat/run/metered) | `scripts/billing_aggregator.py` · `selftest` 11/11 | [PRICING.md](PRICING.md) |
 
 Two loop **modes** make termination explicit: **converge** (a single hard task — ends on the
 evidence-gated `<promise>` or a stall escalation) vs **drain** (a queue — ends when the source
@@ -111,7 +116,7 @@ fallback.
 
 | # | Capability | Absorbs | What it does | Token impact |
 |---|---|---|---|---|
-| 1 | 🔁 **simplicio-tasks** | — | The orchestrator loop: 44 extension points, dual-path router, self-audit convergence | Core |
+| 1 | 🔁 **simplicio-tasks** | — | The orchestrator loop: 48 extension points, dual-path router, self-audit convergence | Core |
 | 2 | ♾️ **simplicio-loop** | [ralph-loop](https://github.com/cursor/plugins/tree/main/ralph-loop) | Hardened Ralph loop: evidence-gated `<promise>` exit, max_iterations cap | Loop drive |
 | 3 | 🧱 **simplicio-orient** | [rtk](https://github.com/rtk-ai/rtk) + [caveman](https://github.com/JuliusBrussee/caveman) | Terminal-first execution, output-reduction catalog, tee-cache, signatures-read | L0 deterministic |
 | 4 | 🔥 **simplicio-review** | [thermos](https://github.com/cursor/plugins/tree/main/thermos) | Parallel adversarial review on distinct rubrics → deduped verdict | Quality gate |
@@ -120,8 +125,8 @@ fallback.
 | 7 | 🧭 **Understand Anything** | [Egonex-AI](https://github.com/Egonex-AI/Understand-Anything) | Knowledge graph orient: semantic search, guided tours, dependency graph | **L0 zero tokens** |
 | 8 | 📊 **agentsview** | [kenn-io](https://github.com/kenn-io/agentsview) | Session analytics, cost tracking, stalled-session discovery | **L1** SQL only |
 | 9 | ⚡ **LMCache** | [LMCache](https://github.com/LMCache/LMCache) | KV cache between loop turns — 40-70% TTFT reduction on local models | GPU time ↓ |
-| 10 | 🗜️ **Simplicio capture engine** | `engine/simplicio_engine.py` (native, stdlib-only; savings-schema compatible with the OSS [headroom](https://github.com/headroomlabs-ai/headroom) project) | Transparent capture proxy: forwards to the real provider, measures + deterministically compresses, writes `proxy_savings.json` | **deterministic** |
-| 11 | 🎬 **video_evidence (hyperframes)** | [hyperframes](https://github.com/heygen-com/hyperframes) | Renders a **deterministic MP4** demo video of a screen/feature — fulfils `/simplicio-tasks faça um vídeo demonstrativo da tela X` AND doubles as CI-reproducible proof a UI change works | Evidence producer |
+| 10 | 🗜️ **Simplicio capture engine** | `engine/simplicio_engine.py` (native, stdlib-only) | Transparent capture proxy: forwards to the real provider, measures + deterministically compresses, writes `proxy_savings.json` | **deterministic** |
+| 11 | 🎬 **video_evidence** | Playwright (default) · [hyperframes](https://github.com/heygen-com/hyperframes) (on request) | Records the **real session** as moving proof of a UI change (Playwright); renders a **deterministic captioned MP4** explainer with hyperframes when the video IS the deliverable | Evidence producer |
 
 Each skill lives under [`.claude/skills/`](.claude/skills); each accelerator has a reference doc
 under `.claude/skills/simplicio-tasks/references/` (the video producer:
@@ -223,7 +228,7 @@ flowchart TD
   subgraph QG["7 · Quality gates"]
     direction LR
     Q1["AC gate = real DoD"]
-    Q2["WORKS not just compiles · web_verify (Playwright) · video_evidence (hyperframes MP4)"]
+    Q2["WORKS not just compiles · web_verify (Playwright) · video_evidence (Playwright recording · hyperframes on request)"]
     Q3["adversarial review · thermos rubrics"]
   end
   QG --> SG
@@ -294,42 +299,36 @@ loop_journal.py stall --k 3 --exit-code      # PROGRESS → re-feed · STALLED
 
 ---
 
-## 🎬 Video evidence — demo videos via hyperframes
+## 🎬 Video evidence — Playwright by default, hyperframes on request
 
-The loop can **create demonstration videos** of a screen/feature on request, and reuse that video
-as proof a change works. The producer is [**hyperframes**](https://github.com/heygen-com/hyperframes)
-(by HeyGen) — it renders HTML/CSS/media compositions to a **deterministic MP4** ("same input, same
-frames, same output"), so the demo is a CI-reproducible artifact, not a throwaway recording. No API
-keys; local render via headless Chrome + FFmpeg (Node 22+).
-
-Two ways it fires — both via the `video_evidence` extension point (worker
-[`scripts/video_evidence.py`](scripts/video_evidence.py), contract
+The loop produces **demo videos** as proof a change works — **two engines**, one `video_evidence`
+extension point (worker [`scripts/video_evidence.py`](scripts/video_evidence.py), contract
 [`references/video-evidence.md`](.claude/skills/simplicio-tasks/references/video-evidence.md)):
 
-1. **On request — the video IS the deliverable.** Ask for it directly and the orchestrator routes
-   the work-item to the hyperframes producer:
+1. **Default — the normal evidence flow uses Playwright.** After a UI change, `video_evidence`
+   records the **real browser session** driving the screen (Playwright native video → `.webm`, →
+   `.mp4` with FFmpeg) — the strongest "works, not just compiles" receipt (Step 4b) and a valid
+   evidence-gated `<promise>`.
 
-   ```text
-   /simplicio-tasks faça um vídeo demonstrativo da tela de login do sistema
-   → detect: video-creation request  → drive the screen with web_verify (per-step screenshots)
-   → scaffold a hyperframes composition  → npx hyperframes render → deterministic MP4
-   → attach the MP4 to the PR as evidence + close with the link
+   ```bash
+   python3 scripts/video_evidence.py verify --url http://localhost:3000/login \
+       --name login-demo --expect "Sign in" --issue 42 [--upload --pr 42]
    ```
 
-2. **As proof — the video backs a code change.** After a UI change, the same MP4 walkthrough is the
-   strongest "works, not just compiles" receipt (Step 4b) and a valid evidence-gated `<promise>`
-   for the loop — a video that never rendered yields **BLOCKED**, never a fake pass.
+2. **On request — a personalized explainer uses hyperframes.** When the deliverable IS a video
+   ("make an explainer video of screen X"), the orchestrator renders a **deterministic, captioned
+   slideshow** of the `web_verify` screenshots with
+   [**hyperframes**](https://github.com/heygen-com/hyperframes) (by HeyGen — "same input, same
+   frames, same output", CI-reproducible, no API keys, local render via headless Chrome + FFmpeg).
 
-The two evidence producers chain: `web_verify` (Playwright) captures the per-step screenshots,
-`video_evidence` (hyperframes) assembles them into a captioned, deterministic MP4 walkthrough.
-Evidence is always a **file path + boolean verdict** — never video bytes in context (token economy).
+   ```text
+   /simplicio-tasks make an explainer video of the system login screen
+   → detect: video-creation request → web_verify captures the screens
+   → video_evidence verify --engine hyperframes → deterministic MP4 → attached to the PR
+   ```
 
-```bash
-# one-shot, outside the loop
-python3 scripts/video_evidence.py detect  --goal "grave um vídeo da tela de checkout"
-python3 scripts/video_evidence.py verify  --name checkout-demo \
-    --frames .orchestrator/tee/web --title "Checkout" --issue 42 [--upload --pr 42]
-```
+Either engine: a video that never recorded/rendered yields **BLOCKED**, never a fake pass. Evidence
+is always a **file path + boolean verdict** — never video bytes in context (token economy).
 
 ---
 
@@ -341,10 +340,10 @@ python3 scripts/video_evidence.py verify  --name checkout-demo \
 | Terminal-first execution | Facts from shell, not LLM hallucination |
 | Output-reduction catalog | Caps per command type (`CAP_ERRORS=20`, `CAP_WARNINGS=10`, `CAP_LIST=20`) — `orient_clamp.py` |
 | Tee+CCR cache on failure | Never re-run a failed command — read the cached output |
-| Signatures-only reads | `simplicio signatures <file>` — 870-line file → 65 lines (**93% saved**), bodies stripped |
+| Signatures-only reads | `simplicio-cli signatures <file>` — 870-line file → 65 lines (**93% saved**), bodies stripped |
 | `simplicio-compress` | Terse prose + one-time memory compaction |
 | `orient_clamp.py` | Clamp + tee on every shell command, zero wiring |
-| Native response cache | repeated deterministic (temp=0) request → served from cache, skips the LLM call (**100% on hit**) — `simplicio cache`, on by default (`SIMPLICIO_CACHE=0` to disable) |
+| Native response cache | repeated deterministic (temp=0) request → served from cache, skips the LLM call (**100% on hit**) — `simplicio-cli cache`, on by default (`SIMPLICIO_CACHE=0` to disable) |
 | Simplicio capture proxy + MCP | 60-95% fewer tokens on tool outputs via a transparent compression daemon |
 
 Savings only count on a verified-correct outcome. Baseline = the cheapest sensible non-orchestrated
@@ -368,11 +367,11 @@ Two different things happen when you call **`simplicio-tasks`**, and they behave
 | Runtime | Economy (skill) | Measurement (monitor) |
 |---|---|---|
 | **Hermes** | ✓ | ✓ **automatic** — already routed through the proxy (`base_url → :8788`) |
-| **Claude** | ✓ (skill + hooks) | ✗ by default — Claude talks to `api.anthropic.com` directly; measured only once routed (`simplicio wrap claude`, or `ANTHROPIC_BASE_URL → http://127.0.0.1:8788`) |
-| **Codex** | ✓ (skill) | ✗ by default — `simplicio init codex` adds the MCP tools but does not route LLM traffic; measured with `simplicio wrap codex` or an OpenAI base-url pointing at the proxy |
+| **Claude** | ✓ (skill + hooks) | ✗ by default — Claude talks to `api.anthropic.com` directly; measured only once routed (`simplicio-cli wrap claude`, or `ANTHROPIC_BASE_URL → http://127.0.0.1:8788`) |
+| **Codex** | ✓ (skill) | ✗ by default — `simplicio-cli init codex` adds the MCP tools but does not route LLM traffic; measured with `simplicio-cli wrap codex` or an OpenAI base-url pointing at the proxy |
 
 So: the **savings happen on every runtime**; the **monitor tallies them automatically on Hermes**, and on
-Claude/Codex after a **one-time routing step** (`simplicio wrap …` / base-url → `:8788`). Without routing,
+Claude/Codex after a **one-time routing step** (`simplicio-cli wrap …` / base-url → `:8788`). Without routing,
 the economy still applies — the monitor just won't count those tokens. `scripts/simplicio-economy.sh wire`
 does this routing for OpenAI-compatible clients at install time.
 
@@ -401,8 +400,8 @@ capture runs **without invoking the loop** — see `references/token-capture.md`
 ### 🛠️ The capture engine — one native module, every command
 
 [`engine/simplicio_engine.py`](engine/simplicio_engine.py) is the native Simplicio capture engine
-(stdlib-only, fail-open) — a **full reimplementation of the upstream
-[headroom](https://github.com/headroomlabs-ai/headroom) surface with no external dependency**. Run any
+(stdlib-only, fail-open) — a **native, transparent capture proxy + deterministic compression engine
+with no external dependency**. Run any
 command via the [`scripts/simplicio-engine`](scripts/simplicio-engine) wrapper (e.g. `simplicio-engine doctor`):
 
 | Command | What it does |
@@ -412,7 +411,6 @@ command via the [`scripts/simplicio-engine`](scripts/simplicio-engine) wrapper (
 | `cache` | native response cache (`stats`/`clear`) — a repeated deterministic request is served from cache, skipping the LLM call |
 | `signatures` | signatures-only view of a source file (bodies stripped, ~93% fewer tokens to read code) |
 | `semantic` | reversible extractive (semantic-lite) compression |
-| `kompress` | **ONNX** semantic token-pruning via the real `kompress-v2-base` model |
 | `detect` | content-type detection + smart per-block routing |
 | `rag` | TF-IDF (or `--ml` embedding) retrieval over the CCR memory store |
 | `memory` | CCR compress-cache-retrieve store (`remember`/`recall`/`forget`/`list`/`stats`) |
@@ -420,25 +418,6 @@ command via the [`scripts/simplicio-engine`](scripts/simplicio-engine) wrapper (
 | `init` / `wrap` | register Simplicio into a client (Claude / Codex / Copilot / OpenClaw) · run a client with capture routing |
 | `report` / `audit` / `capture` / `evals` | savings report · audit a tree for compression opportunity · dry-run a request · compression regression gate |
 
-### 🧠 Optional real ML models — `pip install "simplicio-loop[onnx]"`
-
-Four **real**, public (Apache-2.0) ONNX models run natively — the same models the upstream uses.
-Without the extra, the deterministic stdlib path covers everything; models download on first use.
-
-| Model | Command | Use |
-|---|---|---|
-| `kompress-v2-base` | `simplicio kompress` | semantic token pruning |
-| `technique-router-onnx` | `simplicio router` | technique routing |
-| `all-MiniLM-L6-v2-onnx` | `simplicio embed` · `rag --ml` | embeddings + semantic RAG |
-| `siglip-image-encoder-onnx` | `simplicio image` | image-compression content verifier |
-
-### ⚙️ Native Rust performance core (optional)
-
-[`rust/`](rust) ships four crates ported + rebranded from the upstream (Apache-2.0; `NOTICE` credits it):
-`simplicio-core` (compressors + smart-crusher), `simplicio-py` (PyO3 bindings), `simplicio-proxy`
-(axum reverse proxy), `simplicio-parity` (Rust↔Python parity harness). Build with `maturin` — the Python
-engine works fully without them; the crates only add native speed.
-
 ---
 
 ## 🏛️ Design pillars (in detail)
@@ -468,9 +447,8 @@ pwsh scripts/install.ps1 <runtime> [-Global]                    # Windows
 
 **Install is complete by default — it installs everything.** One command sets up the whole stack:
 the two loop operators (`simplicio-mapper` + `simplicio-cli`, auto-handling PEP 668 / externally-managed
-Python and symlinking the binaries onto `PATH`), the **full Python stack** (the package + the `[onnx]`
-models backend: onnxruntime + huggingface_hub + tokenizers + pillow, so `simplicio kompress/router/embed/image`
-work), the **6 skills + hooks** with the loop's Stop hook wired, and the **always-on capture proxy**
+Python and symlinking the binaries onto `PATH`), the **full Python stack** (the package itself),
+the **6 skills + hooks** with the loop's Stop hook wired, and the **always-on capture proxy**
 with Claude + Codex + Hermes **routed and measured** in the background. The **dashboard opens once** on a
 fresh install, then it's on-demand (`simplicio-loop dashboard` / `simplicio-economy.sh monitor`); the
 **menu-bar tray never opens by itself** — nothing is forced to stay open.
@@ -495,16 +473,17 @@ python3 scripts/doctor.py --repair   # install/wire what's fixable; make everyth
 ```
 
 `doctor` separates **REQUIRED** (python3, the two loop operators, the 6 skills, the loop hooks, the
-capture proxy — `--repair` installs/wires them) from **OPTIONAL** accelerators (the ONNX models
-backend, the native **Rust** core, the tray dep). **Missing an optional piece is never a failure and
+capture proxy — `--repair` installs/wires them) from **OPTIONAL** accelerators (the tray dep).
+**Missing an optional piece is never a failure and
 never blocks** — the Python engine + the deterministic path cover everything; the exit code is 0 as
 long as every REQUIRED item is healthy.
 
-Or, on Claude Code / Cursor, add it as a marketplace plugin:
+Or, on Claude Code / Cursor, install it straight from the latest GitHub release (no marketplace):
 
-```
-/plugin marketplace add wesleysimplicio/simplicio-loop
-/plugin install simplicio-loop@simplicio
+```bash
+gh release download --repo wesleysimplicio/simplicio-loop --archive tar.gz
+tar xzf simplicio-loop-*.tar.gz && cd simplicio-loop-*/
+bash scripts/install.sh claude    # or: bash scripts/install.sh cursor
 ```
 
 Then:
@@ -530,7 +509,7 @@ gate + secret-scan on. With `ceiling = 0` the watcher refuses to run unattended
   mass-file delete → stop and ask. Headless + no approver → remove the destructive capability.
 - **Enforced, not just promised** — `hooks/action_gate.py` is a **fail-closed** `PreToolUse` /
   git-pre-push hook that mechanically blocks the above (and secret-laden commits) *before* they run.
-  The safety contract holds even if the model forgets it. `selftest` proves the ruleset (14/14).
+  The safety contract holds even if the model forgets it. `selftest` proves the ruleset (15/15).
 - **4-state pre-execution verdict** — optimization may never raise a command's risk tier.
 - **Trust-before-load** — perception-shaping config (clamp profiles, suppression lists) is
   untrusted until a human reviews and hash-pins it.
@@ -568,12 +547,3 @@ python3 scripts/check.py            # the whole gate (audit + tests)
 ## 📄 License
 
 MIT
-
-## 💳 Pricing
-
-The engine is **free and MIT** — fully self-hostable, never crippled. A proposed **open-core
-hosted tier** (managed 24/7 watcher, hosted operators, retained savings dashboard, distributed
-`video_evidence` render) is sketched in [`PRICING.md`](PRICING.md), along with a deterministic,
-privacy-preserving billing architecture built on the metering primitives the loop already
-produces (`loop-budget.json` kill-switch + `savings_ledger`). It is a proposal — nothing is billed
-today.

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.9.1"
+version = "3.11.0"
 description = "The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (6 skills) that drains any queue of work end-to-end on any LLM/runtime."
 readme = "PYPI.md"
 requires-python = ">=3.8"
@@ -29,7 +29,7 @@ dependencies = [
   "simplicio-cli",
 ]
 
-# Optional: the real embedding backend for `simplicio semantic --ml` / `simplicio rag --ml`.
+# Optional: the real embedding backend for `simplicio-cli semantic --ml` / `simplicio-cli rag --ml`.
 # The native engine itself is stdlib-only; this only enables embedding-based semantic dedup +
 # meaning retrieval. `pip install "simplicio-loop[ml]"`.
 [project.optional-dependencies]
@@ -37,11 +37,6 @@ dependencies = [
 # only a convenience for nicer output / IDE integration — never required.
 dev = ["pytest>=7"]
 ml = ["model2vec>=0.3", "numpy>=1.21"]
-# ONNX model commands (the REAL headroom models, downloaded on first use):
-#   kompress -> chopratejas/kompress-v2-base (~274MB) · router -> chopratejas/technique-router-onnx (~32MB)
-#   embed    -> Qdrant/all-MiniLM-L6-v2-onnx (~90MB). `pip install "simplicio-loop[onnx]"`.
-onnx = ["onnxruntime>=1.16", "huggingface_hub>=0.20", "tokenizers>=0.15", "numpy>=1.21", "pillow>=9"]
-kompress = ["onnxruntime>=1.16", "huggingface_hub>=0.20", "tokenizers>=0.15", "numpy>=1.21"]
 
 [project.urls]
 Homepage = "https://github.com/wesleysimplicio/simplicio-loop"

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/simplicio_loop/__init__.py

@@ -13,6 +13,6 @@ try:
     try:
         __version__ = _v("simplicio-loop")
     except PackageNotFoundError:
-        __version__ = "3.9.1"
+        __version__ = "3.11.0"
 except Exception:  # pragma: no cover
-    __version__ = "3.9.1"
+    __version__ = "3.11.0"

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/simplicio_loop/_bundle/hooks/README.md

@@ -39,7 +39,7 @@ the ruleset (14/14).
 `orient_clamp.py` is a plain wrapper — use it anywhere, any runtime, no hooks:
 
 ```bash
-python3 hooks/orient_clamp.py -- cargo test          # reduced output, tee log on failure
+python3 hooks/orient_clamp.py -- go test ./...          # reduced output, tee log on failure
 python3 hooks/orient_clamp.py --json -- git diff      # machine summary
 ```
 

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/simplicio_loop/_bundle/hooks/action_gate.py

@@ -41,6 +41,34 @@ except Exception:
 HERE = os.path.dirname(os.path.abspath(__file__))
 REPO = os.path.dirname(HERE)
 
+
+def _project_relevant():
+    """Project-relevance gate for the PreToolUse path ONLY.
+
+    The plugin's Bash gate must not impose itself on every repo on the machine — it acts
+    only inside an active simplicio-loop project. Relevant when the opt-in env var
+    SIMPLICIO_LOOP (or SIMPLICIO_ORCHESTRATOR) is set, or when a `.orchestrator/` marker
+    dir (the orchestrator's state dir, created when the loop runs) exists in the current
+    working directory or an ancestor. Outside such a project the PreToolUse hook no-ops.
+    The explicit CLI / git-hook entry points (check / scan-diff / selftest) are NOT gated —
+    they are invoked deliberately and always run.
+    """
+    if os.environ.get("SIMPLICIO_LOOP") or os.environ.get("SIMPLICIO_ORCHESTRATOR"):
+        return True
+    home = os.path.realpath(os.path.expanduser("~"))
+    d = os.path.realpath(os.getcwd())
+    for _ in range(40):  # depth backstop so an off-home tree can't climb forever
+        parent = os.path.dirname(d)
+        # Never treat the home dir or a drive/filesystem root as a project marker location:
+        # a stray ~/.orchestrator, or a marker at a drive root, must not widen the scope.
+        if d == home or parent == d:
+            return False
+        if os.path.isdir(os.path.join(d, ".orchestrator")):
+            return True
+        d = parent
+    return False
+
+
 # Irreversible / history-rewriting / destructive ops → BLOCK and route to a human (Step 5).
 # High-precision patterns: each is genuinely hard to undo; benign commands never match.
 IRREVERSIBLE = [
@@ -193,6 +221,12 @@ def cmd_scan_diff(opts):
 
 def from_pretooluse():
     """Claude PreToolUse mode: read tool call JSON on stdin, gate the Bash command."""
+    try:
+        relevant = _project_relevant()
+    except Exception:
+        relevant = True  # safety gate: can't prove irrelevant → still run the gate (fail-closed)
+    if not relevant:
+        sys.exit(0)  # outside a simplicio-loop project → no-op (project-relevance gate)
     try:
         raw = sys.stdin.read()
         data = json.loads(raw) if raw.strip() else {}

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/simplicio_loop/_bundle/hooks/loop_stop.py

@@ -23,6 +23,8 @@ DONE_FLAG = os.path.join(LOOP_DIR, "done")
 LAST_RESP = os.path.join(LOOP_DIR, "last_response.txt")
 STOP_SIGNAL = os.path.join(".orchestrator", "STOP")
 BUDGET = os.path.join(".orchestrator", "loop-budget.json")
+GATE_LOCK = os.path.join(LOOP_DIR, "gate.lock")
+GATE_TTL_SEC = 1800  # 30 min — a stale lock must NEVER permanently trap the loop (fail-open)
 
 EVIDENCE_RE = re.compile(
     r"(https?://\S+/pull/\d+)"          # a PR URL
@@ -108,6 +110,23 @@ def last_assistant_text(stdin):
     return ""
 
 
+def gate_running():
+    """True when a background gate (verification workflow / CI / long task) is in flight + fresh.
+
+    The orchestrator touches `.orchestrator/loop/gate.lock` before launching a background gate and
+    removes it on completion. While present AND fresh, the turn ended because we are WAITING on that
+    gate — not because the loop is idle — so the Stop hook must NOT re-feed the goal. A stale lock
+    (older than the TTL) is ignored so a leftover file can never trap the agent (fail-open).
+    """
+    try:
+        if not os.path.exists(GATE_LOCK):
+            return False
+        import time
+        return (time.time() - os.path.getmtime(GATE_LOCK)) < GATE_TTL_SEC
+    except Exception:
+        return False
+
+
 def budget_halted():
     try:
         if not os.path.exists(BUDGET):
@@ -139,6 +158,11 @@ def main():
         # Explicit STOP signal beats everything.
         if os.path.exists(STOP_SIGNAL):
             cleanup_and_stop()
+        # Waiting on a background gate (workflow / CI / long task)? Let the turn end WITHOUT
+        # consuming an iteration or re-feeding — we are blocked on that gate, not idle. The gate's
+        # completion re-invokes the agent; the loop resumes then (lock is gone). Preserves state.
+        if gate_running():
+            allow_stop()
         # (1) No active loop.
         if not os.path.exists(SCRATCHPAD):
             allow_stop()

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/simplicio_loop/_bundle/hooks/orient_rewrite.py

@@ -26,11 +26,32 @@ CLAMP = os.path.join(os.path.dirname(os.path.abspath(__file__)), "orient_clamp.p
 CONFIG = os.path.join(".orchestrator", "orient.toml")
 DEFAULT_EXCLUDES = ["curl", "wget", "playwright", "ssh", "vim", "less", "top", "htop"]
 
+
+def _project_relevant():
+    """Project-relevance gate: this PreToolUse hook acts ONLY inside an active
+    simplicio-loop project, never on unrelated repos. Relevant when the opt-in env var
+    SIMPLICIO_LOOP (or SIMPLICIO_ORCHESTRATOR) is set, or a `.orchestrator/` marker dir
+    exists in the current working directory or an ancestor. Outside such a project the
+    hook no-ops and the command runs raw."""
+    if os.environ.get("SIMPLICIO_LOOP") or os.environ.get("SIMPLICIO_ORCHESTRATOR"):
+        return True
+    home = os.path.realpath(os.path.expanduser("~"))
+    d = os.path.realpath(os.getcwd())
+    for _ in range(40):  # depth backstop so an off-home tree can't climb forever
+        parent = os.path.dirname(d)
+        # Never treat the home dir or a drive/filesystem root as a project marker location:
+        # a stray ~/.orchestrator, or a marker at a drive root, must not widen the scope.
+        if d == home or parent == d:
+            return False
+        if os.path.isdir(os.path.join(d, ".orchestrator")):
+            return True
+        d = parent
+    return False
+
 # read-only, output-heavy commands worth clamping (prefix match on the first token(s))
 ALLOW = [
     "git status", "git log", "git diff", "git show", "git branch",
     "ls", "ll", "dir", "rg ", "grep ", "cat ", "type ", "tree",
-    "cargo check", "cargo test", "cargo clippy", "cargo build",
     "npm test", "npm run", "pnpm test", "yarn test", "jest", "vitest",
     "go test", "go build", "go vet", "pytest", "python -m pytest",
     "mvn ", "gradle ", "tsc", "eslint", "ruff", "golangci-lint",
@@ -61,6 +82,8 @@ def load_excludes():
 
 def main():
     try:
+        if not _project_relevant():
+            allow_unchanged()  # outside a simplicio-loop project → no-op (project-relevance gate)
         raw = sys.stdin.read()
         data = json.loads(raw) if raw.strip() else {}
         ti = data.get("tool_input", data.get("toolInput", {})) or {}

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/simplicio_loop/_bundle/hooks/simplicio_dashboard.py

@@ -30,14 +30,11 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 # Structured savings file written by the capture engine — the primary data source.
 SAVINGS_JSON_CANDIDATES = [
     Path(HOME) / ".simplicio" / "proxy_savings.json",
-    Path(HOME) / ".headroom" / "proxy_savings.json",
 ]
-# Raw proxy log (Simplicio-named first; engine dir + legacy paths kept for back-compat).
+# Raw proxy log (Simplicio-named first; engine dir kept for back-compat).
 LOG_CANDIDATES = [
     Path(HOME) / ".simplicio" / "logs" / "proxy.log",
     Path(HOME) / ".hermes" / "logs" / "simplicio-proxy.log",
-    Path(HOME) / ".headroom" / "logs" / "proxy.log",
-    Path(HOME) / ".hermes" / "logs" / "headroom.log",
 ]
 LOGO_CANDIDATES = [
     REPO_ROOT / "assets" / "simplicio-loop-logo.png",
@@ -45,7 +42,7 @@ LOGO_CANDIDATES = [
 ]
 # Cross-platform temp dir (Windows has no /tmp) — must match simplicio_loop/cli.py PID_FILE.
 PID_FILE = Path(tempfile.gettempdir()) / "simplicio-token-monitor.pid"
-PROXY_PORT = os.environ.get("SIMPLICIO_PROXY_PORT", os.environ.get("HEADROOM_PORT", "8788"))
+PROXY_PORT = os.environ.get("SIMPLICIO_PROXY_PORT", "8788")
 # Engine call: the native Simplicio engine module, invoked cross-platform via this interpreter.
 ENGINE_CMD = [sys.executable or "python3", str(REPO_ROOT / "engine" / "simplicio_engine.py")]
 

{simplicio_loop-3.9.1 → simplicio_loop-3.11.0}/simplicio_loop/_bundle/hooks/simplicio_watch.py

@@ -1,21 +1,26 @@
 #!/usr/bin/env python3
 """Simplicio Token Monitor (CLI watch) — proxy + savings status for simplicio-loop.
 
-The compression proxy is powered by headroom-ai (a third-party accelerator Simplicio
-integrates); its binary is still invoked as `headroom`, so those command names stay.
+Drives the native Simplicio capture engine (`engine/simplicio_engine.py`) — no external
+dependency. Proxy reachability and lifetime savings come from the engine's own
+`doctor` / `memory stats` subcommands.
 
 Usage:
     python3 hooks/simplicio_watch.py status    # show proxy + savings status
     python3 hooks/simplicio_watch.py start     # start the compression proxy
     python3 hooks/simplicio_watch.py stop      # stop the compression proxy
 """
-import json
 import os
 import subprocess
 import sys
+from pathlib import Path
 
 HOME = os.path.expanduser("~")
-LOGS = os.path.join(HOME, ".hermes", "logs")
+LOGS = os.path.join(HOME, ".simplicio", "logs")
+REPO_ROOT = Path(__file__).resolve().parents[1]
+# Native engine: invoked cross-platform via this interpreter (no external binary).
+ENGINE_CMD = [sys.executable or "python3", str(REPO_ROOT / "engine" / "simplicio_engine.py")]
+PROXY_PORT = os.environ.get("SIMPLICIO_PROXY_PORT", "8788")
 PROXY_SERVICE = "ai.simplicio.proxy"
 
 
@@ -32,34 +37,32 @@ def run(cmd, timeout=10):
 
 
 def status():
-    out, rc = run(["lsof", "-i", ":8787"])
-    if "headroom" in out:  # external proxy process name
-        log("✅ Simplicio proxy — RUNNING (port 8787)")
+    out, _ = run([*ENGINE_CMD, "doctor", "--port", PROXY_PORT])
+    running = "running" in out.lower() and "not reachable" not in out.lower()
+    if running:
+        log(f"✅ Simplicio proxy — RUNNING (port {PROXY_PORT})")
     else:
         log("❌ Simplicio proxy — NOT RUNNING")
-    out2, _ = run(["headroom", "memory", "stats"])  # external accelerator binary
+    for line in out.split("\n"):
+        if line.strip().startswith(("proxy:", "savings:")):
+            log(f"  {line.strip()}")
+    out2, _ = run([*ENGINE_CMD, "memory", "stats"])
     for line in out2.split("\n"):
         if "Total" in line or "Database" in line:
             log(f"  {line.strip()}")
-    out3, _ = run(["headroom", "output-savings"])  # external accelerator binary
-    if "No output-savings data yet" in out3:
-        log("  📊 Output savings: no data yet (seed with `headroom learn`)")
-    else:
-        log(f"  📊 Output savings: {out3[:80]}")
     # Savings ledger
-    ledger = os.path.join(HOME, "projetos", "ai", "simplicio-loop",
-                          ".simplicio", "ledger", "savings-events.jsonl")
-    if os.path.isfile(ledger):
-        total = sum(1 for _ in open(ledger))
+    ledger = REPO_ROOT / ".simplicio" / "ledger" / "savings-events.jsonl"
+    if ledger.is_file():
+        total = sum(1 for _ in ledger.open(errors="replace"))
         log(f"  💰 Savings ledger: {total} events")
-    log(f"  🪵 Logs: {LOGS}/simplicio-proxy.log")
-    return 0 if "RUNNING" in out2 else 1
+    log(f"  🪵 Logs: {LOGS}/proxy.log")
+    return 0 if running else 1
 
 
 def start():
-    log("Starting Simplicio compression proxy on port 8787...")
-    log("  Use: headroom proxy --port 8787")  # external accelerator binary
-    log(f"  Then: launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/{PROXY_SERVICE}.plist")
+    log(f"Starting Simplicio compression proxy on port {PROXY_PORT}...")
+    log(f"  Use: scripts/simplicio-engine proxy --port {PROXY_PORT}")
+    log(f"  Or as a service: launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/{PROXY_SERVICE}.plist")
     return 0