simplicio-loop 1.0.2__py3-none-any.whl

simplicio_loop/_bundle/skills/simplicio-tasks/references/standing-loop-247.md

@@ -0,0 +1,117 @@
+# 24/7 standing loop + arming the watcher (Step 7 full detail)
+
+To run unattended for 24h and cover the WHOLE work universe, the skill becomes a durable,
+self-governing, self-healing loop. When `simplicio-loop` is loaded, it provides the drive
+(evidence-gated completion-promise + cap); this is the orchestrator-side policy. Ten axes:
+
+### 1. Durable driver
+A durable scheduler (host-native cron if bound, else OS cron / scheduled task) that survives
+reboot/closed session — NOT a session-bound loop. Each ~2-min tick: load state → poll all sources
+→ dispatch within capacity → persist state → sleep. If the loop dies, the scheduler restarts it
+and it resumes from the journal.
+
+### 2. Total coverage matrix ("exactly everything")
+Every SOURCE × every WORK-TYPE, drained each tick:
+
+| Sources | Work-types |
+|---|---|
+| GitHub issues/PRs/CI, Jira, Asana, ClickUp, Trello, Azure DevOps, local, delegations | new feature/bug, CI failure, PR review comment / requested change, PR behind main, security advisory (Dependabot/CVE), flaky test, stale PR, confirmed TODO/FIXME, failed scheduled job |
+
+"Done forever" never happens — idle cheaply when drained, wake on anything. Forward path
+(Steps 2–6) and feedback path (Step 6b) both run every tick.
+
+### 3. Durable state (idempotent, resumable)
+Persist on disk (journal, JSONL/SQLite): `seen` set, idempotency keys, in-flight claims,
+dead-letter quarantine, `dry` counter, lessons. Each tick, reconcile state with reality (which PRs
+merged, which items closed) before acting.
+
+### 4. Cost & resource governance
+- **HARD $ kill-switch**: stop all spend when the daily budget is exceeded; resume next window.
+  Unattended runs MUST have a ceiling.
+- Shared token/quota bucket across agents (no 429 storms); re-probe provider quota each tick.
+- Re-probe CPU/RAM/disk/load each tick → degrade tiers as resources tighten.
+- Disk hygiene: prune old worktrees, rotate logs, GC build artifacts + old receipts. Time-box
+  every item and every tick.
+
+**Kill-switch — concrete.** `.orchestrator/loop-budget.json`:
+```json
+{ "daily_usd_ceiling": 0, "per_run_token_ceiling": 0,
+  "spent_usd_today": 0, "reset_at": "ISO-8601", "state": "running|halted" }
+```
+Every tick + before every dispatch: read it; compute real spend via `savings_ledger` (or
+estimate). `spent >= ceiling` (ceiling > 0) → `state=halted`, stop dispatch, alert, idle until
+`reset_at`. `ceiling = 0` = UNSET → the loop refuses to run unattended (fail-safe). On `reset_at`,
+zero spend, resume.
+
+### 5. Unattended safety (no human at the keyboard)
+- Irreversible ops queue to an async approval channel and BLOCK. Never auto-proceed.
+- **Headless rule:** if NO approver is reachable, REMOVE the destructive capability (do the safe
+  part, defer the rest) — do not execute unsupervised.
+- Secret-scan every push. Aggregate blast-radius cap per item AND per day. Injection hardening on
+  all item/PR/comment content.
+
+### 6. Self-healing + intelligent retry by failure class
+| Failure class | Detection | Retry strategy |
+|---|---|---|
+| Compile error | build/typecheck emits `^error` | Fix via `diagnostics` → retry (max 3×) |
+| Test failure | runner exit ≠ 0 | Parse failing test + assertion → targeted fix → retry (max 3×) |
+| Merge conflict | `git merge/rebase` exit ≠ 0 | Conflict retry protocol (Step 6b) → retry (max 3×) |
+| Static-analysis blocker | new clippy/Sonar blocker | Fix the finding → re-run → retry (max 2×) |
+| Timeout / infra | no output > wall-clock | Kill → re-queue → backoff 2× (max 2×) |
+| Missing dependency | undefined symbol from unmerged dep | Suspend until the dependency issue closes |
+| Security gate | secret in diff | Remove → rotate if live → retry once; second hit → dead-letter + alert |
+
+Circuit breakers: open after N same-class failures on the same item → dead-letter with full log.
+Watchdog: no progress across ALL items in M ticks → alert + reduce WIP cap. Dead-letter items
+surfaced in the evidence package + next-run intake summary.
+
+### 7. Prioritization & WIP
+Portfolio order: security/prod-broken → blockers → CI failures → high-impact/low-effort →
+deadlines → bugs → features → docs. Enforce a WIP cap and backpressure.
+
+### 8. Observability
+Structured event stream (JSONL: claimed/planned/edited/gate_passed/failed/merged/blocked) +
+provenance chain. A live status surface (host-provided if bound). Periodic digest: items closed,
+blocked, $ spent, queue depth.
+
+**Periodic savings audit (deterministic, zero new model calls).** On a slow cadence, scan the
+run's OWN command log for commands that MATCH the output-reduction catalog but ran RAW. Split
+compound commands the same way the live gate does, sum estimated leaked tokens per the catalog's
+expected-%, emit: adoption rate, top offending patterns, total tokens leaked. Reuse the exact same
+catalog the live gate uses so the audit never drifts.
+
+**Snapshot-based measurement (generate once, score offline).** Split any savings/quality
+measurement into an EXPENSIVE generator (runs the model once, snapshots raw outputs + metadata to
+a committed file) and a CHEAP offline scorer (recomputes from the snapshot with a FIXED tokenizer,
+NO model call). Regenerate only when the skill/prompt set materially changes. Prefer per-item
+MEDIAN, include min–max + stdev, disclose limits. Published metrics live between begin/end markers,
+mechanically rewritten from committed evidence — never hand-typed.
+
+### 9. Self-improvement
+After each item, record the trajectory + learn from the run (delegate to `simplicio-learn`); reuse
+prior solved patterns (precedents) so they're applied, not regenerated. Run the Step 6 self-audit
+per item. Daily meta-review: scan escapes/blocks → propose protocol tweaks, back-tested before adoption.
+
+### 10. Coordination & clean stop
+Multiple loop instances: atomic claims (tuple-space/labels/lockfile) + lease/heartbeat/TTL so a
+dead worker's items are reclaimed, never stolen while live. A single `STOP` signal (flag file
+`.orchestrator/STOP` or channel command) halts cleanly between ticks. Daily budget resets on schedule.
+
+**Exit condition: none by design** — idle when drained, wake on any new item/comment/check. Only
+STOPS on the explicit stop signal, budget exhaustion, or a safety halt.
+
+## Arming the watcher (idle, between runs)
+Cadence configurable (default ~2 min). The user chooses always-on vs session-only via the
+kill-switch ceiling (`ceiling > 0` arms the 24/7 watcher, `ceiling = 0` runs once and stops).
+
+Mechanisms (prefer the most durable):
+- **Host-native durable scheduler** (if bound): a 2-minute tick that discovers + dispatches.
+- **OS cron / scheduled task**: `*/2 * * * *` re-invoking this skill — survives reboots.
+- **Session loop** (least durable): `/loop 2m /simplicio-tasks <goal>` — alive while the session is.
+- **simplicio-loop** (if loaded): binds re-feed/iteration to a real stop-hook with an
+  evidence-gated completion-promise — exits only when `<promise>` is genuinely true AND backed by a
+  passing gate. Wires the watcher into the hard rule: never close work without a merged PR or
+  concrete evidence.
+
+MANDATORY before arming 24/7: a cost ceiling configured; persistent source auth; the irreversible-op
+human gate ON; the secret-scan gate blocking any commit with a secret.

