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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.11.0
+Version: 3.14.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.11.0 → simplicio_loop-3.14.0}/README.md

@@ -81,7 +81,7 @@ protocol on 11 runtimes**, and it does all of this with **aggressive, honest tok
 
 ---
 
-## 📘 Official capability record (v3.10.2)
+## 📘 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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.11.0"
+version = "3.14.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.11.0 → simplicio_loop-3.14.0}/simplicio_loop/__init__.py

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

{simplicio_loop-3.11.0 → simplicio_loop-3.14.0}/simplicio_loop/_bundle/hooks/loop_capture.py

@@ -18,6 +18,7 @@ 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")
 
 PROMISE_RE = re.compile(r"<promise>\s*(.*?)\s*</promise>", re.IGNORECASE | re.DOTALL)
 EVIDENCE_RE = re.compile(
@@ -26,6 +27,22 @@ EVIDENCE_RE = re.compile(
 )
 
 
+def anchor_pending():
+    """Unverified acceptance-criteria ids from the task anchor, or [] (fail-open).
+
+    Mirror of loop_stop.anchor_pending: the done flag is raised only when every anchored AC is
+    `done`. Reads the anchor JSON directly (no dependency on scripts/, which the lean plugin omits);
+    a missing/unreadable/empty anchor returns [] so it never blocks completion.
+    """
+    try:
+        with open(ANCHOR, encoding="utf-8") as f:
+            data = json.load(f)
+        return [c.get("id") for c in (data.get("criteria") or [])
+                if isinstance(c, dict) and c.get("status") != "done"]
+    except Exception:
+        return []
+
+
 def main():
     try:
         raw = sys.stdin.read()
@@ -53,7 +70,9 @@ def main():
         evidence_required = "evidence_required: false" not in content.lower()
         m = PROMISE_RE.search(resp)
         if m and m.group(1).strip() == promise:
-            if (not evidence_required) or EVIDENCE_RE.search(resp):
+            # Evidence-gated AND anchor-gated: raise `done` only with in-turn evidence and no
+            # acceptance criterion still open in the task anchor (mechanical anti-drift).
+            if ((not evidence_required) or EVIDENCE_RE.search(resp)) and not anchor_pending():
                 try:
                     open(DONE_FLAG, "w").close()  # raise the flag; stop hook acts
                 except OSError:

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

@@ -21,6 +21,7 @@ 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")
 STOP_SIGNAL = os.path.join(".orchestrator", "STOP")
 BUDGET = os.path.join(".orchestrator", "loop-budget.json")
 GATE_LOCK = os.path.join(LOOP_DIR, "gate.lock")
@@ -127,6 +128,27 @@ def gate_running():
         return False
 
 
+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.
+    """
+    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"]
+    except Exception:
+        return []  # fail-open: anchor unreadable ≠ trap
+
+
 def budget_halted():
     try:
         if not os.path.exists(BUDGET):
@@ -189,9 +211,12 @@ def main():
             m = PROMISE_RE.search(resp)
             if m and m.group(1).strip() == promise.strip():
                 has_evidence = bool(EVIDENCE_RE.search(resp))
-                if (not evidence_required) or has_evidence:
+                # The promise is honored only with evidence AND no acceptance criterion still open
+                # 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
-                # promise without evidence → ignore, keep looping
+                # 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()
@@ -219,7 +244,16 @@ def main():
             if promise
             else ""
         )
-        header = "[simplicio-loop iteration %d.%s]" % (nxt, promise_hint)
+        # Surface the still-open acceptance criteria so the next turn knows exactly what blocks
+        # "done" — the anchor gate is why a promise would be ignored, so name the gap.
+        pending = anchor_pending()
+        ac_hint = (
+            " Open acceptance criteria (verify each before the promise): %s."
+            % ", ".join(p for p in pending if p)
+            if pending
+            else ""
+        )
+        header = "[simplicio-loop iteration %d.%s%s]" % (nxt, promise_hint, ac_hint)
         emit_refeed(header + "\n\n" + (body or ""))
     except Exception:
         allow_stop()  # fail-open, always

{simplicio_loop-3.11.0 → simplicio_loop-3.14.0}/simplicio_loop/_bundle/skills/simplicio-loop/SKILL.md

@@ -49,25 +49,37 @@ hard dependencies of the `simplicio-loop` package (`pip install simplicio-loop`
 
 | Operator | CLI (binary) | Binds | Role in the loop |
 |---|---|---|---|
-| **simplicio-mapper** | `simplicio-mapper` | `orient` / `recall` | **Survey** — maps the repo(s) into `.simplicio/*.json` (project-map, precedent-index, symbol-index, call-graph, docs). This survey, not an ad-hoc LLM read, is what feeds the goal each turn. |
+| **simplicio-mapper** | `simplicio-mapper` | `orient` / `recall` | **Survey** — maps the repo(s) into `.simplicio/*.json` (project-map, precedent-index, symbol-index, call-graph, docs). Two-tier (v0.9+): `macro` is an instant shallow skeleton (no content reads), `scan` returns that skeleton now and runs the deep index in the background, `status` reports the deep-pass phase. This survey, not an ad-hoc LLM read, is what feeds the goal each turn. |
 | **simplicio-dev-cli** | `simplicio-dev-cli` | `execute` / `deterministic_edit` / `validate` / `diagnostics` | **Operate** — applies a DECIDED change through its 6-layer contract (mapper context → precedent → prompt → diff → test → verify, ≤3 retries). The CLI edits and verifies; the AI does not hand-write the diff. |
 
-**Preflight (MANDATORY, BLOCKING).** Before iteration 1, confirm both operators are on PATH:
+**Preflight (MANDATORY, BLOCKING).** Before iteration 1, auto-update both operators to their latest
+release (so every run uses the newest `simplicio-mapper`/`simplicio-cli`), then confirm both are on
+PATH:
 ```bash
-simplicio-mapper --version   # survey operator
+# Always run the loop on the latest operators. FAIL-OPEN: offline / no-pip / a pin keeps the
+# currently-installed build; this never blocks. Runs ONCE per loop preflight, not per turn.
+python3 -m pip install -qU simplicio-mapper simplicio-cli 2>/dev/null \
+  || python3 -m pip install -qU --user --break-system-packages simplicio-mapper simplicio-cli 2>/dev/null || true
+simplicio-mapper --version   # survey operator (now latest)
 simplicio-dev-cli --help     # action operator (pkg simplicio-cli; exposes `simplicio-dev-cli`)
 ```
-The action binary is `simplicio-dev-cli` (from `pip install simplicio-cli`) — NOT the bare
+The auto-update is best-effort and offline-safe — a network/pip failure leaves the working version
+in place and the loop proceeds. The action binary is `simplicio-dev-cli` (from `pip install simplicio-cli`) — NOT the bare
 `simplicio`, which is reserved for the separate `simplicio-runtime` and is not what this loop
 binds. `simplicio-dev-cli` has no `--version` subcommand; `--help` exiting 0 is the readiness
 proof. If either operator is missing, do NOT fall back to LLM survey/editing — STOP and emit
 `simplicio-loop: BLOCKED — missing operator <name>; run: pip install simplicio-loop` (the install
 re-pulls `simplicio-mapper` + `simplicio-cli`). This requirement is scoped to the loop drive.
 
-**Survey step (each loop start + on any structural change).** Run
-`simplicio-mapper index . --json` (add `--watch` for long runs) to (re)build `.simplicio/`. Read
-the survey artifacts — never re-scan the tree by hand when a fresh map exists. For a multi-repo
-survey, run the mapper per repo root and aggregate the JSON.
+**Survey step (each loop start + on any structural change).** Prefer the two-tier flow (v0.9+):
+`simplicio-mapper scan . --json` returns an instant `macro` skeleton AND kicks the deep index off in
+the background — the loop starts working immediately instead of blocking on a full crawl. Poll
+`simplicio-mapper status . --json` (`phase`: `deep_running` → terminal) before relying on the deep
+artifacts; pass `--await [--timeout <s>]` to block until terminal, or `scan --sync` (forced when
+`CI=true`) for the old single-shot behavior. `simplicio-mapper index . --json` (add `--watch` for
+long runs) remains the synchronous full (re)build of `.simplicio/`. Read the survey artifacts —
+never re-scan the tree by hand when a fresh map exists. For a multi-repo survey, run the mapper per
+repo root and aggregate the JSON.
 
 **Operate step (every turn that mutates code).** Once the AC and the change are DECIDED, delegate
 the mutation to the operator, one decided change at a time:
@@ -84,9 +96,9 @@ merge/close gates); the operators do survey + apply:
 
 | Phase | Operator | Command |
 |---|---|---|
-| Preflight (before iteration 1) | both | `simplicio-mapper --version` · `simplicio-dev-cli --help` → BLOCK if missing |
-| Survey (loop start; multi-repo: per root) | mapper | `simplicio-mapper index . --json` → `.simplicio/*.json` |
-| Loop contract step 2 — Triage (every turn) | mapper | re-read `.simplicio/*.json`; `simplicio-mapper index . --json` to refresh if the tree changed |
+| Preflight (before iteration 1) | both | `python3 -m pip install -qU simplicio-mapper simplicio-cli` (auto-update to latest, fail-open) → `simplicio-mapper --version` · `simplicio-dev-cli --help` → BLOCK if missing |
+| Survey (loop start; multi-repo: per root) | mapper | `simplicio-mapper scan . --json` (instant macro + deep index in background; `--sync`/`--await` to block) → `.simplicio/*.json`. `index . --json` for a forced synchronous build |
+| Loop contract step 2 — Triage (every turn) | mapper | re-read `.simplicio/*.json`; `simplicio-mapper macro . --json` for an instant skeleton, or `scan`/`status` to refresh if the tree changed |
 | Loop contract step 3 — Work the goal | dev-cli | `simplicio-dev-cli task "<decided change>" --target <file> [--json]` |
 | Evidence-gated `<promise>` / `simplicio-tasks` Step 4b | dev-cli | the operator's passing test+verify pass = in-turn evidence |
 
@@ -151,14 +163,19 @@ detector below. It is the difference between a loop that converges and one that
    `.orchestrator/loop-budget.json` $ kill-switch (see `simplicio-tasks` Step 1a/7).
 2. **Triage the live state FIRST (mandatory).** Before any action each turn, re-read the ground
    truth — the **`simplicio-mapper` survey** (`.simplicio/*.json`; refresh it with
-   `simplicio-mapper index . --json` if the tree changed), `git status`/`git diff`, the working
+   `simplicio-mapper macro . --json` for an instant skeleton or `scan . --json` if the tree changed),
+   `git status`/`git diff`, the working
    tree, the scratchpad notes, AND the source of record (re-query the open issues/PRs, existing
    branches, the `.orchestrator/loop/done` flag). **Also read the attempt memory FIRST**:
    `python3 scripts/loop_journal.py resume` — it lists what was already tried and the dead-end
    actions to AVOID, so the turn never re-runs a known-failing approach. For **incremental triage**
    (don't re-scan the whole tree every turn), `loop_journal.py since` shows only the delta since the
-   last recorded turn's commit. Act only on what is still genuinely open; never redo done work or
-   act on a stale picture (idempotency).
+   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).
 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
@@ -245,7 +262,11 @@ 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 named acceptance criteria are each checked with a `file:line` or command-output receipt, 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
+  is allowed. An anchor with pending criteria makes the `<promise>` a contract violation, exactly
+  like missing evidence, or
 - for a queue, the source re-query confirms the items are actually closed/merged, or
 - a **demo video** of the change running on screen — a deterministic MP4 rendered with
   **hyperframes** via the `video_evidence` producer (below) — whose ledger row + MP4 path prove

{simplicio_loop-3.11.0 → simplicio_loop-3.14.0}/simplicio_loop/_bundle/skills/simplicio-tasks/SKILL.md

@@ -164,7 +164,11 @@ List candidates by METADATA only; normalize to the canonical schema; dedup by so
 normalized-title + fingerprint AND by existing branch/PR (idempotency). Before implementing an
 item, do the MANDATORY deep intake: read full body + ALL comments, extract acceptance criteria
 (an obvious-but-missing AC is a BLOCKER — ask once), orient the existing code (signatures-only
-reads for API surface), then write a short plan with an AC checklist + complexity. Detail:
+reads for API surface), then write a short plan with an AC checklist + complexity. **FREEZE the
+acceptance criteria as the task anchor** (`python3 scripts/task_anchor.py set --item <id> --goal
+"<verbatim>" --ac "<AC>" …`) — this is the loop's memory for SCOPE (sibling to `loop_journal`'s
+memory for ATTEMPTS): it is what every later turn re-checks so the run cannot silently narrow or
+wander off the task (the "desvio de tarefas" fix, Step 4 drift guard). Detail:
 `references/orchestration.md`.
 
 > **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.
@@ -203,8 +207,19 @@ Never mark done without green gates + evidence; a failure is NOT a blocker — i
   re-trying the same approach: switch strategy, or escalate via the human gate (Step 5) with the
   fingerprint + dead-ends. Start each turn with `loop_journal.py resume` to avoid known dead-ends.
   Delegate to `simplicio-loop` when loaded (§ Run-journal + stall detector).
+- **AC anchor + drift guard (anti-deviation).** Every turn, BEFORE acting, re-read the frozen
+  anchor and verify you are still on the SAME task: `python3 scripts/task_anchor.py check --goal
+  "<the goal you are working now>" --exit-code` (verdict `DRIFT` ⇒ exit 11 — the goal moved; STOP
+  and re-anchor explicitly with `--force`, never drift silently). As each AC is genuinely met,
+  record its receipt — `task_anchor.py mark --id ACk --status done --evidence "<file:line / cmd /
+  screenshot>"` (a `done` with no evidence is REFUSED). The anchor is the runnable form of
+  "never narrow the task": it makes the orchestrator's working memory for SCOPE durable, exactly as
+  `loop_journal` does for ATTEMPTS.
 - **4a AC gate (real DoD):** verify EVERY AC explicitly; no placeholder/stub success, no
-  `todo!()`/`panic!` in prod paths, reads from context, compiles clean on changed files.
+  `todo!()`/`panic!` in prod paths, reads from context, compiles clean on changed files. The gate
+  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.
 - **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
@@ -234,7 +249,16 @@ Never mark done without green gates + evidence; a failure is NOT a blocker — i
 
 ## Step 6 — Deliver + close + self-audit  ·  Step 6b — Feedback loop
 Per completed item: commit (Conventional Commits, English), push, Draft PR, close in-source with a
-short evidence comment (PR link + verification). If the `pr_template` extension point is available, use it to auto-fill the PR body from the discovered PULL_REQUEST_TEMPLATE.md and the item's acceptance criteria. Otherwise, read .github/PULL_REQUEST_TEMPLATE.md directly and fill in the sections. **Verify reality, never trust self-report** — the
+short evidence comment (PR link + verification). **Assemble the PR body mechanically so it ALWAYS
+carries prints + an item-by-item AC check** — `python3 scripts/pr_evidence.py build --item <id>
+--title "<t>" --summary "<s>" --require-evidence --out .orchestrator/pr_body.md` pulls the
+item-by-item acceptance-criteria checklist from the task anchor (Step 2b/4) AND embeds the
+screenshots/recordings captured by `web_verify`/`video_evidence` under `.orchestrator/tee/web`; with
+`--require-evidence` it EXITS 3 (blocked) rather than open a PR with no prints and no checklist (the
+"PR sem evidência" fix). It honors the discovered `.github/PULL_REQUEST_TEMPLATE.md` (the
+`pr_template` extension point) — appending the checklist + prints under the maintainer's sections —
+and `pr_evidence.py comment --item <id> --pr <N>` emits the matching in-source evidence comment.
+**Verify reality, never trust self-report** — the
 final step re-runs the merged build/test + smoke + a source re-query; the run's status = that
 measured state. Then self-audit (score, fix P0/P1, converge). Pursue the feedback loop until
 merge-ready: CI fail → fix root cause; review comments → adjust; branch behind main → additive

{simplicio_loop-3.11.0 → simplicio_loop-3.14.0}/simplicio_loop/_bundle/skills/simplicio-tasks/references/extension-points.md

@@ -36,10 +36,10 @@ fallback with standard tools. The skill depends on the ABSTRACTION, never on a s
 | `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 |
-| `delivery_gate` | One DoD gate: AC check + run-verification + regression guard + diff self-review + delivery certificate | LLM walks the AC checklist, runs affected tests, reviews own diff, writes a certificate into the receipt |
+| `delivery_gate` | One DoD gate: AC check + run-verification + regression guard + diff self-review + delivery certificate. Runnable form: the **task anchor** (`scripts/task_anchor.py`) freezes the ACs at intake, `check` flags goal-drift each turn (anti-deviation), `mark` records a per-AC receipt, and `gate` (exit 12) BLOCKS "done"/PR-open while any AC is unverified. | LLM walks the AC checklist, runs affected tests, reviews own diff, writes a certificate into the receipt |
 | `action_gate` | Risk-classify every mutation (safe/auto/ask) vs allow/deny + hardline blocklist before it runs | LLM pattern-matches action vs irreversible-op list, secret-scans, proceeds/auto-runs/escalates to `human_gate` |
 | `repo_conventions` | LEARN the repo's own playbook, not just what's documented. Worker `scripts/repo_conventions.py learn` mines the git history (branch-name scheme, commit convention + REAL scope list, ticket pattern — by frequency) + merged PRs via `gh` (title pattern, label vocab, PR-body sections) + static config (CONTRIBUTING.md/AGENTS.md/pyproject.toml for a Conventional-Commits/commitizen hint, and the PR template for body-section structure) → one hash-pinned `.orchestrator/conventions.json` (`source=history\|config\|default`, confidence-gated: sparse history degrades to an honest default, never an over-fit guess). Steps 4–6 apply it deterministically via `repo_conventions.py branch`/`commit`. PR bodies are untrusted data; a learned convention never overrides a safety gate. | LLM reads CONTRIBUTING.md + AGENTS.md + .github/ + pyproject.toml AND skims `git log`/`gh pr list` for the dominant branch/commit/PR pattern, emits the same structured conventions summary that shapes Step 4–6 (branch naming, commit scopes, PR checklist, CI/lint/test gates). |
-| `pr_template` | Discover .github/PULL_REQUEST_TEMPLATE.md, parse structured sections (what/why, how to test, checklist), map completed ACs to checklist items, and auto-fill the PR body before creation. Ensures every PR matches the maintainer's expected format on first submission. | LLM reads .github/PULL_REQUEST_TEMPLATE.md, maps completed acceptance criteria to each checklist item, fills in what/why from the item description and the implementation summary, lists changed files with rationale. |
+| `pr_template` | Discover .github/PULL_REQUEST_TEMPLATE.md, parse structured sections (what/why, how to test, checklist), map completed ACs to checklist items, and auto-fill the PR body before creation. Ensures every PR matches the maintainer's expected format on first submission. Runnable form: `scripts/pr_evidence.py build --require-evidence` assembles the body with the **item-by-item AC checklist** (from the task anchor) + the **prints/recordings** captured under `.orchestrator/tee/web`, honoring the discovered template; it FAILS CLOSED (exit 3) rather than open an evidence-less PR. | LLM reads .github/PULL_REQUEST_TEMPLATE.md, maps completed acceptance criteria to each checklist item, fills in what/why from the item description and the implementation summary, lists changed files with rationale. |
 | `reuse_precedent` | Match item by fingerprint to a prior SOLVED run → reuse not regenerate → ingest the new solution back | LLM greps past PRs/closed issues/solved-patterns journal for the fingerprint, applies it, appends new solution |
 | `sibling_search` | Given a changed file/function/pattern, find all other call sites or implementations with the same pattern across the repo. Enumerate sibling paths so the fix covers the entire bug class, not just one reported instance. Critical for projects where maintainers reject single-site fixes. | LLM uses `grep -rn` / `rg` for the symbol/pattern, traces each candidate with `git log -p -S`, reads each sibling to confirm the same bug class, then includes all confirmed siblings in the fix scope. |
 | `source_adapter` | Uniform source connector contract (list_ready/get_details/claim/update/attach/close) bound per source | LLM calls the source CLI/REST per verb; lockfile/label claim with TTL for cross-session safety |
@@ -66,7 +66,7 @@ them to two installed CLIs (hard deps of `pip install simplicio-loop`) and BLOCK
 
 | Point(s) | Bound CLI | What replaces the LLM fallback |
 |---|---|---|
-| `orient` / `recall` | `simplicio-mapper` (`simplicio-mapper index . --json`) | the repo SURVEY — `.simplicio/*.json` (project-map, precedent-index, symbol-index, call-graph) instead of ad-hoc LLM reads |
+| `orient` / `recall` | `simplicio-mapper` (`simplicio-mapper scan . --json`; `macro` for an instant skeleton, `status` for the deep-pass phase, `index . --json` for a forced synchronous build) | the repo SURVEY — `.simplicio/*.json` (project-map, precedent-index, symbol-index, call-graph) instead of ad-hoc LLM reads |
 | `execute` / `deterministic_edit` / `validate` / `diagnostics` | `simplicio-dev-cli task` (binary `simplicio-dev-cli`, pkg `simplicio-cli`) | the OPERATOR — applies a decided change via its 6-layer contract (mapper→precedent→prompt→diff→test→verify, ≤3 retries); the AI never hand-writes the diff inside the loop |
 
 This is the one place the abstraction is realized by a REQUIRED binding rather than an optional

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

@@ -24,6 +24,16 @@ DoD per item:
 ```
 Done only when fully green. "N/A" on a real AC → mark `partial`, note what's missing.
 
+**Anchor the ACs — don't re-derive them (anti-deviation).** The acceptance criteria are frozen
+ONCE at intake as the task anchor (`task_anchor.py set`, Step 2b) and re-checked every turn so the
+run cannot silently narrow or wander off the task. Per turn: `task_anchor.py check --goal "<goal
+worked now>" --exit-code` (verdict `DRIFT`/exit 11 ⇒ the goal moved — STOP, re-anchor with `--force`
+only if the task genuinely changed). As each AC is met: `task_anchor.py mark --id ACk --status done
+--evidence "<file:line / command output / screenshot path>"` (a `done` with no receipt is REFUSED).
+The DoD gate is then mechanical: `task_anchor.py gate --exit-code` (exit 12 = criteria still
+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.
+
 ### 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
@@ -91,6 +101,19 @@ sections + label vocabulary. Then push, Draft PR, close the item in its source w
 comment (PR link + verification summary). When the profile is `source=default` (no clear repo
 history), fall back to Conventional Commits and say so.
 
+**Every PR carries prints + an item-by-item AC check (the `pr_evidence` worker).** Do NOT hand-write
+the PR body and risk forgetting the proof — assemble it mechanically:
+`python3 scripts/pr_evidence.py build --item <id> --title "<t>" --summary "<s>" --require-evidence
+--out .orchestrator/pr_body.md`. It pulls the item-by-item checklist from the task anchor (one line
+per AC, with its status + the receipt that verified it) AND embeds every screenshot/recording
+captured by `web_verify`/`video_evidence` under `.orchestrator/tee/web`. With `--require-evidence`
+it FAILS CLOSED — exit 3 (`blocked`), never a body — when there is neither a checklist nor a single
+print, so an evidence-less PR cannot be opened by accident. It honors a discovered
+`.github/PULL_REQUEST_TEMPLATE.md` (keeps the maintainer's sections, appends the checklist + prints
+below). `pr_evidence.py comment --item <id> --pr <N>` emits the matching in-source evidence comment
+(PR link + per-AC check + a count of attached prints). Write surrounding comment PROSE in the user's
+language; keep paths/identifiers in English.
+
 **Verify in the workflow, never trust self-report.** When a fan-out drove the run, its FINAL step
 re-verifies reality: the merged build/test, the `smoke` gate, and a source re-query confirming
 items are actually closed. The run's status = that measured state, not the sum of agent claims.

{simplicio_loop-3.11.0 → simplicio_loop-3.14.0}/simplicio_loop/_bundle/skills/simplicio-tasks/references/understand-anything-adapter.md

@@ -38,7 +38,7 @@ file — no LLM invocation, no re-scan. The full analysis is re-run only intenti
 
 | Extension point | Default (`simplicio-mapper`) | Understand Anything adapter |
 |---|---|---|
-| `orient` | `simplicio-mapper index . --json` → `.simplicio/*.json` | Read `.understand-anything/knowledge-graph.json` + `jq` queries |
+| `orient` | `simplicio-mapper scan . --json` (or `index . --json` synchronous) → `.simplicio/*.json` | Read `.understand-anything/knowledge-graph.json` + `jq` queries |
 | `recall` | `.simplicio/precedent-index.json` (past resolutions) | Guided tours + semantic search over the graph + prior `/understand-diff` snapshots |
 
 ### When to use which

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.11.0
+Version: 3.14.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.11.0 → simplicio_loop-3.14.0}/tests/test_loop_e2e.py

@@ -5,6 +5,8 @@ the loop stops on **evidence**, not on a bare promise, and not by accident. We d
 
   • promise + evidence            → STOP (state cleaned up)        ← the success exit
   • promise WITHOUT evidence       → CONTINUE (re-feed, ignored)   ← the anti-false-done guard
+  • promise + evidence, AC pending → CONTINUE (re-feed, ignored)   ← the anti-DRIFT anchor gate
+  • promise + evidence, ACs done   → STOP                          ← anchor satisfied
   • no promise, under cap          → CONTINUE (iteration bumped)
   • iteration >= max_iterations    → STOP by cap                   ← distinct from the evidence exit
   • .orchestrator/STOP signal      → STOP immediately
@@ -79,6 +81,40 @@ def test_bare_promise_without_evidence_continues(tmp_path):
     assert _iteration(root) == 2
 
 
+def _write_anchor(root, criteria):
+    loop = os.path.join(root, ".orchestrator", "loop")
+    os.makedirs(loop, exist_ok=True)
+    with open(os.path.join(loop, "anchor.json"), "w", encoding="utf-8") as f:
+        json.dump({"item": "1", "goal": "g", "goal_fp": "x", "criteria": criteria}, f)
+
+
+def test_promise_with_evidence_but_pending_anchor_continues(tmp_path):
+    # The mechanical anti-drift gate: even WITH evidence, a promise must NOT stop the loop while the
+    # task anchor still has an unverified acceptance criterion — it re-feeds instead, naming the gap.
+    root = str(tmp_path)
+    _arm(root, iteration=1, max_iter=5)
+    _write_anchor(root, [{"id": "AC1", "status": "done"}, {"id": "AC2", "status": "pending"}])
+    r = _tick(root, "Looks done. <promise>SIMPLICIO_DONE</promise> tests pass ✓ "
+                    "https://github.com/o/r/pull/9")
+    assert r.returncode == 0
+    assert "followup_message" in r.stdout or "block" in r.stdout, \
+        "a promise with an open AC must be ignored, not honored:\n%s" % r.stdout
+    assert os.path.exists(_scratchpad(root)), "loop wrongly stopped with an open AC"
+    assert "AC2" in r.stdout, "re-feed should name the open acceptance criterion:\n%s" % r.stdout
+
+
+def test_promise_with_evidence_all_acs_done_stops(tmp_path):
+    # Once every anchored AC is verified, the evidence-backed promise stops the loop as before.
+    root = str(tmp_path)
+    _arm(root, iteration=1, max_iter=5)
+    _write_anchor(root, [{"id": "AC1", "status": "done"}, {"id": "AC2", "status": "done"}])
+    r = _tick(root, "All green. <promise>SIMPLICIO_DONE</promise> tests pass ✓ "
+                    "https://github.com/o/r/pull/9")
+    assert r.returncode == 0
+    assert r.stdout.strip() == "", "expected STOP (every AC verified), got: %s" % r.stdout
+    assert not os.path.exists(_scratchpad(root)), "state should be cleaned up on a verified stop"
+
+
 def test_no_promise_continues_and_bumps_iteration(tmp_path):
     root = str(tmp_path)
     _arm(root, iteration=2, max_iter=5)

{simplicio_loop-3.11.0 → simplicio_loop-3.14.0}/tests/test_worker_selftests.py

@@ -15,6 +15,8 @@ SELFTESTS = [
     ("scripts/loop_journal.py", "selftest"),
     ("scripts/billing_aggregator.py", "selftest"),
     ("scripts/savings_harness.py", "selftest"),
+    ("scripts/task_anchor.py", "selftest"),
+    ("scripts/pr_evidence.py", "selftest"),
 ]
 
 
@@ -42,6 +44,18 @@ def test_savings_harness_selftest():
     assert "FAIL" not in r.stdout.upper() or "PASS" in r.stdout.upper(), r.stdout
 
 
+def test_task_anchor_selftest():
+    r = _run("scripts/task_anchor.py", "selftest")
+    assert r.returncode == 0, "task_anchor selftest failed:\n%s%s" % (r.stdout, r.stderr)
+    assert "PASS" in r.stdout, r.stdout
+
+
+def test_pr_evidence_selftest():
+    r = _run("scripts/pr_evidence.py", "selftest")
+    assert r.returncode == 0, "pr_evidence 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

{simplicio_loop-3.11.0 → simplicio_loop-3.14.0}/tests/test_worker_smoke.py

@@ -97,6 +97,75 @@ def test_repo_conventions_formatters_default():
     assert c.stdout.strip() == "feat(auth): add SSO", c.stdout
 
 
+def _run_anchor(args, env):
+    return subprocess.run([sys.executable, os.path.join(REPO, "scripts", "task_anchor.py")] + args,
+                          capture_output=True, text=True, cwd=REPO, env=env)
+
+
+def test_task_anchor_gate_and_drift(tmp_path):
+    # The anti-deviation guard: a freshly anchored task must BLOCK the done-gate (nothing verified),
+    # flag a CHANGED goal as DRIFT, and only go READY once every AC is marked with a receipt.
+    env = dict(os.environ, SIMPLICIO_ANCHOR_FILE=str(tmp_path / "anchor.json"))
+    s = _run_anchor(["set", "--item", "9", "--goal", "Add SSO login",
+                     "--ac", "Renders an SSO button", "--ac", "Redirects to the IdP"], env)
+    assert s.returncode == 0, s.stdout + s.stderr
+
+    g = _run_anchor(["gate", "--exit-code"], env)
+    assert g.returncode == 12, "expected BLOCKED exit 12, got %d:\n%s" % (g.returncode, g.stdout)
+    assert "blocked" in g.stdout.lower(), g.stdout
+
+    d = _run_anchor(["check", "--goal", "refactor the database layer", "--exit-code"], env)
+    assert d.returncode == 11, "expected DRIFT exit 11, got %d:\n%s" % (d.returncode, d.stdout)
+    assert "drift" in d.stdout.lower(), d.stdout
+
+    # marking done WITHOUT a receipt must be refused (no fake "done") and not record progress
+    nm = _run_anchor(["mark", "--id", "AC1", "--status", "done"], env)
+    assert nm.returncode == 12, nm.stdout
+    assert "blocked" in nm.stdout.lower() and "requires --evidence" in nm.stdout.lower(), nm.stdout
+    # the refused mark must NOT have advanced the gate
+    still = _run_anchor(["gate", "--exit-code"], env)
+    assert still.returncode == 12, "refused mark leaked progress:\n%s" % still.stdout
+
+    _run_anchor(["mark", "--id", "AC1", "--status", "done", "--evidence", "a.png"], env)
+    _run_anchor(["mark", "--id", "AC2", "--status", "done", "--evidence", "b.png"], env)
+    ok = _run_anchor(["gate", "--exit-code"], env)
+    assert ok.returncode == 0, "expected READY, got %d:\n%s" % (ok.returncode, ok.stdout)
+    assert "ready" in ok.stdout.lower(), ok.stdout
+
+
+def test_pr_evidence_blocks_without_evidence(tmp_path):
+    # The "PR sem evidência" fix: with --require-evidence and neither a checklist nor a print,
+    # building the PR body MUST block (exit 3) and never emit a body / claim done.
+    env = dict(os.environ, SIMPLICIO_ANCHOR_FILE=str(tmp_path / "none.json"))
+    r = subprocess.run([sys.executable, os.path.join(REPO, "scripts", "pr_evidence.py"), "build",
+                        "--require-evidence", "--anchor", str(tmp_path / "none.json"),
+                        "--shots-dir", str(tmp_path / "empty")],
+                       capture_output=True, text=True, cwd=REPO, env=env)
+    assert r.returncode == 3, "expected BLOCKED exit 3, got %d:\n%s" % (r.returncode, r.stdout)
+    assert "blocked" in r.stdout.lower(), r.stdout
+    assert "# " not in r.stdout, "leaked a PR body while blocked:\n%s" % r.stdout
+
+
+def test_pr_evidence_builds_with_checklist_and_prints(tmp_path):
+    # With an anchor + a captured print, the body MUST contain the item-by-item checklist and embed
+    # the screenshot — the two things the client said were missing.
+    anchor = str(tmp_path / "anchor.json")
+    env = dict(os.environ, SIMPLICIO_ANCHOR_FILE=anchor)
+    _run_anchor(["set", "--item", "9", "--goal", "Add SSO login",
+                 "--ac", "Renders an SSO button"], env)
+    _run_anchor(["mark", "--id", "AC1", "--status", "done", "--evidence", "login.png"], env)
+    shots = tmp_path / "shots"
+    shots.mkdir()
+    (shots / "login.png").write_bytes(b"PNG")
+    r = subprocess.run([sys.executable, os.path.join(REPO, "scripts", "pr_evidence.py"), "build",
+                        "--title", "Add SSO login", "--item", "9", "--require-evidence",
+                        "--anchor", anchor, "--shots-dir", str(shots)],
+                       capture_output=True, text=True, cwd=REPO, env=env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    assert "[x] **AC1**" in r.stdout, "missing item-by-item checklist:\n%s" % r.stdout
+    assert "login.png" in r.stdout, "missing embedded print:\n%s" % r.stdout
+
+
 if __name__ == "__main__":
     sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
     from _selfrun import run_module