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

{simplicio_loop-3.15.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.15.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.15.0 → simplicio_loop-3.18.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.15.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.15.0 → simplicio_loop-3.18.1}/simplicio_loop/_bundle/hooks/loop_stop.py

@@ -11,17 +11,26 @@ hook must never trap the agent in an endless loop. The real guards are the
 
 State (single source of truth): .orchestrator/loop/scratchpad.md  (+ sibling `done` flag)
 Reads stdin JSON from the host (Claude: {transcript_path,...}; Cursor: {text,...}).
+
+Cross-agent handoff: an INCOMPLETE stop (budget halted, iteration cap, manual STOP
+signal) writes `.orchestrator/loop/HANDOFF.md` before clearing the scratchpad, so a
+different agent/runtime picking up this repo cold — because the first one ran out of
+budget — can resume without re-deriving the goal, the verified acceptance criteria, or
+the dead-end attempts. A successful (promise-fulfilled) stop needs no handoff.
 """
 import json
 import os
 import re
 import sys
+import time
 
 LOOP_DIR = os.path.join(".orchestrator", "loop")
 SCRATCHPAD = os.path.join(LOOP_DIR, "scratchpad.md")
 DONE_FLAG = os.path.join(LOOP_DIR, "done")
 LAST_RESP = os.path.join(LOOP_DIR, "last_response.txt")
 ANCHOR = os.path.join(LOOP_DIR, "anchor.json")
+JOURNAL = os.path.join(LOOP_DIR, "journal.jsonl")
+HANDOFF = os.path.join(LOOP_DIR, "HANDOFF.md")
 STOP_SIGNAL = os.path.join(".orchestrator", "STOP")
 BUDGET = os.path.join(".orchestrator", "loop-budget.json")
 GATE_LOCK = os.path.join(LOOP_DIR, "gate.lock")
@@ -122,31 +131,118 @@ def gate_running():
     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 read_anchor():
+    """Return the parsed task anchor dict, or None if absent/corrupt. Fail-open."""
+    try:
+        with open(ANCHOR, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
 def anchor_pending():
     """Return the unverified acceptance-criteria ids from the task anchor, or [].
 
     The mechanical anti-drift gate: a `<promise>` must not end the loop while the frozen task anchor