simplicio_loop/_bundle/skills/simplicio-tasks/references/token-economy.md

@@ -0,0 +1,175 @@
+# Token-economy routing gate (full detail)
+
+The condensed rule lives in SKILL.md Step 1c; this is the full mechanism. When `simplicio-orient`
+is loaded, delegate to it — it IS this gate as a standalone skill. The cheapest token is the one
+not spent: deterministic first, terminal for facts, model only where it pays.
+
+## THINK vs NO-THINK
+- NO-THINK (fast, prefer `deterministic_edit`/`orient`/`recall`): template/cache hit, known
+  scaffold, single mechanical op, exact regex/AST match, a deterministic plan exists, or the
+  answer is known from recall.
+- THINK (planner/reviewer, record evidence): template miss, ambiguous task, multi-step plan, new
+  domain, error/conflict/retry, architecture decision, output touches multiple files, security/
+  release risk.
+
+## INTERNET — default OFF
+- OFF when: the task is about local code; repo/vendor/lockfile already has the API/docs; it is a
+  test/docs/refactor change.
+- ON only when: current external docs are required, a CVE/recent package version matters, an
+  API/SDK error is undocumented locally, or the source demands current information.
+
+## EXECUTE via terminal — NEVER simulate
+Every git, cargo, gh, az, or shell command MUST run via a real terminal call. Never reason about
+what a command "would return". Priority: (1) host native `shell_exec` if bound; (2) shell tool
+with output clamping; (3) NEVER LLM-simulated output.
+
+## Auto-clarity (safety overrides brevity)
+Compression YIELDS to the safety gate. When a command/message is security-sensitive, irreversible
+(force-push, history rewrite, prod deploy, data/schema delete, mass-file delete), or
+order-dependent, FORCE full-clarity verbose output for that segment — the complete warning, the
+exact command quoted verbatim, steps in explicit order — then resume terse. Brevity is never
+applied to a confirmation a human must act on.
+
+## Output-reduction catalog (drives clamp routing)
+Consult BEFORE running. Each row `{pattern, recipe, exp-savings, SKIP-if}`. SKIP-if fires on
+structured output (`--json`/`--jq`) or a write/confirm op. Clamp highest-savings first; NEVER
+clamp a SKIP-if row; report the catalog's expected-% in the savings receipt.
+
+| command pattern | reduce recipe | exp. savings | skip-if |
+|---|---|---|---|
+| test/spec runner | success-collapse to `pass: N`; on fail keep ≤20 error lines | ~90% | piped to structured consumer |
+| type/compile check | error lines only; clean→`ok` | ~80% | — |
+| diff / show | stat + hunks only, drop context | ~80% | piped to structured consumer |
+| lint | findings only; clean→`ok` | ~80% | — |
+| add / commit / push | collapse to `ok <branch/sha>` | ~59% | — |
+| PR / list view | counts + titles only | ~87% | `--json`/`--jq` present |
+| package / image inventory | keep ≤50 rows | ~50% | — |
+| format / passthrough | run raw | 0% | always |
+
+Content-type routing (headroom taxonomy): route by detected type — JSON → keep
+errors/anomalies/boundaries; code → keep signatures, collapse bodies; logs → keep failures, drop
+passing noise; diff → stat+hunks. Same intent as the rows above, articulated by content type.
+
+## Signal-tiered caps (one shared set)
+`CAP_ERRORS=20`, `CAP_WARNINGS=10`, `CAP_LIST=20`, `CAP_INVENTORY=50`. Always keep ERROR lines
+over surrounding context. A lowered cap is underflow-safe: falls back to the full cap rather than
+emptying a non-empty result. Never flat "head N + tail N" (over-cuts errors).
+
+## Two clamp primitives (both `unless errors present`)
+- Success-collapse: exit 0 + clean pattern + no error/warning → one-line verdict.
+- Dedup-with-counts: collapse runs of identical lines to `line xN`.
+If ANY error/warning line exists, fall back to signal-tiered caps — a collapse can NEVER hide a failure.
+
+## tee cache + CCR reversible retrieve (failure escape hatch)
+On any NON-ZERO exit, or when a cap clips a FAILING command, write full output to
+`.orchestrator/tee/<ts>_<cmd-slug>.log` and surface only the path + kept error lines. The agent
+re-reads it lazily only if needed — recovering full context WITHOUT re-running (which re-burns
+tokens and may be non-deterministic). Config `.orchestrator/orient.toml` → `tee.mode =
+failures|always|never` (default `failures`).
+
+**CCR (compress-cache-retrieve), folded from headroom:** make the clamp REVERSIBLE, not lossy.
+Every clamped blob gets a stable handle = the tee path. Surface a retrieve convention so a worker
+pulls the original on demand instead of re-running:
+```
+retrieve <tee-path> [--lines a-b] [--grep PATTERN]
+```
+This turns "lossy by policy" into "reversible decision point": clamp to a signature/summary
+in-context, keep the full original on disk keyed by handle, fetch by handle only when the kept
+lines aren't enough. Removes the main risk of aggressive clamping (losing the one line that
+mattered) at zero up-front token cost.
+
+## Compound-command clamping (pipe/redirect-safe)
+Understand `&& || ; |`: (1) split respecting quotes/escapes, clamp each segment; (2) for `|`,
+clamp ONLY the left producer, leave the pipe TARGET raw; (3) never clamp a `find`/glob producer
+feeding a pipe; (4) strip trailing redirects (`2>&1`,`>/dev/null`), clamp inner, re-append;
+(5) unsplittable (`$(...)`, backticks, heredoc, file-target redirect) → run RAW with a tail clamp.
+
+## Density tiers by consumer
+MACHINE tier (terse, fixed-schema — the worker report contract) for worker→orchestrator reports
+and internal digests; HUMAN tier (readable prose) for PR bodies, status comments, confirmations.
+Skip a compression pass on already-dense content (code, config, lockfiles).
+
+## Fail-open
+Every reduction step is additive and removable. On ANY error/missing dep/unparseable payload/
+unknown command, run the original command unchanged and propagate its REAL exit status. A bad
+profile degrades to "slightly more tokens", never "task dead".
+
+A raw `cargo check` costs ~2000 tokens to read; catalog-clamped
+(`--message-format json | grep '"level":"error"'`) costs ~80.
+
+## Terminal substitution table — use the terminal, NOT the LLM
+Detect platform once: `python3 -c "import platform; print(platform.system())"` →
+`Windows | Darwin | Linux`. Prefer cross-platform (`git`,`gh`,`rg`,`python3`,`cargo`) first.
+
+### filesystem / system facts
+| need | cross-platform | Windows | Linux/macOS |
+|---|---|---|---|
+| File exists? | `python3 -c "import os,sys;sys.exit(0 if os.path.exists('<p>') else 1)"` | `Test-Path <p>` | `test -f <p>` |
+| Find in code | `rg "<pat>" --json` | same | same |
+| Count matches | `rg -c "<pat>" <file>` | same | same |
+| Grep + context | `rg -C 3 "<p>" <file>` | same | same |
+| CPU cores | `python3 -c "import os;print(os.cpu_count())"` | `$env:NUMBER_OF_PROCESSORS` | `nproc` |
+| Free disk GB | `python3 -c "import shutil;print(shutil.disk_usage('.').free//1024**3)"` | same | `df -BG .` |
+| Free RAM MB | `python3 -c "import psutil;print(psutil.virtual_memory().available//1024**2)"` | `(Get-CimInstance Win32_OS).FreePhysicalMemory` | `free -m` |
+| Today UTC | `python3 -c "from datetime import*;print(datetime.now(timezone.utc).date())"` | same | `date -u +%F` |
+| Sort+dedup | `python3 -c "import sys;print('\n'.join(sorted(set(sys.stdin.read().split()))))"` | same | `sort -u` |
+| Port listening? | `python3 -c "import socket;s=socket.socket();print(s.connect_ex(('127.0.0.1',<port>))==0)"` | `netstat -an \| findstr :<port>` | `ss -tlnp \| grep :<port>` |
+
+### git (highest-value — answer from git, not from reasoning)
+| intent | command (cross-platform) |
+|---|---|
+| Current branch | `git rev-parse --abbrev-ref HEAD` |
+| Ahead of main? | `git rev-list --count main..HEAD` |
+| Files changed in branch | `git diff --name-only main...HEAD` |
+| Commits since base | `git log <BASE>..HEAD --oneline` |
+| Last commit SHA | `git rev-parse HEAD` |
+| Branch exists remotely? | `git ls-remote --heads origin <b>` |
+| Show file at commit | `git show <commit>:<path>` |
+| Blame line N | `git blame -L <N>,<N> <file> --porcelain` |
+| Sync branch | `git fetch origin <b> && git checkout <b> && git pull --ff-only` |
+| Isolated checkout | `git worktree add --detach <dir> <sha>` |
+
+### gh (GitHub — all 5 scanned repos use this, not Azure DevOps)
+| intent | command |
+|---|---|
+| Issue state | `gh issue view N --json state --jq ".state"` |
+| Count open issues | `gh issue list --state open --json number --jq "length"` |
+| List ready items (metadata) | `gh issue list --state open --json number,title,labels` |
+| PR for branch | `gh pr list --head <b> --json number --jq ".[0].number"` |
+| PR checks | `gh pr checks <n>` |
+| PR diff | `gh pr diff <n>` |
+| Comment / close | `gh issue comment N --body "…"` · `gh issue close N` |
+| Workflow dispatch | `gh api repos/{owner}/{repo}/dispatches -f event_type=X` |
+
+### node (vscode, openclaw, claude-code) / python (hermes) / rust (codex)
+| intent | command |
+|---|---|
+| Deterministic install | `npm ci` · `pnpm install --frozen-lockfile` · `uv sync --locked` |
+| Build | `npm run build` · `cargo build -p <crate>` |
+| Test (clamp: failures-only) | `npm test` · `pytest -q` · `cargo test` |
+| Lint (clamp: findings-only) | `eslint .` · `ruff check --fix` · `cargo clippy --all-targets` |
+| Typecheck | `tsc --noEmit` · `mypy` |
+| Dep inventory | `cargo metadata --no-deps --format-version 1` · `npm ls --depth=0` |
+
+### docker / azure
+| intent | command |
+|---|---|
+| Build / run | `docker build -t <img> .` · `docker run -d --name <c> <img>` |
+| Exec / cleanup | `docker exec <c> sh -c "<cmd>"` · `docker rm -f <c>` |
+| Compose | `docker compose -f <f> up -d` / `down` |
+| Azure login / acct | `az login` · `az account show -o json` |
+| Azure DevOps boards (if used) | `az boards work-item show --id N` · `az boards query --wiql "…"` · `az repos pr list` · `az pipelines runs list` |
+
+> NOTE: the 5 scanned local repos (hermes-agent, openclaw, vscode, codex, claude-code) use
+> **GitHub (`gh`) + GitHub Actions exclusively** — no Azure DevOps. The `az`/`az boards` rows are
+> provided for repos that DO use Azure DevOps; bind them as a `source_adapter` only when detected.
+
+**Rule:** if the answer is a fact about the filesystem, git, processes, or system resources — the
+terminal knows it exactly; the LLM approximates it expensively. Always pick the terminal.
+
+## TOOLS / SKILLS — minimum necessary
+- NO-TOOLS when the answer is derivable from context or the tool only confirms something
+  irrelevant. A tool call must change a decision, an implementation, or evidence.
+- NO-SKILLS by default. Rank/recall first; lazy-load only a genuinely relevant skill.
+
+Record the chosen modes per sub-task in the receipt (one line).

