simplicio-loop 3.16.0__tar.gz → 3.18.1__tar.gz

{simplicio_loop-3.16.0/simplicio_loop.egg-info → simplicio_loop-3.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.16.0
+Version: 3.18.1
 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

{simplicio_loop-3.16.0 → simplicio_loop-3.18.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.16.0"
+version = "3.18.1"
 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"

{simplicio_loop-3.16.0 → simplicio_loop-3.18.1}/simplicio_loop/_bundle/skills/simplicio-review/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: simplicio-review
-description: Deep, adversarial branch review — parallel subagents on separate rubrics (security/correctness AND code-quality), spawned in one message, then deduped into one verdict. Use before merging non-trivial work, when the user says "review this branch/PR hard", "thermo-nuclear review", "is this safe to merge", or when simplicio-tasks needs the MEDIUM+ adversarial verify gate. Scopes strictly to the diff; refutes rather than rubber-stamps.
+description: Deep, adversarial branch review — parallel subagents on separate rubrics (security/correctness, code-quality, and does-it-reproduce), spawned in one message, then deduped into one verdict. Runs for EVERY item, no TRIVIAL/SMALL shortcut — it is 3 of the 6 roles in simplicio-tasks' minimum-agent floor. Use before merging any work, when the user says "review this branch/PR hard", "thermo-nuclear review", "is this safe to merge", or when simplicio-tasks needs the Step 4c adversarial verify gate. Scopes strictly to the diff; refutes rather than rubber-stamps.
 ---
 
 # simplicio-review — thermo-nuclear adversarial review
@@ -15,9 +15,9 @@ security vs code-quality rubrics, dedup-on-synthesis) wired into the simplicio e
 
 ## When to use
 
-- Before merging any MEDIUM/LARGE/CRITICAL item (the Step 4c gate).
+- Before merging ANY item, TRIVIAL through CRITICAL (the Step 4c gate) — `simplicio-tasks`' 6-agent
+  floor (Step 3) has no solo/self-review path left; this fan-out is 3 of those 6 roles, always.
 - "review this branch hard", "thermo-nuclear", "find what's wrong before I merge".
-- NOT for TRIVIAL/SMALL items — those keep a single self-review (don't pay the latency).
 
 ## Step 1 — Gather context ONCE (parent)
 
@@ -36,7 +36,7 @@ unless the change makes them reachable.
 
 ## Step 2 — Fan out parallel reviewers (one message, background)
 
-Spawn 2–3 INDEPENDENT subagents IN A SINGLE MESSAGE (so they run concurrently — wall-clock
+Spawn 3 INDEPENDENT subagents IN A SINGLE MESSAGE (so they run concurrently — wall-clock
 down, no proportional token blow-up). Each gets the SAME context bundle and a DISTINCT rubric:
 
 ### Rubric A — security & correctness
@@ -53,7 +53,7 @@ down, no proportional token blow-up). Each gets the SAME context bundle and a DI
 - Boundary cleanliness: leaky abstractions, duplicated logic that ignores an adjacent module.
 - Naming, dead code, comments that lie, tests that assert nothing.
 
-### Rubric C (LARGE/CRITICAL only) — does-it-reproduce / runtime
+### Rubric C — does-it-reproduce / runtime (always spawned; its evidence requirements below stay scoped to what the diff touches)
 - Actually run the changed path; confirm the AC behavior end-to-end (not just "compiles").
 - **Front-end change → require web evidence.** If the diff touches front-end files
   (`*.tsx/jsx/vue/svelte/css/html`, `components/**`, `pages/**`, `app/**`), REQUIRE a `web_verify`

{simplicio_loop-3.16.0 → simplicio_loop-3.18.1}/simplicio_loop/_bundle/skills/simplicio-tasks/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: simplicio-tasks
-description: Autonomously complete a body of work (tasks, issues, cards, CI failures) on ANY LLM/runtime. Use when the user types /simplicio-tasks or asks to clear/finish/close/implement a queue of work — e.g. "finish all open issues", "close the bugs in milestone X", "implement epic #235", "clear the CI queue", "clean up the Jira board". Runtime-agnostic: discovers work-items from any source, dedups, auto-scales to machine capacity, fast-path for trivial items / heavy-path continuous waves for large queues, then merges and closes with evidence. If a host runtime is present it binds native capabilities to this skill's extension points; otherwise the LLM performs every step directly. For a body of work it runs as a loop (auto-arms, no separate /loop or /simplicio-loop command, re-feeding the goal until the queue is drained and verified, or a cap/budget/STOP fires); a single interactive item takes the fast-path and stops after one pass.
+description: Autonomously complete a body of work (tasks, issues, cards, CI failures) on ANY LLM/runtime. Use when the user types /simplicio-tasks or asks to clear/finish/close/implement a queue of work — e.g. "finish all open issues", "close the bugs in milestone X", "implement epic #235", "clear the CI queue", "clean up the Jira board". Runtime-agnostic: discovers work-items from any source, dedups, auto-scales to machine capacity, a minimum 6-agent floor (plan, implement, 4 parallel reviewers) for every item / a scaled fleet beyond 6 for large queues, then merges and closes with evidence. If a host runtime is present it binds native capabilities to this skill's extension points; otherwise the LLM performs every step directly. For a body of work it runs as a loop (auto-arms, no separate /loop or /simplicio-loop command, re-feeding the goal until the queue is drained and verified, or a cap/budget/STOP fires); a single interactive item still runs the 6-agent floor and stops after one pass.
 ---
 
 # /simplicio-tasks — Universal Looping Orchestrator
@@ -9,7 +9,10 @@ A runtime-agnostic autonomous orchestrator. It works on ANY strong LLM/runtime (
 Copilot, Gemini, Cursor, local models, CI agents) with NO mandatory external dependency. Every
 step is something the LLM can do directly with standard tools (shell, git, gh, file edit, web).
 Where a host runtime exposes a faster native capability, it BINDS to the extension points
-(Step 1b) — near-zero token cost — but the skill never REQUIRES it.
+(Step 1b) — near-zero token cost. The skill itself never requires it (the abstraction works on
+any strong LLM) — but on Claude Code, Codex, Cursor, VS Code, Antigravity, Kiro, OpenCode, and
+Hermes, binding to `simplicio-runtime` (MCP or CLI) IS a project-policy requirement, enforced at
+the host/installer level, not by the skill (see `adapters/MATRIX.md` `FORCED_BIND_RUNTIMES`).
 
 The target is in the skill arguments (e.g. `/simplicio-tasks finish all open issues`). If no
 argument, default to "all open work-items in the default source"; confirm scope in ONE line only
@@ -122,6 +125,11 @@ ABSTRACTION, never a runtime — the INVERTED DEPENDENCY (the skill names no run
 detects the skill). Full table + fallbacks: `references/extension-points.md`. Core rule: any
 DECIDED change goes through `deterministic_edit` — never hand-write or regenerate it with a model.
 
+On the 8 `FORCED_BIND_RUNTIMES` (Claude, Codex, Cursor, VS Code, Antigravity, Kiro, OpenCode,
+Hermes), the LLM fallback for an extension point is allowed only until the native bind is
+verified reachable (`simplicio doctor --json`); a run that starts unbound on one of these hosts
+must report the gap as a blocker, not proceed silently on the fallback indefinitely.
+
 When the run is driven by `simplicio-loop` (Step 0, the armed body-of-work path), two points are bound to REQUIRED
 operators instead of LLM fallbacks: `simplicio-mapper` surveys the repo (`orient`) and
 `simplicio-dev-cli task` applies+verifies each decided change (`execute`/`deterministic_edit`) — the AI
@@ -352,5 +360,6 @@ on the STOP signal, budget exhaustion, or a safety halt. Full ten axes + arming
   and load the compact form thereafter.
 - **Portability:** any strong LLM/runtime runs this end-to-end with standard tools. A host runtime
   that binds the extension points makes steps deterministic + near-zero-token; without it the LLM
-  fallbacks cover 100%. Same skill, any runtime. Runtimes without real multi-agent degrade the
-  heavy-path to internal multi-pass — no swarm, same gates.
+  fallbacks cover 100%. Same skill, any runtime — EXCEPT that on the 8 `FORCED_BIND_RUNTIMES`
+  the native bind is a policy requirement, not a speed-only nicety (see Step 1b). Runtimes
+  without real multi-agent degrade the heavy-path to internal multi-pass — no swarm, same gates.

{simplicio_loop-3.16.0 → simplicio_loop-3.18.1}/simplicio_loop/_bundle/skills/simplicio-tasks/references/orchestration.md

@@ -61,13 +61,33 @@ changes, or refactors inside widely imported modules, tighten the gate to `--fai
 uncovered local dependencies and related tests also block the plan. The point is to know the blast
 radius before editing, not after the regression.
 
-## Step 3 — Route: fast-path vs heavy-path
-- **Fast-path** (queue small AND every item complexity ≤ 3): inline, solo, minimal receipt,
-  single targeted test. No fan-out. Finish → Step 6.
-- **Heavy-path** (large queue OR any medium+ item): fan out. Compute the fleet, keep a CONTINUOUS
-  WORKER POOL fed by a LIVE queue (not frozen waves) — a freed worker pulls the next item, even
-  one that appeared seconds ago. Serialize same-file items (conflict detection). Quarantine items
-  that fail K times to a dead-letter list.
+## Step 3 — Route: minimum fleet vs scaled fleet
+
+**Hard floor: every run keeps ≥6 orchestrated agents in flight — no solo/inline path.** A single
+TRIVIAL item is decomposed by ROLE, not by work-item count, so the floor holds without inventing
+parallel work that doesn't exist:
+
+| # | Role | Cardinality |
+|---|---|---|
+| 1 | Orient + plan (Step 2b) | 1 agent |
+| 2 | Implement (Step 4) | 1 agent (2 on MEDIUM+: a fast-follow pair) |
+| 3 | Review — Rubric A: security & correctness (`simplicio-review`) | 1 agent |
+| 4 | Review — Rubric B: quality & maintainability (`simplicio-review`) | 1 agent |
+| 5 | Review — Rubric C: does-it-reproduce / runtime (`simplicio-review`) | 1 agent |
+| 6 | Independent blast-radius reviewer — re-checks Step 4a' `impact_audit.json` (and `flow_audit.json` when applicable) as a second set of eyes, not the implementer self-grading its own scope claim | 1 agent |
+
+Roles 1–2 are sequential (plan before implementing); roles 3–6 spawn in ONE message so they run
+concurrently — wall-clock down, no proportional token blow-up (`simplicio-review` Step 2 pattern).
+Rubric C's heaviest sub-checks (`web_verify`, `flow_audit`) stay conditional on the diff actually
+touching that surface — the rubric runs always, its expensive evidence requirements stay scoped.
+
+- **Minimum fleet** (queue small AND every item complexity ≤ 3): the 6-role floor above runs on
+  the single item. There is no solo/self-review shortcut left to fall back to — the floor IS the
+  minimum, never undercut it. Finish → Step 6.
+- **Scaled fleet** (large queue OR any medium+ item): fan out beyond 6. Compute the fleet, keep a
+  CONTINUOUS WORKER POOL fed by a LIVE queue (not frozen waves) — a freed worker pulls the next
+  item, even one that appeared seconds ago. Serialize same-file items (conflict detection).
+  Quarantine items that fail K times to a dead-letter list.
 
 **Worker report contract (every worker MUST follow).** A worker result is re-injected into the
 orchestrator context verbatim and costs budget on EVERY delegation. Forbid narration; mandate the
@@ -92,10 +112,12 @@ Step 4 loop). Feed the top corrections into the shared digest so agents pre-empt
 cap_cpu  = max(1, floor((cores - 2) / 2))
 cap_mem  = floor(free_gb / 2)
 cap_disk = (free_disk_gb < 10) ? 0 : (free_disk_gb < 25 ? 1 : 99)
-fleet    = min(cap_cpu, cap_mem, cap_disk, independent_items, 16)   # hard cap 16/wave
+fleet    = max(6, min(cap_cpu, cap_mem, cap_disk, independent_items, 16))   # 6-agent floor, 16/wave cap
 waves    = ceil(queue_size / fleet)
 ```
-If resources unknown or disk < 10 GB → fast-path/solo only.
+If resources unknown or disk < 10 GB, the 6-role floor still runs — switch isolation to
+`isolation=shared` (one checkout, sequential commits on overlapping files) instead of
+worktree-per-item, so the floor is met without the disk cost of 6 separate worktrees.
 
 **Worktree-per-item isolation (DEFAULT) + a cost opt-out.** Each item gets its OWN
 `git worktree add` checkout by default, so parallel workers never touch the same tree and there is
@@ -133,10 +155,13 @@ conflict-serialization for newly-arrived same-file items.
 ## Step 3c — Speed model (velocity without sacrificing quality)
 1. Pipeline, not barrier (item A merges while B builds). 2. Shared compile cache (e.g. `sccache`).
 3. Verify once: each agent runs a scoped incremental check; the full suite runs EXACTLY ONCE on
-the merged result. 4. Front-load shared context (orient once, share the digest). 5. Tier
-verification: TRIVIAL/SMALL skip adversarial review; only MEDIUM+ pay it. 6. Pre-warm the build on
-clean main. 7. Time-box + quarantine stuck agents. 8. Prefetch re-discovery during the prior
-wave's review. Speed comes from removing redundant work, not skipping gates.
+the merged result. 4. Front-load shared context (orient once, share the digest). 5. Tier scope,
+not tier skip: the Step 3 6-role review fan-out (roles 3-6) runs on EVERY item regardless of
+tier — only Rubric C's heaviest sub-checks (web/flow evidence) stay scoped to MEDIUM+ or
+surface-touching diffs; a TRIVIAL item still gets the full review, just lighter individual
+checks within it. 6. Pre-warm the build on clean main. 7. Time-box + quarantine stuck agents.
+8. Prefetch re-discovery during the prior wave's review. Speed comes from removing redundant
+work, not skipping gates.
 
 ## Step 3d — Model routing (spend reasoning only where it pays)
 - **L0** Deterministic, ZERO LLM tokens: decided edits via `deterministic_edit`, repo view via

{simplicio_loop-3.16.0 → simplicio_loop-3.18.1}/simplicio_loop/_bundle/skills/simplicio-tasks/references/quality-safety-delivery.md

@@ -108,12 +108,14 @@ python3 scripts/flow_audit.py audit <root> --fail-on medium
 The final evidence must include either `.orchestrator/flow-audit.json` or the human summary. A green
 unit test is not enough when the flow graph still has an unclassified loose end.
 
-### 4c — Adversarial verify for MEDIUM+ items (multi-vote)
-Spawn 2–3 INDEPENDENT verifiers, each prompted to REFUTE the implementation AND check each AC.
-Majority-refute → back to fix. TRIVIAL/SMALL keep single self-review. When `simplicio-review` is
-loaded, delegate this gate to it (parallel rubrics → deduped verdict). Each verifier gets the full
-body + ACs, the diff, the run evidence; task: "Find any AC NOT met, any fake/placeholder return.
-Refute or confirm with specific `file:line`."
+### 4c — Adversarial verify for EVERY item (multi-vote, no tier shortcut)
+Spawn 3 INDEPENDENT verifiers — Rubrics A/B/C of the Step 3 6-role floor — each prompted to REFUTE
+the implementation AND check each AC. Majority-refute → back to fix. There is no TRIVIAL/SMALL
+single-self-review shortcut left: the 6-agent floor applies to every item, so this fan-out is
+already paid for by the floor, not an extra cost layered on top of a cheaper default. When
+`simplicio-review` is loaded, delegate this gate to it (parallel rubrics → deduped verdict). Each
+verifier gets the full body + ACs, the diff, the run evidence; task: "Find any AC NOT met, any
+fake/placeholder return. Refute or confirm with specific `file:line`."
 
 ## Step 5 — Safety gates (NON-NEGOTIABLE)
 Before any commit/push: secret-scan the diff (block on hit). Before any IRREVERSIBLE op

{simplicio_loop-3.16.0 → simplicio_loop-3.18.1/simplicio_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.16.0
+Version: 3.18.1
 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