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

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

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

{simplicio_loop-3.14.1 → simplicio_loop-3.16.0}/README.md

@@ -84,7 +84,7 @@ protocol on 11 runtimes**, and it does all of this with **aggressive, honest tok
 ## 📘 Official capability record
 
 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 + 28 tests). Each links to its
+runnable, and tested** (`python3 scripts/check.py`: claims-audit 5/5 + local test suite). Each links to its
 deep section and its worker.
 
 | Capability | What it does | Proof / worker | Details |
@@ -92,6 +92,8 @@ deep section and its worker.
 | 🎬 **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) |
+| 🧩 **Scope reflection** (`dependency_graph`) | Maps local dependencies, reverse dependents, and related tests from the planned touched files; blocks task plans that ignore callers, sibling files, or proof points before the edit starts | `scripts/impact_audit.py` · `selftest` | [§ Tests & local checks](#-tests--local-checks-no-paid-ci) |
+| 🕸️ **Flow coverage** (`endpoint_compare`) | Maps mixed front/back/service workspaces: UI actions → frontend HTTP calls → backend endpoints → service calls; blocks frontend calls with no backend endpoint and stubbed endpoints, and surfaces unclassified loose ends | `scripts/flow_audit.py` · `selftest` | [§ Tests & local checks](#-tests--local-checks-no-paid-ci) |
 | 🔒 **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) |
@@ -227,8 +229,8 @@ flowchart TD
   POOL --> QG
   subgraph QG["7 · Quality gates"]
     direction LR
-    Q1["AC gate = real DoD"]
-    Q2["WORKS not just compiles · web_verify (Playwright) · video_evidence (Playwright recording · hyperframes on request)"]
+    Q1["AC gate + impact_audit = real DoD"]
+    Q2["WORKS not just compiles · web_verify · video_evidence · flow_audit"]
     Q3["adversarial review · thermos rubrics"]
   end
   QG --> SG
@@ -535,6 +537,16 @@ python3 scripts/check.py            # the whole gate (audit + tests)
 - **Claims audit** (`scripts/claims_audit.py`, fail-closed) — every `scripts/*.py` the docs
   reference exists · the extension-point count agrees across all files · each cited worker command
   actually runs · the shipped `simplicio_loop/_bundle/` skills are **byte-identical** to source.
+- **Impact audit** (`scripts/impact_audit.py`) — for any code task, proves the declared task
+  surface covers the local blast radius: dependencies, reverse dependents, and related tests.
+  ```bash
+  python3 scripts/impact_audit.py audit . --file path/to/seed.py --cover path/to/seed.py --fail-on high
+  ```
+- **Flow audit** (`scripts/flow_audit.py`) — for mixed front/back/service repos, produces the
+  `endpoint_compare` evidence map and fails on objective integration gaps:
+  ```bash
+  python3 scripts/flow_audit.py audit . --fail-on high
+  ```
 - **Wire it as a git pre-push hook** to keep `main` honest for free:
   ```bash
   printf '#!/bin/sh\npython3 scripts/check.py\n' > .git/hooks/pre-push && chmod +x .git/hooks/pre-push

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

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

{simplicio_loop-3.14.1 → simplicio_loop-3.16.0}/simplicio_loop/__init__.py

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

{simplicio_loop-3.14.1 → simplicio_loop-3.16.0}/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.14.1 → simplicio_loop-3.16.0}/simplicio_loop/_bundle/skills/simplicio-loop/SKILL.md

@@ -173,14 +173,29 @@ detector below. It is the difference between a loop that converges and one that
    last recorded turn's commit. **And re-read the task anchor** — `python3 scripts/task_anchor.py
    check --goal "<the goal worked this turn>" --exit-code` — so the turn stays on the SAME frozen
    acceptance criteria and cannot drift: a `DRIFT` verdict (exit 11) means the goal moved; STOP and
-   re-anchor explicitly (`--force`), never wander silently. The journal is the loop's memory for
-   ATTEMPTS; the anchor is its memory for SCOPE. Act only on what is still genuinely open; never redo
-   done work or act on a stale picture (idempotency).
+   re-anchor explicitly (`--force`), never wander silently. Before deciding the next code change,
+   refresh the local impact map for the planned seed files with
+   `python3 scripts/impact_audit.py audit <root> --file <seed> --cover <known-reviewed-file> --json
+   > .orchestrator/impact-audit.json` so the turn sees callers, neighboring dependencies, and
+   related tests before it edits. For shared/public contracts or signature changes, tighten that gate
+   to `--fail-on medium`. For mixed front/back/service workspaces or any cross-surface user flow,
+   also refresh the flow map with
+   `python3 scripts/flow_audit.py audit <root> --fail-on high --json > .orchestrator/flow-audit.json`
+   so triage sees UI actions, frontend calls, backend endpoints, and service calls before deciding
+   the next move. The journal is the loop's memory for ATTEMPTS; the anchor is its memory for SCOPE;
+   the impact audit is its memory for BLAST RADIUS; the flow audit is its memory for INTEGRATION.
+   Act only on what is still genuinely open; never redo done work or act on a stale picture
+   (idempotency).
 3. **Work the goal** each turn as if fresh, against that triaged state. The model DECIDES the
    AC-scoped change; the **`simplicio-dev-cli` operator APPLIES and verifies it**
    (`simplicio-dev-cli task "<change>" --target <file>`) — do not hand-edit inside the loop. End EVERY
    iteration with a short, concrete verification — the operator's passing test run, or one gate /
-   command / `file:line` receipt. **Then RECORD the attempt** in the journal:
+   command / `file:line` receipt. If the actual edit surface expands, rerun `impact_audit.py` with
+   the new seeds/cover and treat uncovered reverse dependents as failed verification; use
+   `--fail-on medium` for shared/public contracts or signature changes. If the change crosses
+   UI/API/service boundaries, rerun
+   `flow_audit.py` after the edit and treat high gaps as failed verification; use `--fail-on medium`
+   when the AC promises backend integration for that UI flow. **Then RECORD the attempt** in the journal:
    `loop_journal.py record --iteration N --action "<what you changed>" --hypothesis "<why>"
    --gate pass|fail --gate-output <test.log>` — on a failure the gate output is fingerprinted so the
    SAME failure is recognised next turn. Keep iterations small and verifiable: a turn that only
@@ -262,6 +277,12 @@ only if, in the SAME turn, there is concrete evidence the work is truly done:
 
 - the run-verification gate passed ("works, not just compiles" — `simplicio-tasks` Step 4b) —
   the `simplicio-dev-cli` operator's passing test+verify pass (its contract step 5/6) satisfies this, or
+- the flow coverage gate passed for a mixed front/back/service change —
+  `python3 scripts/flow_audit.py audit <root> --fail-on high` (or `--fail-on medium` for ACs that
+  promise backend integration) found no unhandled UI/API/service gaps, or
+- the scope/impact gate passed for the changed shared files —
+  `python3 scripts/impact_audit.py audit <root> --file <seed> ...` found no uncovered reverse
+  dependents (and, for shared/public contracts, no uncovered local deps/tests under `--fail-on medium`), or
 - the named acceptance criteria are each checked with a `file:line` or command-output receipt —
   mechanically enforced by the task anchor: `python3 scripts/task_anchor.py gate --exit-code` must
   return READY (every anchored AC `done` with a receipt; exit 12 = still pending) before the promise
@@ -291,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.14.1 → simplicio_loop-3.16.0}/simplicio_loop/_bundle/skills/simplicio-review/SKILL.md

@@ -60,6 +60,16 @@ down, no proportional token blow-up). Each gets the SAME context bundle and a DI
   ledger entry with a screenshot + trace path AND 0 console errors (see the orchestrator's
   `references/web-evidence.md`, Playwright). Missing or failing → `fix-required`. Evidence is the
   artifact PATH, never pasted DOM/pixels.
+- **Cross-surface change → require flow evidence.** If the diff touches frontend + backend/service
+  files, or an AC promises a UI→API/service flow, REQUIRE `scripts/flow_audit.py audit <root>
+  --fail-on high` evidence (`--fail-on medium` when backend integration is part of the AC). Missing
+  audit, frontend call without backend endpoint, stubbed endpoint, or unclassified UI/API/service
+  loose end → `fix-required`.
+- **Shared-contract change → require impact evidence.** If the diff changes exported/shared
+  functions, controllers, DTOs/schemas, shared types, or a widely imported module, REQUIRE
+  `scripts/impact_audit.py audit <root> --file <seed> --cover <reviewed-file> ...` evidence.
+  Any uncovered reverse dependency is `fix-required`; use `--fail-on medium` when the contract
+  itself changed so uncovered neighboring deps/tests also block.
 
 Each reviewer's task: **"Refute this change. Find any AC not met, any fake return, any break.
 Default to 'not done' if uncertain. Cite every finding as `file:line` with a one-line why."**

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

@@ -173,6 +173,27 @@ wander off the task (the "desvio de tarefas" fix, Step 4 drift guard). Detail:
 
 > **Understand Anything (optional).** If `.understand-anything/knowledge-graph.json` exists, use Understand Anything as the primary orientation — the graph already holds the complete code structure, relationships, and guided tours. Query it via semantic search instead of signatures-only reads.
 
+> **Scope reflection / impact coverage (mandatory for any coded change).** Before editing, declare
+> the seed files you expect to touch and the files you already know must be reviewed/adjusted, then
+> run `python3 scripts/impact_audit.py audit <root> --file <seed> --cover <planned-file> --json >
+> .orchestrator/impact-audit.json`. This maps local dependencies, reverse dependents, and related
+> tests so the task cannot silently ignore callers, adjacent modules, or tests that prove the same
+> flow. Any `high` gap (`uncovered_reverse_dependency`) blocks planning until that caller/dependent
+> file is added to the review surface or explicitly ruled out by evidence. For shared/public
+> contracts, signature changes, DTO/schema changes, or refactors in widely imported modules, use
+> `--fail-on medium` so uncovered local dependencies and related tests also block the task plan.
+
+> **Full-stack flow coverage (mandatory for mixed front/back/service workspaces).** When a repo
+> root contains frontend + backend + services together — or the item touches a user flow that crosses
+> those surfaces — run the flow audit BEFORE planning: `python3 scripts/flow_audit.py audit <root>
+> --fail-on high --json > .orchestrator/flow-audit.json`. This maps UI actions, frontend HTTP
+> calls, backend endpoints, and backend service calls. Any `high` gap (frontend call with no backend
+> endpoint, or stubbed/incomplete backend endpoint) is a BLOCKER and must become an AC/fix before
+> `done`. `medium` gaps (button/action with no observed backend call, endpoint with no observed
+> caller, backend local-looking service call with no local endpoint) must be classified explicitly:
+> local-only/internal/external by design, or promoted to an AC. For flows whose AC promises backend
+> integration, rerun with `--fail-on medium`; do not leave loose ends unclassified.
+
 > **Video-creation work-items (`video_evidence`).** A work-item — or the skill argument itself
 > (e.g. `/simplicio-tasks make an explainer video of the login screen`) — may ASK for a demo video.
 > Classify it cheaply in the terminal: `python3 scripts/video_evidence.py detect --goal "<text>"`.
@@ -220,12 +241,24 @@ Never mark done without green gates + evidence; a failure is NOT a blocker — i
   is mechanical: `python3 scripts/task_anchor.py gate --exit-code` (exit 12 = criteria still
   pending) MUST pass before you declare done or open the PR — "done" requires every anchored AC
   verified with a receipt.
+- **4a' Scope/impact gate:** if the actual change surface expanded, rerun
+  `python3 scripts/impact_audit.py audit <root> --file <seed> ... --cover <reviewed-file> ...`
+  and refresh `.orchestrator/impact-audit.json`. The task is not done while a changed shared file
+  still has uncovered reverse dependents, or while a contract/signature change leaves callers,
+  neighboring dependencies, or related tests outside the declared review surface. Use
+  `--fail-on medium` for shared/public contracts.
 - **4b WORKS, not just compiles:** RUN it (`--help` + happy path / affected tests). Front-end
   change → `web_verify` (screenshot + trace, `references/web-evidence.md`). For moving proof of a UI
   change, `video_evidence verify --url <url>` records the **real session with Playwright** (default
   engine) → a video attached to the PR. Only when the item ITSELF asks for a personalized explainer
   ("make a video of screen X") use `--engine hyperframes` (deterministic captioned slideshow).
   Contract: `references/video-evidence.md`. Compiles-but-never-run = PARTIAL.
+- **4b' Flow coverage gate (mixed front/back/service workspaces):** rerun
+  `python3 scripts/flow_audit.py audit <root> --fail-on high` after the change (or
+  `--fail-on medium` when the AC promises backend integration). The task is not done while a
+  frontend call lacks a backend endpoint, a backend endpoint is stubbed/incomplete, or any UI/API/
+  service gap remains unclassified. Attach `.orchestrator/flow-audit.json` or the human summary as
+  evidence alongside tests/screenshots.
 - **4c Adversarial verify (MEDIUM+):** 2–3 independent verifiers prompted to REFUTE + check each
   AC; majority-refute → back to fix. Delegate to `simplicio-review` when loaded. Full: `references/quality-safety-delivery.md`.
 

{simplicio_loop-3.14.1 → simplicio_loop-3.16.0}/simplicio_loop/_bundle/skills/simplicio-tasks/references/extension-points.md

@@ -32,7 +32,7 @@ fallback with standard tools. The skill depends on the ABSTRACTION, never on a s
 | `status` | Live observability dashboard | `gh` queries |
 | `security` | Supply-chain / secret scan | `rg` for secrets |
 | `intake` | Ingest work from sprint/board link | `gh issue list` |
-| `dependency_graph` | Inter-item ordering as a resumable DAG (B after A; independents fan out); re-run skips done nodes | LLM topo-sorts by depends-on/blocked-by, runs ready first, journals done node-ids to resume |
+| `dependency_graph` | Inter-item ordering as a resumable DAG (B after A; independents fan out); re-run skips done nodes. At code level, it also means "what else breaks if I touch this?" — runnable form: `scripts/impact_audit.py audit <root> --file <seed> --cover <planned-file> --json > .orchestrator/impact-audit.json` maps local dependencies, reverse dependents, and related tests for the planned task surface. `high` gaps block missing callers/dependents; `--fail-on medium` blocks uncovered local deps/tests for shared contracts. | LLM topo-sorts by depends-on/blocked-by, runs ready first, journals done node-ids to resume; for code impact, it uses `rg`/imports/git grep to enumerate local dependencies, reverse callers, and related tests, then widens the plan before editing |
 | `durable_workflow` | Per-item pipeline (intake→plan→edit→validate→deliver) as a resumable phase state-machine; retry skips done phases | LLM drives phases, journals which phase each item reached, resumes from last completed |
 | `work_queue` | Durable priority queue that runs+auto-retries+requeues-stuck, with a write-serialization lock for shared checkouts | LLM keeps queue in JSONL/SQLite, pops by priority, re-enqueues on fail, lockfile+TTL guards shared-tree writes |
 | `resource_governor` | Dynamic mid-loop throttle: decide when to back off + machine-tier ceilings before scaling a wave | LLM re-probes CPU/RAM/load each tick, reduces fleet / sleeps longer under load, degrades tiers |
@@ -49,7 +49,7 @@ fallback with standard tools. The skill depends on the ABSTRACTION, never on a s
 | `toolchain_detect` | Detect which build/lint/typecheck/test toolchains the repo actually has so validate/diagnostics route right | LLM inspects manifests/lockfiles/config + probes PATH to pick the correct toolchain per stack |
 | `checkpoint_restore` | Snapshot run/repo state before a risky batch; restore to known-good if validation/delivery fails | LLM tags a commit / stashes / copies the journal before destructive ops, restores on failure |
 | `notify` | Push progress/blocker/digest to a human channel + receive inbound approvals (async approval I/O) | LLM writes digest/approval-request to a file or session; no-reply = block the destructive op (headless rule) |
-| `endpoint_compare` | Compare web/API/agent surfaces to detect drift; gaps become follow-up items (full-stack coverage) | LLM lists routes on each side (grep handlers / read OpenAPI) and diffs by hand to flag mismatches |
+| `endpoint_compare` | Compare web/API/service surfaces to detect drift; gaps become follow-up items or blockers. Runnable form: `scripts/flow_audit.py audit <root> --fail-on high --json > .orchestrator/flow-audit.json` maps UI actions, frontend HTTP calls, backend endpoints, and backend service calls. It blocks on frontend calls without backend endpoints and stubbed backend endpoints; `--fail-on medium` blocks unclassified UI/API/service loose ends for flows whose AC promises integration. | LLM lists UI actions, frontend calls, backend routes/controllers, OpenAPI entries, and service calls with `rg`, then diffs by hand to flag missing endpoints, stub handlers, orphan callers, and unclassified loose ends |
 | `web_verify` | Drive a real browser (navigate/click/console) to prove a UI/web change works end-to-end; capture screenshot+trace as evidence | Playwright via `playwright-mcp` or headless `npx playwright` / `pytest-playwright`; evidence = artifact path, not pixels (see web-evidence.md) |
 | `video_evidence` | Produce a demo video of a screen/feature as evidence — two engines | **DEFAULT = Playwright** native session recording (`video_evidence verify --url …` records the real browser drive to `.webm`→`.mp4`) for the normal moving-proof flow; **hyperframes** (`npx hyperframes render` — heygen-com/hyperframes) only for an EXPLICIT custom explainer request ("make a video of screen X"), assembling the `web_verify` screenshots into a deterministic captioned MP4. Evidence = video path, not bytes (see video-evidence.md); BLOCK if the toolchain is absent |
 | `web_research` | Fetch current external knowledge (docs/CVE/version/SDK error), gated behind local-memory-miss, with provenance | LLM uses built-in web search/fetch only after local miss; records source URL as provenance |

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

@@ -45,6 +45,21 @@ API surface — a 600-line file → ~40 lines; full-body read only when editing
 
 **2b-3 Build the plan BEFORE coding:** files to change, files to read first, AC checklist, risks/
 unknowns, complexity (trivial|small|medium|large|critical). Coding starts only after the plan.
+Make the plan mechanically accountable with the impact audit:
+
+```bash
+python3 scripts/impact_audit.py audit <root> \
+  --file <seed-you-expect-to-touch> \
+  --cover <files-already-in-plan> \
+  --fail-on high \
+  --json > .orchestrator/impact-audit.json
+```
+
+Treat a `high` issue as a planning failure: a caller/dependent file sits outside the declared task
+surface, so the plan is incomplete. For shared/public contracts, signature changes, DTO/schema
+changes, or refactors inside widely imported modules, tighten the gate to `--fail-on medium` so
+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,

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

@@ -34,6 +34,41 @@ The DoD gate is then mechanical: `task_anchor.py gate --exit-code` (exit 12 = cr
 pending) MUST pass before "done" or PR-open. This is the loop's durable working memory for SCOPE,
 the sibling of `loop_journal`'s working memory for ATTEMPTS.
 
+### 4a' — Scope/impact gate for dependency-aware tasks
+Before editing, and again if the changed surface expands, make the task's blast radius explicit:
+
+```bash
+python3 scripts/impact_audit.py audit <root> \
+  --file <seed-you-touch> \
+  --cover <reviewed-or-adjusted-files> \
+  --fail-on high \
+  --json > .orchestrator/impact-audit.json
+```
+
+The audit maps three things around each seed file:
+
+- local dependencies used by the seed
+- reverse dependents/callers that reach the seed, including transitive import chains
+- related tests that prove the same path
+
+Default interpretation:
+
+- `uncovered_reverse_dependency` is `high` and blocks the task: a caller/dependent file exists
+  outside the declared review/edit surface.
+- `uncovered_local_dependency` and `uncovered_related_test` are `medium`: the plan is missing a
+  neighbor or proof point that should at least be reviewed.
+
+For shared/public contracts, signature changes, DTO/schema changes, or refactors in widely
+imported modules, run the stricter gate:
+
+```bash
+python3 scripts/impact_audit.py audit <root> --fail-on medium
+```
+
+The final evidence can cite `.orchestrator/impact-audit.json` or summarize the explicit caller/test
+classification. "I changed one file" is not enough when the dependency map says the task reached
+farther.
+
 ### 4b — WORKS, not just compiles (run-verification, mandatory)
 "Compiles" ≠ "done". Before done it must RUN:
 - New/changed command → invoke for real: `--help` returns 0 AND a minimal happy-path produces the
@@ -45,6 +80,34 @@ the sibling of `loop_journal`'s working memory for ATTEMPTS.
 - Use `validate`/`smoke` if bound. **Front-end change → `web_verify`** (see web-evidence.md):
   screenshot + trace as evidence. An item that compiles but was never run is PARTIAL.
 
+### 4b' — Flow coverage gate for front/back/service workspaces
+When a workspace contains frontend, backend, and services under the same root — or the task touches
+any cross-surface user flow — run a structural flow audit before planning and again before done:
+
+```
+python3 scripts/flow_audit.py audit <root> --fail-on high --json > .orchestrator/flow-audit.json
+```
+
+The audit builds a static map of UI actions, frontend HTTP calls, backend endpoints, and backend
+service calls. It fails the default gate on objective high-confidence gaps:
+
+- `frontend_call_without_backend_endpoint`: the UI/client calls an API path that no scanned backend
+  exposes.
+- `backend_endpoint_stub`: an endpoint body still looks like TODO, `pass`, `NotImplemented`, 501, or
+  a thrown "not implemented" error.
+
+Medium gaps are still work, not noise. They must be classified in the task anchor or promoted to an
+AC before done: UI action with no observed backend call, backend endpoint with no observed frontend
+caller, or backend local-looking service call with no local endpoint. If the AC promises backend
+integration for a UI flow, run the stricter gate:
+
+```
+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

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

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

{simplicio_loop-3.14.1 → simplicio_loop-3.16.0}/simplicio_loop.egg-info/SOURCES.txt

@@ -41,6 +41,8 @@ simplicio_loop/_bundle/skills/simplicio-tasks/references/understand-anything-ada
 simplicio_loop/_bundle/skills/simplicio-tasks/references/video-evidence.md
 simplicio_loop/_bundle/skills/simplicio-tasks/references/web-evidence.md
 tests/test_action_gate.py
+tests/test_flow_audit.py
+tests/test_impact_audit.py
 tests/test_loop_e2e.py
 tests/test_worker_selftests.py
 tests/test_worker_smoke.py

simplicio_loop-3.16.0/tests/test_flow_audit.py

@@ -0,0 +1,72 @@
+import os
+import subprocess
+import sys
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+FLOW = os.path.join(REPO, "scripts", "flow_audit.py")
+
+
+def _write(path, text):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text.strip(), encoding="utf-8")
+
+
+def _run(args, cwd):
+    return subprocess.run([sys.executable, FLOW] + args, capture_output=True, text=True, cwd=cwd)
+
+
+def test_flow_audit_fails_on_frontend_call_without_endpoint(tmp_path):
+    _write(tmp_path / "frontend" / "Checkout.tsx", """
+export function Checkout() {
+  return <button onClick={() => fetch("/api/checkout", { method: "POST" })}>Pay</button>
+}
+""")
+    _write(tmp_path / "backend" / "routes.py", """
+@app.get("/api/health")
+def health():
+    return {"ok": True}
+""")
+
+    r = _run(["audit", str(tmp_path), "--fail-on", "high"], cwd=REPO)
+    assert r.returncode == 1, r.stdout
+    assert "frontend_call_without_backend_endpoint" in r.stdout, r.stdout
+
+
+def test_flow_audit_detects_backend_stub(tmp_path):
+    _write(tmp_path / "frontend" / "Login.tsx", """
+export function Login() {
+  return <button onClick={() => fetch("/api/login", { method: "POST" })}>Login</button>
+}
+""")
+    _write(tmp_path / "backend" / "routes.py", """
+@app.post("/api/login")
+def login():
+    raise NotImplementedError("TODO")
+""")
+
+    r = _run(["audit", str(tmp_path), "--fail-on", "high"], cwd=REPO)
+    assert r.returncode == 1, r.stdout
+    assert "backend_endpoint_stub" in r.stdout, r.stdout
+
+
+def test_flow_audit_passes_matched_non_stub_flow(tmp_path):
+    _write(tmp_path / "frontend" / "Login.tsx", """
+export function Login() {
+  return <button onClick={() => fetch("/api/login", { method: "POST" })}>Login</button>
+}
+""")
+    _write(tmp_path / "backend" / "routes.py", """
+@app.post("/api/login")
+def login():
+    return {"ok": True}
+""")
+
+    r = _run(["audit", str(tmp_path), "--fail-on", "high"], cwd=REPO)
+    assert r.returncode == 0, r.stdout
+    assert "flow-audit: PASS" in r.stdout, r.stdout
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from _selfrun import run_module
+    run_module(globals(), "test_flow_audit")