simplicio_loop/_bundle/skills/simplicio-tasks/references/web-evidence.md

@@ -0,0 +1,93 @@
+# Web evidence — `web_verify` via Playwright (front-end proof)
+
+Concrete implementation of the `web_verify` extension point: drive a real browser to PROVE a
+front-end change works, and capture a **screenshot + trace** as evidence. The north star from
+Step 4b ("works, not just compiles") applied to UI: a front-end change that was never rendered is
+PARTIAL, not done.
+
+Credit: Microsoft Playwright (`playwright`, `playwright-mcp`, `playwright-python`). The agent-facing
+path is **playwright-mcp** (structured accessibility snapshots, not pixels).
+
+## When it fires (cheap gate — terminal, not LLM)
+Run the front-end detector via the terminal:
+```
+git diff --name-only <base>...HEAD | rg -i "\.(tsx|jsx|vue|svelte|css|scss|html)$|^(components|pages|app|public|src/ui)/"
+```
+No front-end files changed → SKIP the whole gate. Front-end files changed → run `web_verify` as a
+conditional sub-gate of `validate`/`smoke`.
+
+## How to drive the browser
+**Preferred — playwright-mcp** (the worker has the MCP server registered):
+```json
+{ "mcpServers": { "playwright": { "command": "npx",
+  "args": ["@playwright/mcp@latest", "--headless", "--output-dir", ".orchestrator/tee/web", "--save-trace"] } } }
+```
+Per acceptance check: `browser_navigate(url)` → act (`browser_click` / `browser_fill_form` /
+`browser_type`) → `browser_snapshot` (assert text present — compact a11y tree, no vision needed) →
+`browser_take_screenshot({filename:"<issue>-<step>.png", fullPage:true})` →
+`browser_console_messages` + `browser_network_requests` for an error scan. Trace auto-written by
+`--save-trace`.
+
+**Fallback A — `npx playwright` (no MCP):**
+```bash
+npx playwright install --with-deps chromium
+PWTEST_OUTPUT_DIR=.orchestrator/tee/web npx playwright test --trace on --output .orchestrator/tee/web
+```
+
+**Fallback B — playwright-python / pytest (Python repos, e.g. hermes-agent):**
+```bash
+pip install playwright pytest-playwright && playwright install chromium
+pytest --tracing retain-on-failure --output .orchestrator/tee/web
+```
+or programmatic: `context.tracing.start(screenshots=True, snapshots=True)` … `page.screenshot(
+path=".orchestrator/tee/web/shot.png")` … `context.tracing.stop(path=".orchestrator/tee/web/trace.zip")`.
+
+## Capture into the evidence ledger
+All artifacts write to `.orchestrator/tee/web/` (screenshots `*.png`, `trace.zip`, optional
+`console.log`/`network.json`). Append a ledger row recording **paths + a one-line verdict**:
+```
+web_verify: PASS — /login renders, 0 console errors; shot=.orchestrator/tee/web/login.png trace=…/trace.zip
+```
+The ledger stores the path, never the bytes.
+
+## Attach to the PR (link, don't paste)
+```bash
+# CI: prefer actions/upload-artifact; locally a release/gist works
+gh release upload "evidence-<pr>" .orchestrator/tee/web/login.png .orchestrator/tee/web/trace.zip
+gh pr comment <pr> --body "web_verify ✅  screenshot: <url>  trace: <url> (open in trace.playwright.dev)"
+```
+
+## Token economy (critical)
+- NEVER paste DOM, screenshot bytes, or full page HTML into context. Evidence = **file path/URL +
+  boolean verdict**.
+- Prefer `browser_snapshot` (compact a11y text) over vision to assert state; the screenshot is for
+  the human reviewer, not the model.
+- Clamp `browser_console_messages` / `browser_network_requests` through the orient catalog (tee to
+  file; feed back only count + first N error lines — same rtk-style clamp as build/test output).
+- Run `--headless --isolated`, one browser context per check.
+
+## Enforcement (simplicio-review rubric line)
+At MEDIUM+, `simplicio-review` adds: "if the diff is front-end, REQUIRE a `web_verify` ledger entry
+with screenshot+trace paths and 0 console errors, else FAIL." `web_verify` is the producer;
+`simplicio-review` is the enforcer; `pr`/`evidence` attaches.
+
+## Runnable worker (`scripts/web_verify.py`)
+The prose above is the contract; `scripts/web_verify.py` is the runnable form. Two backends via
+`--runner`: `npx` (default, Fallback A) and `pytest` (Fallback B, playwright-python);
+playwright-mcp stays the richer path when a worker has the MCP server:
+```bash
+python3 scripts/web_verify.py detect --base origin/main [--exit-code]   # cheap FE-diff gate
+python3 scripts/web_verify.py run    --url URL --expect "Sign in" --issue 10 [--runner npx|pytest] [--upload --pr N]
+python3 scripts/web_verify.py verify --url URL --expect TEXT --base origin/main --issue 10
+```
+`verify` = detect + (run only if the diff is front-end, else a SKIP ledger note). It writes the
+screenshot, trace, and console scan under `.orchestrator/tee/web/`, appends the ledger row, and
+prints the MACHINE-tier verdict (`done|fail|skip|blocked`); a missing toolchain yields BLOCKED,
+never a fake pass. **CI artifact upload:** `.github/workflows/web-verify.yml` runs the worker on
+front-end PRs and uploads `.orchestrator/tee/web` via `actions/upload-artifact@v4`; locally pass
+`--upload --pr <N>` to `gh release upload` the artifacts and `gh pr comment` the links.
+
+## Scope (v1 — don't over-engineer)
+Build: FE-diff detector · `web_verify` worker (playwright-mcp preferred, npx/pytest fallback) ·
+ledger row schema · the review rubric line. Skip: vision/coordinate caps, video, visual-diff
+baselines, multi-browser matrix. Single headless Chromium + screenshot + trace is sufficient proof.