-    still has criteria that are not `done`. Read the anchor JSON DIRECTLY (no dependency on
-    `scripts/task_anchor.py`, which the lean marketplace plugin does not ship — the hook must stay
-    self-contained). FAIL-OPEN: a missing / unreadable / empty anchor, or one with no criteria,
-    returns [] so the gate never blocks — a buggy anchor must never trap the loop, and the rejection
-    it does cause is still bounded by `max_iterations` + the budget. Only a cleanly-parsed anchor
-    with ≥1 criterion that is not `done` reports pending.
+    still has criteria that are not `done`. FAIL-OPEN: a missing / unreadable / empty anchor, or one
+    with no criteria, returns [] so the gate never blocks — a buggy anchor must never trap the loop.
     """
+    data = read_anchor()
+    if not data:
+        return []
+    crit = data.get("criteria") or []
+    return [c.get("id") for c in crit
+            if isinstance(c, dict) and c.get("status") != "done"]
+
+
+def tail_journal(n=8):
+    """Last N attempt records from the journal, oldest first. [] on any read error."""
     try:
-        with open(ANCHOR, encoding="utf-8") as f:
-            data = json.load(f)
-        crit = data.get("criteria") or []
-        return [c.get("id") for c in crit
-                if isinstance(c, dict) and c.get("status") != "done"]
+        with open(JOURNAL, encoding="utf-8") as f:
+            lines = [ln for ln in f if ln.strip()]
+        out = []
+        for ln in lines[-n:]:
+            try:
+                out.append(json.loads(ln))
+            except Exception:
+                continue
+        return out
     except Exception:
-        return []  # fail-open: anchor unreadable ≠ trap
+        return []
+
+
+def write_handoff(reason, meta=None, body=None):
+    """Write the cross-agent continuation artifact before an INCOMPLETE stop.
+
+    Aggregates the frozen task anchor (goal + acceptance criteria + evidence), the last journal
+    attempts (what was already tried, to avoid re-running a dead end), and the live scratchpad
+    iteration/promise — everything a fresh agent needs to resume cold, without this conversation.
+    Fail-open: any error here must never block the stop itself.
+    """
+    try:
+        anchor = read_anchor() or {}
+        criteria = anchor.get("criteria") or []
+        attempts = tail_journal()
+        lines = [
+            "# simplicio-loop handoff",
+            "",
+            "Stop reason: %s" % reason,
+            "Stopped at: %s" % time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        ]
+        if meta:
+            lines += [
+                "Iteration: %s / %s" % (meta.get("iteration", "?"), meta.get("max_iterations", "?")),
+                "Completion promise: %s" % (meta.get("completion_promise") or "(none set)"),
+            ]
+        if anchor.get("goal"):
+            lines += ["", "## Frozen goal", "", anchor["goal"]]
+        elif body:
+            lines += ["", "## Goal (from scratchpad, no anchor set)", "", body]
+        if criteria:
+            lines += ["", "## Acceptance criteria"]
+            for c in criteria:
+                if not isinstance(c, dict):
+                    continue
+                mark = "x" if c.get("status") == "done" else " "
+                ev = (" — %s" % c["evidence"]) if c.get("evidence") else ""
+                lines.append(
+                    "- [%s] %s (%s)%s"
+                    % (mark, c.get("text", c.get("id", "?")), c.get("status", "pending"), ev)
+                )
+        if attempts:
+            lines += ["", "## Last attempts (`scripts/loop_journal.py resume` for the full read)"]
+            for a in attempts:
+                lines.append(
+                    "- iter %s: %s -> %s (fp %s)%s"
+                    % (
+                        a.get("iteration", "?"),
+                        a.get("action", "?"),
+                        a.get("gate", "?"),
+                        (a.get("fingerprint") or "")[:12],
+                        (" — %s" % a["note"]) if a.get("note") else "",
+                    )
+                )
+        lines += [
+            "",
+            "## Resume",
+            "",
+            "1. `python3 scripts/task_anchor.py status` (or `gate --exit-code`) — verified vs open.",
+            "2. `python3 scripts/loop_journal.py resume` — dead-end actions to avoid.",
+            "3. `git log --oneline -10` / `git diff` — what already landed.",
+            "4. Re-arm the loop once the stop cause (budget/cap/manual) is resolved.",
+            "",
+        ]
+        tmp = HANDOFF + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines))
+        os.replace(tmp, HANDOFF)
+    except Exception:
+        pass  # fail-open: a broken handoff write must never block the stop
 
 
 def budget_halted():
@@ -177,8 +273,18 @@ def emit_refeed(followup):
 
 def main():
     try:
-        # Explicit STOP signal beats everything.
+        meta, body = None, None
+        if os.path.exists(SCRATCHPAD):
+            try:
+                with open(SCRATCHPAD, encoding="utf-8") as f:
+                    meta, body = parse_frontmatter(f.read())
+            except OSError:
+                meta, body = None, None
+
+        # Explicit STOP signal beats everything — but still hand off if there was live state.
         if os.path.exists(STOP_SIGNAL):
+            if meta is not None:
+                write_handoff("manual STOP signal", meta, body)
             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
@@ -188,9 +294,6 @@ def main():
         # (1) No active loop.
         if not os.path.exists(SCRATCHPAD):
             allow_stop()
-        with open(SCRATCHPAD, encoding="utf-8") as f:
-            content = f.read()
-        meta, body = parse_frontmatter(content)
         # (2) Corrupt state.
         if meta is None:
             cleanup_and_stop()
@@ -215,21 +318,26 @@ def main():
                 # in the task anchor — the mechanical anti-drift gate. Pending ACs ⇒ ignore the
                 # promise and keep looping (still bounded by max_iter), never a false "done".
                 if ((not evidence_required) or has_evidence) and not anchor_pending():
-                    cleanup_and_stop()  # (3) promise fulfilled → stop
+                    cleanup_and_stop()  # (3) promise fulfilled → stop, no handoff needed
                 # promise without evidence, or anchor still has open ACs → ignore, keep looping
         # (3') Cursor capture may have raised the flag.
         if os.path.exists(DONE_FLAG):
             cleanup_and_stop()
-        # (4) Iteration cap.
+        # (4) Iteration cap — incomplete stop, hand off.
         if max_iter > 0 and iteration >= max_iter:
+            write_handoff("max_iterations cap reached", meta, body)
             cleanup_and_stop()
-        # (5) Budget halted.
+        # (5) Budget halted — incomplete stop, hand off. This is the exact "ran out of tokens/$"
+        # case: a different agent must be able to pick this up cold.
         if budget_halted():
+            write_handoff("budget halted", meta, body)
             cleanup_and_stop()
         # (6) Continue: bump iteration in place, re-feed the goal body.
         nxt = iteration + 1
+        with open(SCRATCHPAD, encoding="utf-8") as f:
+            raw = f.read()
         new_content = re.sub(
-            r"^iteration:\s*\d+", "iteration: %d" % nxt, content, count=1, flags=re.M
+            r"^iteration:\s*\d+", "iteration: %d" % nxt, raw, count=1, flags=re.M
         )
         try:
             tmp = SCRATCHPAD + ".tmp"

{simplicio_loop-3.15.0 → simplicio_loop-3.18.1}/simplicio_loop/_bundle/skills/simplicio-loop/SKILL.md

@@ -312,7 +312,7 @@ Where the host runtime supports lifecycle hooks, bind the two cross-platform hoo
 | Hook | Fires | Job |
 |---|---|---|
 | `afterAgentResponse` → `loop_capture.py` | after every turn | extract `<promise>…</promise>`; if it exactly equals `completion_promise` AND in-turn evidence exists → `touch .orchestrator/loop/done`. Fire-and-forget, `exit 0`. Never stops the loop itself. |
-| `stop` → `loop_stop.py` | when the turn ends | guard clauses, each ends the loop cleanly (remove state, `exit 0`): (1) no scratchpad → stop; (2) corrupt frontmatter → stop; (3) `done` flag present → stop (promise fulfilled); (4) `iteration >= max_iterations > 0` → stop (cap); (5) budget halted → stop; else increment `iteration` in place and emit `{"followup_message": "<header>\n\n<goal body>"}` to re-feed. |
+| `stop` → `loop_stop.py` | when the turn ends | guard clauses, each ends the loop cleanly (remove state, `exit 0`): (1) no scratchpad → stop; (2) corrupt frontmatter → stop; (3) `done` flag present → stop (promise fulfilled); (4) `iteration >= max_iterations > 0` → write `HANDOFF.md`, then stop (cap); (5) budget halted → write `HANDOFF.md` (frozen goal + AC status + last attempts) for a different agent to resume, then stop; else increment `iteration` in place and emit `{"followup_message": "<header>\n\n<goal body>"}` to re-feed. |
 
 Detection (`capture`) and termination (`stop`) are split on purpose — neither parses the
 other's inline state. Iteration carries forward through git history + the working tree, not

{simplicio_loop-3.15.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.15.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.15.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.15.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.15.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.15.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