simplicio_loop-3.16.0/tests/test_impact_audit.py

@@ -0,0 +1,125 @@
+import json
+import os
+import subprocess
+import sys
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+IMPACT = os.path.join(REPO, "scripts", "impact_audit.py")
+
+
+def _write(path, text):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text.strip() + "\n", encoding="utf-8")
+
+
+def _run(args, cwd):
+    return subprocess.run([sys.executable, IMPACT] + args, capture_output=True, text=True, cwd=cwd)
+
+
+def test_impact_audit_fails_on_transitive_reverse_dependency(tmp_path):
+    _write(tmp_path / "app" / "util.py", """
+def helper():
+    return 1
+""")
+    _write(tmp_path / "app" / "service.py", """
+from .util import helper
+
+def compute():
+    return helper()
+""")
+    _write(tmp_path / "app" / "controller.py", """
+from app.service import compute
+
+def run():
+    return compute()
+""")
+
+    r = _run(["audit", str(tmp_path), "--file", "app/util.py", "--cover", "app/util.py"], cwd=REPO)
+    assert r.returncode == 1, r.stdout
+    assert "app/service.py" in r.stdout, r.stdout
+    assert "app/controller.py" in r.stdout, r.stdout
+    assert "uncovered_reverse_dependency" in r.stdout, r.stdout
+
+
+def test_impact_audit_passes_when_callers_and_tests_are_covered(tmp_path):
+    _write(tmp_path / "app" / "util.py", """
+def helper():
+    return 1
+""")
+    _write(tmp_path / "app" / "service.py", """
+from .util import helper
+
+def compute():
+    return helper()
+""")
+    _write(tmp_path / "tests" / "test_service.py", """
+from app.service import compute
+
+def test_compute():
+    assert compute() == 1
+""")
+
+    r = _run(
+        [
+            "audit",
+            str(tmp_path),
+            "--file",
+            "app/util.py",
+            "--cover",
+            "app/util.py",
+            "--cover",
+            "app/service.py",
+            "--cover",
+            "tests/test_service.py",
+        ],
+        cwd=REPO,
+    )
+    assert r.returncode == 0, r.stdout
+    assert "impact-audit: PASS" in r.stdout, r.stdout
+
+
+def test_impact_audit_json_ok_tracks_fail_threshold(tmp_path):
+    _write(tmp_path / "app" / "service.py", """
+from .util import helper
+
+def compute():
+    return helper()
+""")
+    _write(tmp_path / "app" / "util.py", """
+def helper():
+    return 1
+""")
+
+    r = _run(
+        [
+            "audit",
+            str(tmp_path),
+            "--file",
+            "app/service.py",
+            "--cover",
+            "app/service.py",
+            "--fail-on",
+            "medium",
+            "--json",
+        ],
+        cwd=REPO,
+    )
+    assert r.returncode == 1, r.stdout
+    payload = json.loads(r.stdout)
+    assert payload["fail_on"] == "medium"
+    assert payload["ok"] is False
+    assert payload["counts"]["blocking_issues"] >= 1
+    assert any(issue["code"] == "uncovered_local_dependency" for issue in payload["blocking_issues"])
+
+
+def test_impact_audit_without_seed_is_blocked(tmp_path):
+    r = _run(["audit", str(tmp_path)], cwd=REPO)
+    assert r.returncode == 2, r.stdout
+    assert "BLOCKED" in r.stdout, r.stdout
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from _selfrun import run_module
+
+    run_module(globals(), "test_impact_audit")