simplicio_loop/cli.py

@@ -0,0 +1,76 @@
+"""CLI for simplicio-loop: install the bundled skills + hooks into a runtime."""
+from __future__ import annotations
+
+import argparse
+import shutil
+from pathlib import Path
+
+from . import __version__
+
+BUNDLE = Path(__file__).resolve().parent / "_bundle"
+
+
+def _copy_tree(src: Path, dst: Path) -> int:
+    """Copy every file under src into dst, preserving structure. Returns file count."""
+    count = 0
+    for item in src.rglob("*"):
+        if item.is_file():
+            out = dst / item.relative_to(src)
+            out.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(item, out)
+            count += 1
+    return count
+
+
+def install(target: Path, globally: bool) -> int:
+    base = (Path.home() / ".claude") if globally else (target / ".claude")
+    skills_dst = base / "skills"
+    hooks_dst = (base / "hooks") if globally else (target / "hooks")
+
+    if not (BUNDLE / "skills").is_dir():
+        print("error: bundled skills not found in the installed package.", flush=True)
+        return 1
+
+    n_skills = _copy_tree(BUNDLE / "skills", skills_dst)
+    n_hooks = _copy_tree(BUNDLE / "hooks", hooks_dst)
+
+    print(f"simplicio-loop {__version__} installed:")
+    print(f"  skills -> {skills_dst}  ({n_skills} files)")
+    print(f"  hooks  -> {hooks_dst}  ({n_hooks} files)")
+    print("")
+    print("Use it in your agent runtime (Claude Code, Cursor, ...):")
+    print("  /simplicio-tasks finish all the open issues")
+    return 0
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="simplicio-loop",
+        description=(
+            "Install the simplicio-loop super-plugin (6 AI-orchestration skills + "
+            "loop/token-economy hooks) into a runtime's skills location."
+        ),
+    )
+    parser.add_argument(
+        "command", nargs="?", default="install", choices=["install"],
+        help="action to run (default: install)",
+    )
+    parser.add_argument(
+        "--target", default=".",
+        help="project directory to install into (default: current directory)",
+    )
+    parser.add_argument(
+        "--global", dest="globally", action="store_true",
+        help="install into ~/.claude instead of the project",
+    )
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"simplicio-loop {__version__}",
+    )
+    args = parser.parse_args(argv)
+    if args.command == "install":
+        return install(Path(args.target).resolve(), args.globally)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

simplicio_loop-1.0.2.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: simplicio-loop
+Version: 1.0.2
+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
+Project-URL: Homepage, https://github.com/wesleysimplicio/simplicio-loop
+Project-URL: Repository, https://github.com/wesleysimplicio/simplicio-loop
+Project-URL: Issues, https://github.com/wesleysimplicio/simplicio-loop/issues
+Keywords: ai,agent,orchestrator,llm,claude,cursor,automation,ralph-loop,token-economy,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# simplicio-loop
+
+**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**:
+`discover → implement → verify → merge → close → watch 24/7`, behind safety gates and a hard cost
+kill-switch, at up to **96% fewer tokens**. Not a chatbot. A worker.
+
+![simplicio-loop](https://raw.githubusercontent.com/wesleysimplicio/simplicio-loop/main/assets/simplicio-loop-hero.jpg)
+
+## Install
+
+```bash
+pip install simplicio-loop
+```
+
+Then drop the skills + hooks into your project (or globally):
+
+```bash
+simplicio-loop install            # into ./.claude of the current project
+simplicio-loop install --global   # into ~/.claude (all projects)
+```
+
+Now invoke it from your agent runtime (Claude Code, Cursor, Codex, Gemini, …):
+
+```
+/simplicio-tasks finish all the open issues
+```
+
+## What you get — 6 skills
+
+| Skill | What it does |
+|---|---|
+| `simplicio-tasks` | The orchestrator loop: discover → implement → verify → merge → close → watch 24/7. |
+| `simplicio-loop` | Hardened Ralph loop — re-feed the goal until an evidence-gated `<promise>` or a cap. |
+| `simplicio-orient` | Terminal-first token economy — output-reduction catalog, tee-cache, signatures-read. |
+| `simplicio-review` | Adversarial review — parallel subagents on distinct rubrics, deduped into one verdict. |
+| `simplicio-compress` | Output + memory compression, byte-preserving identifiers. |
+| `simplicio-learn` | Retrospective — durable, deduped lessons written back to memory. |
+
+## Highlights
+
+- **11 runtimes, one protocol** — Claude Code, Codex, VS Code/Copilot, Cursor, Antigravity, Kiro,
+  OpenCode, Gemini, Aider, Hermes, OpenClaw.
+- **Evidence-gated completion** — never a false "done"; exits only on a verified `<promise>` or a
+  cap / budget / STOP.
+- **Token economy** — honest "answer concisely" baseline; savings credited only on verified-correct
+  outcomes.
+
+Requires Python 3.8+. The skills, hooks, and installer are pure cross-platform Python.
+
+MIT — part of the [Simplicio](https://github.com/wesleysimplicio) ecosystem.
+Full docs: <https://github.com/wesleysimplicio/simplicio-loop>

simplicio_loop-1.0.2.dist-info/RECORD

@@ -0,0 +1,28 @@
+simplicio_loop/__init__.py,sha256=yIVFFI-jF4Cr7xX4JA-AFm6XGVszfPio8rEs5j5R3OQ,304
+simplicio_loop/cli.py,sha256=xGHOMND_2HlzyXaGCkzZCX4YeZkPOip2U_9jZLFDmKc,2519
+simplicio_loop/_bundle/hooks/hooks.claude.json,sha256=7Kun7MXhAkG2ztnDiDTteo9zBwdmtL0pmYs1pulLCoA,509
+simplicio_loop/_bundle/hooks/hooks.json,sha256=hITifltLMzf1DsfiQLe5lNMRAMNAwBQbtfr8s_3mdiE,285
+simplicio_loop/_bundle/hooks/learn_stop.py,sha256=x9zJiYqaXI1OvwLu8w-orPVID-yivVcE5KMuW-vVpzE,1298
+simplicio_loop/_bundle/hooks/loop_capture.py,sha256=KxAuyy2fKI0r_9ACPZG_k4t-MIfQo5cLoUL7QXm61Qs,2447
+simplicio_loop/_bundle/hooks/loop_stop.py,sha256=_DxtbwHpDsCfEZSAuz50uyQjnXCXCEIAPxX0t5cyw-M,7460
+simplicio_loop/_bundle/hooks/orient_clamp.py,sha256=dN9JV5UJTzTfPhGcNNxLXXOjmkbBFx5vcPqvqrtSH6g,6161
+simplicio_loop/_bundle/hooks/orient_rewrite.py,sha256=ZOt7ajvfhbWsOU5EwCr-UODx8ZGv3eaqZzGo5ALN3fM,3996
+simplicio_loop/_bundle/skills/simplicio-compress/SKILL.md,sha256=mFVasjKa30HSfn8EG-MpfTFN9DHCv8ybfSUTxid2Pgw,4714
+simplicio_loop/_bundle/skills/simplicio-learn/SKILL.md,sha256=FxLjlX13NdkrsXJoy9B5qPeWHmI8jndCd_P2JrY3FvI,4057
+simplicio_loop/_bundle/skills/simplicio-loop/SKILL.md,sha256=cT88aCeHLGlXjTd_pCkb2VqXTM5ruk1bkLr3nwpIBvo,6322
+simplicio_loop/_bundle/skills/simplicio-orient/SKILL.md,sha256=Me4r3Mh9TrRQpj_tBDcjX4OkOWEi35CMcKGu_0JaAFs,10835
+simplicio_loop/_bundle/skills/simplicio-review/SKILL.md,sha256=XJ7l4Hz82xKTIutKynrjqv3M7h7OlQxLQZDoe6ejBR0,5218
+simplicio_loop/_bundle/skills/simplicio-tasks/SKILL.md,sha256=CMeagEawcYf_nRmSH2UEM2Du1pLn__PrnRkJ9dNs9ec,15853
+simplicio_loop/_bundle/skills/simplicio-tasks/references/azure-devops-adapter.md,sha256=d5Xaa_jZyU-XUl5fLVo_uCRmsrtm4ZJhtGhO1ynPBgc,4347
+simplicio_loop/_bundle/skills/simplicio-tasks/references/extension-points.md,sha256=CatX67AbeGdgj7ipdJLT8MhKZ0e4St6VE4V9NjBWrMU,7443
+simplicio_loop/_bundle/skills/simplicio-tasks/references/orchestration.md,sha256=TIIPW1GUopHainPax1oPDNGR0Rr5Z4W5nj9zlk4c77s,8516
+simplicio_loop/_bundle/skills/simplicio-tasks/references/quality-safety-delivery.md,sha256=ybOSwMYRH5W-XJHsSHPTZJ28hWScar19K8khLydRK_k,8094
+simplicio_loop/_bundle/skills/simplicio-tasks/references/standing-loop-247.md,sha256=cpTpY-lR1SCBN3jRHIK_imk5hi2MyClA7qXuJVPqUtg,7448
+simplicio_loop/_bundle/skills/simplicio-tasks/references/token-economy.md,sha256=1F9y7uyXJtxEMuse58EM7hQm75nXqXkXpjSCVPwD0u4,10799
+simplicio_loop/_bundle/skills/simplicio-tasks/references/web-evidence.md,sha256=EaOUfu1LM53gBSWaxIrxMoLMl1vbw4c3_3xN021G5vw,5403
+simplicio_loop-1.0.2.dist-info/licenses/LICENSE,sha256=M9nybyYRmZgzRcII42mrIiSDj8Ay0E6XV1xGAsT7J7M,1073
+simplicio_loop-1.0.2.dist-info/METADATA,sha256=ptPMglTiibOPmx83v2B8pNqodkT8izxSczxYeODE6DI,3359
+simplicio_loop-1.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simplicio_loop-1.0.2.dist-info/entry_points.txt,sha256=ZfdATdazngE4o68qwDHv0t4WAWiAYdQAjVizMTxEK6c,59
+simplicio_loop-1.0.2.dist-info/top_level.txt,sha256=VNjXUAbkTKMspHVv_w5B4JDsu43U_Rw1kH8iJLZHqA0,15
+simplicio_loop-1.0.2.dist-info/RECORD,,

simplicio_loop-1.0.2.dist-info/WHEEL

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

simplicio_loop-1.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simplicio-loop = simplicio_loop.cli:main

simplicio_loop-1.0.2.dist-info/licenses/LICENSE

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

simplicio_loop-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+simplicio_loop