{simplicio_loop-3.14.1 → simplicio_loop-3.16.0}/tests/test_worker_selftests.py

@@ -1,8 +1,8 @@
 """Aggregate the deterministic `selftest` of every worker that ships one.
 
-Each worker (`loop_journal`, `billing_aggregator`, `savings_harness`) carries a model-free
-`selftest` that proves its arithmetic with no files. This runs them as subprocesses and asserts
-exit 0 + a PASS line — so `python3 scripts/check.py` (or pytest) re-proves them on every change.
+Each worker with a model-free `selftest` proves its own contract with no external services. This
+runs them as subprocesses and asserts exit 0 + a PASS line — so `python3 scripts/check.py`
+(or pytest) re-proves them on every change.
 """
 import os
 import subprocess
@@ -17,6 +17,8 @@ SELFTESTS = [
     ("scripts/savings_harness.py", "selftest"),
     ("scripts/task_anchor.py", "selftest"),
     ("scripts/pr_evidence.py", "selftest"),
+    ("scripts/flow_audit.py", "selftest"),
+    ("scripts/impact_audit.py", "selftest"),
 ]
 
 
@@ -56,6 +58,18 @@ def test_pr_evidence_selftest():
     assert "PASS" in r.stdout, r.stdout
 
 
+def test_flow_audit_selftest():
+    r = _run("scripts/flow_audit.py", "selftest")
+    assert r.returncode == 0, "flow_audit selftest failed:\n%s%s" % (r.stdout, r.stderr)
+    assert "PASS" in r.stdout, r.stdout
+
+
+def test_impact_audit_selftest():
+    r = _run("scripts/impact_audit.py", "selftest")
+    assert r.returncode == 0, "impact_audit selftest failed:\n%s%s" % (r.stdout, r.stderr)
+    assert "PASS" in r.stdout, r.stdout
+
+
 if __name__ == "__main__":
     sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
     from _selfrun import run_module