simplicio-loop 3.22.6__tar.gz → 3.23.0__tar.gz

{simplicio_loop-3.22.6/simplicio_loop.egg-info → simplicio_loop-3.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.22.6
+Version: 3.23.0
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -20,7 +20,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: simplicio-mapper>=0.17.0
-Requires-Dist: simplicio-cli>=0.9.5
+Requires-Dist: simplicio-cli>=0.9.6
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Provides-Extra: ml

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.22.6"
+version = "3.23.0"
 description = "The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime."
 readme = "PYPI.md"
 requires-python = ">=3.8"
@@ -26,7 +26,7 @@ classifiers = [
 #   simplicio-cli    -> the operator that applies+verifies changes (binds `execute`/`deterministic_edit`)
 dependencies = [
   "simplicio-mapper>=0.17.0",
-  "simplicio-cli>=0.9.5",
+  "simplicio-cli>=0.9.6",
 ]
 
 # Optional: the real embedding backend for `simplicio-cli semantic --ml` / `simplicio-cli rag --ml`.

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/simplicio_loop/_bundle/skills/simplicio-loop/SKILL.md

@@ -158,9 +158,11 @@ detector below. It is the difference between a loop that converges and one that
    Before deciding the change, refresh the impact map (`python3 scripts/impact_audit.py audit <root>
    --file <seed> --cover <known-file> --json`, `--fail-on medium` for shared/public contracts) and,
    for cross-surface flows, the flow map (`python3 scripts/flow_audit.py audit <root> --fail-on
-   high --json`). Journal = memory for ATTEMPTS; anchor = SCOPE; impact audit = BLAST RADIUS; flow
-   audit = INTEGRATION. Act only on what's still genuinely open (idempotency). Full rationale +
-   extra flags: **`references/triage-verify-detail.md`**.
+   high --json`). When a Phase 0 decomposition exists, also re-read the backlog (`python3
+   scripts/task_backlog.py status`). Journal = memory for ATTEMPTS; anchor = SCOPE; backlog =
+   THE DECOMPOSITION; impact audit = BLAST RADIUS; flow audit = INTEGRATION. Act only on what's
+   still genuinely open (idempotency). Full rationale + extra flags:
+   **`references/triage-verify-detail.md`**.
 3. **Work the goal** each turn against that triaged state. The model DECIDES the AC-scoped change;
    the **`simplicio-dev-cli` operator APPLIES and verifies it** — never hand-edit inside the loop.
    End EVERY iteration with a concrete verification. **After the operator passes, run the watcher
@@ -193,7 +195,7 @@ for a single goal, `drain` for a work-queue.
 | | `converge` (single hard task) | `drain` (a queue of items) |
 |---|---|---|
 | Wants | depth — keep changing strategy until ONE thing passes | breadth — clear many independent items, idempotently |
-| Each turn | triage `since` last turn (incremental) → one AC-scoped change → verify → watcher-gate → journal | claim next open item → implement → deliver → re-query source |
+| Each turn | triage `since` last turn (incremental) → one AC-scoped change → verify → watcher-gate → journal | claim next open item → implement → deliver → re-query source (the local Phase 0 backlog is a first-class source: re-query = `task_backlog.py next`; an `empty` print counts as a dry round, `dry≥2` unchanged) |
 | **Termination** | the evidence-gated `<promise>` fires, OR the **stall detector** says STALLED and escalates (below) | the source re-query returns empty for **K consecutive rounds** (`dry≥2`) AND the working set is idle |
 | Anti-pattern it avoids | oscillation (retrying the same dead-end) | missing late-arriving work (stops too early) |
 
@@ -204,6 +206,27 @@ genuinely stuck; `drain` is done when the queue stays empty across rounds. Don't
 and don't apply `converge`'s stall-escalation to a queue (a stuck item should be quarantined, not
 halt the whole drain). `simplicio-tasks` Step 3 routes fast-path/heavy-path on top of this.
 
+## Phase 0 — intake & decomposition (no source / vague goal / genesis)
+
+When the goal is vague and no external source (board/issues) supplies items, the LLM brainstorms
+the decomposition — subtasks with ≥1 acceptance criterion each, `depends_on`, risks — and MUST
+freeze it BEFORE any edit: `python3 scripts/task_backlog.py init --goal "<goal verbatim>"
+--items-file plan.json` (the worker refuses an empty plan, a zero-AC item, or an unknown/cyclic
+dependency — the AI decides, the worker freezes, orders and gates). State:
+`.orchestrator/backlog/backlog.jsonl`.
+
+**Genesis.** First run `python3 scripts/task_backlog.py genesis --exit-code` — exit 10 means a
+repo with NO code yet. There `init` demands `--genesis` plus exactly one item tagged `scaffold`
+(structure + toolchain + one minimal green test as its ACs); the worker reorders it to T1 and
+makes every other item depend on it. After the scaffold item's gate passes, re-run
+`simplicio-mapper scan . --json` before claiming the next item — the survey only feeds the goal
+once there is something to map.
+
+**Per-item cycle**: `python3 scripts/task_backlog.py next` claims one item (re-prints the one in
+flight) and prints the ready `task_anchor.py set` arming command → work it under the normal
+converge contract → `python3 scripts/task_backlog.py done --id T1` (exit 12 unless the ARMED
+anchor is this item with every AC verified) → `next` again; exactly `empty` = drained.
+
 ## HRM-style hierarchical planner (two-level reasoning loop)
 
 Inspired by the **Hierarchical Reasoning Model** (arXiv:2506.21734, JesseBrown1980/HRM), the loop

{simplicio_loop-3.22.6/simplicio_loop/_bundle/skills/simplicio-tasks → simplicio_loop-3.23.0/simplicio_loop/_bundle/skills/simplicio-loop}/references/extension-points.md

@@ -12,7 +12,7 @@ fallback with standard tools. The skill depends on the ABSTRACTION, never on a s
 | `normalize` | Work-item → canonical schema | LLM maps fields by hand |
 | `deterministic_edit` | Mechanical file writer (zero-token apply of a decided change) | LLM applies edit with file tool |
 | `autoscale` | Safe fleet size from machine profile | formula in orchestration.md |
-| `plan` / `decide` | Plan / decision support | LLM reasons it out |
+| `plan` / `decide` | Plan / decision support. Runnable freeze: a vague goal's LLM decomposition (subtasks, per-item ACs, `depends_on`) is frozen, ordered and gated by `scripts/task_backlog.py init` — genesis-aware (an empty repo demands `--genesis` and a leading `scaffold` item) | LLM reasons it out |
 | `execute` | Local agent fan-out for mass/mechanical work | LLM does it or spawns host sub-agents |
 | `issue_factory` | Full orchestrator loop: discover→claim→implement→PR | manual pipeline (Steps 2–6) |
 | `claim` | Atomic claim on a work-item (cross-session safe) | `gh label "in-progress"` + lockfile |
@@ -31,10 +31,10 @@ fallback with standard tools. The skill depends on the ABSTRACTION, never on a s
 | `retry` | Classified retry+backoff by failure class | manual retry loop |
 | `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. 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 |
+| `intake` | Ingest work from sprint/board link — or, with no board, the local backlog (`task_backlog.py next`) | `gh issue list` |
+| `dependency_graph` | Inter-item ordering as a resumable DAG (B after A; independents fan out); re-run skips done nodes (at item level, the frozen backlog's `depends_on` — `scripts/task_backlog.py` — IS this DAG for Phase 0 decompositions). 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 |
+| `work_queue` | Durable priority queue that runs+auto-retries+requeues-stuck, with a write-serialization lock for shared checkouts. Local binding: `scripts/task_backlog.py` — `next` honors `depends_on` and re-prints the one claimed item; `done` is exit-12-gated on the verified task anchor; `skip` quarantines with a reason; an exact `empty` print is the drain dry signal | 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. 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` |
@@ -92,6 +92,7 @@ state file" bug class (the 685600b spindle/latch mismatch; the HANDOFF.md three-
 | `anchor.json` | `scripts/task_anchor.py set`/`mark` (agent-invoked, once per item + per AC) | `hooks/loop_stop.py` (`anchor_pending()`, drift/AC gate), `scripts/watcher_verify.py` (independent recompute) | Frozen at intake; re-`set` with an unchanged goal preserves progress, a changed goal requires `--force`. |
 | `journal.jsonl` | `scripts/loop_journal.py record` (agent-invoked); `hooks/loop_stop.py` (`auto_record_journal`, a minimal fallback record only when the agent didn't record one this turn) | `scripts/hierarchical_planner.py` (phase timing/stall), `hooks/loop_stop.py` (journal tail in `write_handoff`) | Append-only. The fallback record uses `gate: blocked` (never `fail`) so it can never itself trigger stall detection — it is a presence signal, not attempt memory. |
 | `phase.json` | `scripts/hierarchical_planner.py plan` | `hooks/loop_stop.py` (re-feed header hint) | Re-planned every `DEFAULT_PLAN_INTERVAL` iterations or on stall. |
+| `backlog.jsonl` (`.orchestrator/backlog/`) | `scripts/task_backlog.py` (`init` freezes; `next`/`done`/`skip` transition item states — agent-invoked) | the Phase 0 per-item cycle (SKILL.md § Phase 0), drain-mode dry detection (an exact `empty` from `next`) | Frozen at Phase 0 intake; re-`init` with the same master goal preserves per-item progress, a changed goal requires `--force`; `done` only closes an item whose armed anchor gate passed. |
 
 If a machine has no `.claude/skills/simplicio-loop/SKILL.md` (a bare `simplicio-tasks` loop with
 no `simplicio-loop` companion), none of the watcher/anchor/journal producers are expected to run —

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/simplicio_loop/_bundle/skills/simplicio-loop/references/orchestration.md

@@ -11,6 +11,7 @@ and authed, then use it. Never claim a source works without a live connector.
 | Trello / Azure DevOps | host connector, else the `az boards` adapter (`scripts/az_boards_adapter.py`, see `azure-devops-adapter.md`) |
 | agentsview sessions | `scripts/agentsview_adapter.py` (see `agentsview-adapter.md`) | session observability, recovery of stalled sessions |
 | local files / CI queue | filesystem / CI API |
+| vague goal / no reachable board | the LOCAL BACKLOG — `scripts/task_backlog.py` (the frozen LLM decomposition, `.orchestrator/backlog/`; SKILL.md § Phase 0) |
 
 If the target source has no reachable adapter, STOP and report it as a blocker (do not silently
 fall back to GitHub). Each adapter exposes: list_ready (metadata-only), get_details, claim,
@@ -30,7 +31,10 @@ Triage is metadata-only; implementation is NOT. An agent that skips this produce
 assignees, milestone, acceptance_criteria, comments, linked_prs, linked_items.
 - Extract explicit **acceptance criteria** (numbered, checklists, "done when…"). If none stated,
   derive + record them. An item that obviously should have ACs but has none is a BLOCKER — ask
-  ONE line, don't guess.
+  ONE line, don't guess. With a VAGUE goal and no source at all, decompose first (brainstorm the
+  subtasks + per-item ACs + `depends_on`) and freeze the plan with `python3
+  scripts/task_backlog.py init --goal "<goal>" --items-file plan.json` (SKILL.md § Phase 0); a
+  GENESIS repo (`task_backlog.py genesis --exit-code` exits 10) leads with the `scaffold` item.
 - Extract design decisions/constraints/rejections from comments ("don't use X", "must integrate
   with Y", reviewer requests) — these override naive title reading.
 - Note linked items/PRs and check status — a blocked dependency is flagged, not ignored.

{simplicio_loop-3.22.6/simplicio_loop/_bundle/skills/simplicio-loop → simplicio_loop-3.23.0/simplicio_loop/_bundle/skills/simplicio-tasks}/references/extension-points.md

@@ -12,7 +12,7 @@ fallback with standard tools. The skill depends on the ABSTRACTION, never on a s
 | `normalize` | Work-item → canonical schema | LLM maps fields by hand |
 | `deterministic_edit` | Mechanical file writer (zero-token apply of a decided change) | LLM applies edit with file tool |
 | `autoscale` | Safe fleet size from machine profile | formula in orchestration.md |
-| `plan` / `decide` | Plan / decision support | LLM reasons it out |
+| `plan` / `decide` | Plan / decision support. Runnable freeze: a vague goal's LLM decomposition (subtasks, per-item ACs, `depends_on`) is frozen, ordered and gated by `scripts/task_backlog.py init` — genesis-aware (an empty repo demands `--genesis` and a leading `scaffold` item) | LLM reasons it out |
 | `execute` | Local agent fan-out for mass/mechanical work | LLM does it or spawns host sub-agents |
 | `issue_factory` | Full orchestrator loop: discover→claim→implement→PR | manual pipeline (Steps 2–6) |
 | `claim` | Atomic claim on a work-item (cross-session safe) | `gh label "in-progress"` + lockfile |
@@ -31,10 +31,10 @@ fallback with standard tools. The skill depends on the ABSTRACTION, never on a s
 | `retry` | Classified retry+backoff by failure class | manual retry loop |
 | `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. 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 |
+| `intake` | Ingest work from sprint/board link — or, with no board, the local backlog (`task_backlog.py next`) | `gh issue list` |
+| `dependency_graph` | Inter-item ordering as a resumable DAG (B after A; independents fan out); re-run skips done nodes (at item level, the frozen backlog's `depends_on` — `scripts/task_backlog.py` — IS this DAG for Phase 0 decompositions). 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 |
+| `work_queue` | Durable priority queue that runs+auto-retries+requeues-stuck, with a write-serialization lock for shared checkouts. Local binding: `scripts/task_backlog.py` — `next` honors `depends_on` and re-prints the one claimed item; `done` is exit-12-gated on the verified task anchor; `skip` quarantines with a reason; an exact `empty` print is the drain dry signal | 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. 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` |
@@ -92,6 +92,7 @@ state file" bug class (the 685600b spindle/latch mismatch; the HANDOFF.md three-
 | `anchor.json` | `scripts/task_anchor.py set`/`mark` (agent-invoked, once per item + per AC) | `hooks/loop_stop.py` (`anchor_pending()`, drift/AC gate), `scripts/watcher_verify.py` (independent recompute) | Frozen at intake; re-`set` with an unchanged goal preserves progress, a changed goal requires `--force`. |
 | `journal.jsonl` | `scripts/loop_journal.py record` (agent-invoked); `hooks/loop_stop.py` (`auto_record_journal`, a minimal fallback record only when the agent didn't record one this turn) | `scripts/hierarchical_planner.py` (phase timing/stall), `hooks/loop_stop.py` (journal tail in `write_handoff`) | Append-only. The fallback record uses `gate: blocked` (never `fail`) so it can never itself trigger stall detection — it is a presence signal, not attempt memory. |
 | `phase.json` | `scripts/hierarchical_planner.py plan` | `hooks/loop_stop.py` (re-feed header hint) | Re-planned every `DEFAULT_PLAN_INTERVAL` iterations or on stall. |
+| `backlog.jsonl` (`.orchestrator/backlog/`) | `scripts/task_backlog.py` (`init` freezes; `next`/`done`/`skip` transition item states — agent-invoked) | the Phase 0 per-item cycle (SKILL.md § Phase 0), drain-mode dry detection (an exact `empty` from `next`) | Frozen at Phase 0 intake; re-`init` with the same master goal preserves per-item progress, a changed goal requires `--force`; `done` only closes an item whose armed anchor gate passed. |
 
 If a machine has no `.claude/skills/simplicio-loop/SKILL.md` (a bare `simplicio-tasks` loop with
 no `simplicio-loop` companion), none of the watcher/anchor/journal producers are expected to run —

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/simplicio_loop/_bundle/skills/simplicio-tasks/references/orchestration.md

@@ -11,6 +11,7 @@ and authed, then use it. Never claim a source works without a live connector.
 | Trello / Azure DevOps | host connector, else the `az boards` adapter (`scripts/az_boards_adapter.py`, see `azure-devops-adapter.md`) |
 | agentsview sessions | `scripts/agentsview_adapter.py` (see `agentsview-adapter.md`) | session observability, recovery of stalled sessions |
 | local files / CI queue | filesystem / CI API |
+| vague goal / no reachable board | the LOCAL BACKLOG — `scripts/task_backlog.py` (the frozen LLM decomposition, `.orchestrator/backlog/`; SKILL.md § Phase 0) |
 
 If the target source has no reachable adapter, STOP and report it as a blocker (do not silently
 fall back to GitHub). Each adapter exposes: list_ready (metadata-only), get_details, claim,
@@ -30,7 +31,10 @@ Triage is metadata-only; implementation is NOT. An agent that skips this produce
 assignees, milestone, acceptance_criteria, comments, linked_prs, linked_items.
 - Extract explicit **acceptance criteria** (numbered, checklists, "done when…"). If none stated,
   derive + record them. An item that obviously should have ACs but has none is a BLOCKER — ask
-  ONE line, don't guess.
+  ONE line, don't guess. With a VAGUE goal and no source at all, decompose first (brainstorm the
+  subtasks + per-item ACs + `depends_on`) and freeze the plan with `python3
+  scripts/task_backlog.py init --goal "<goal>" --items-file plan.json` (SKILL.md § Phase 0); a
+  GENESIS repo (`task_backlog.py genesis --exit-code` exits 10) leads with the `scaffold` item.
 - Extract design decisions/constraints/rejections from comments ("don't use X", "must integrate
   with Y", reviewer requests) — these override naive title reading.
 - Note linked items/PRs and check status — a blocked dependency is flagged, not ignored.

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0/simplicio_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.22.6
+Version: 3.23.0
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -20,7 +20,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: simplicio-mapper>=0.17.0
-Requires-Dist: simplicio-cli>=0.9.5
+Requires-Dist: simplicio-cli>=0.9.6
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Provides-Extra: ml

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/simplicio_loop.egg-info/SOURCES.txt

@@ -90,6 +90,7 @@ tests/test_repo_conventions_architecture.py
 tests/test_schema_verify_integration.py
 tests/test_schema_verify_unit.py
 tests/test_system_check.py
+tests/test_task_backlog.py
 tests/test_token_budget.py
 tests/test_toon_codec.py
 tests/test_verify_adapters_integration.py

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/simplicio_loop.egg-info/requires.txt

@@ -1,5 +1,5 @@
 simplicio-mapper>=0.17.0
-simplicio-cli>=0.9.5
+simplicio-cli>=0.9.6
 
 [dev]
 pytest>=7

simplicio_loop-3.23.0/tests/test_task_backlog.py

@@ -0,0 +1,225 @@
+"""End-to-end tests for `scripts/task_backlog.py` — the frozen multi-item decomposition ABOVE the
+per-item task anchor (Phase 0):
+
+  * `init` is fail-closed: no items / zero-AC item refused; a GENESIS (no-code) repo refuses a
+    plan without `--genesis`, and with it forces the scaffold item to lead.
+  * `genesis --exit-code` is the deterministic greenfield detector (exit 10).
+  * `next` honors `depends_on`, re-prints the claimed item (one in flight), and prints exactly
+    `empty` when everything drained (the drain-mode dry signal).
+  * `done` is GATED on the real anchor: it refuses (exit 12) with no anchor, with another item's
+    anchor, or with pending ACs — and passes only after a real `task_anchor.py set` + `mark`.
+
+Every test isolates state via SIMPLICIO_BACKLOG_FILE / SIMPLICIO_ANCHOR_FILE into a tmp dir and
+pins the genesis detector with --root.
+"""
+import json
+import os
+import subprocess
+import sys
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def _env(tmp_path):
+    return dict(os.environ,
+                SIMPLICIO_BACKLOG_FILE=str(tmp_path / "backlog.jsonl"),
+                SIMPLICIO_ANCHOR_FILE=str(tmp_path / "anchor.json"))
+
+
+def _run(script, args, env):
+    return subprocess.run([sys.executable, os.path.join(REPO, "scripts", script)] + args,
+                          capture_output=True, text=True, cwd=REPO, env=env)
+
+
+def _backlog(args, env):
+    return _run("task_backlog.py", args, env)
+
+
+def _anchor(args, env):
+    return _run("task_anchor.py", args, env)
+
+
+def _plan(tmp_path, items, name="plan.json"):
+    p = tmp_path / name
+    p.write_text(json.dumps(items), encoding="utf-8")
+    return str(p)
+
+
+def _code_root(tmp_path):
+    """A --root that is NOT genesis (has one code file)."""
+    root = tmp_path / "coderoot"
+    root.mkdir(exist_ok=True)
+    (root / "app.py").write_text("print('x')\n", encoding="utf-8")
+    return str(root)
+
+
+def _drive_anchor_done(goal, acs, env):
+    """Arm the real anchor for one item and verify every AC — the flow `next` prescribes."""
+    s = _anchor(["set", "--goal", goal, "--force"] + sum([["--ac", a] for a in acs], []), env)
+    assert s.returncode == 0, s.stdout + s.stderr
+    for i in range(len(acs)):
+        m = _anchor(["mark", "--id", "AC%d" % (i + 1), "--status", "done",
+                     "--evidence", "receipt-%d" % (i + 1)], env)
+        assert m.returncode == 0, m.stdout + m.stderr
+
+
+def test_init_refuses_zero_ac_and_empty(tmp_path):
+    env = _env(tmp_path)
+    root = _code_root(tmp_path)
+    r = _backlog(["init", "--goal", "g", "--root", root,
+                  "--items-file", _plan(tmp_path, [])], env)
+    assert r.returncode == 2, "empty plan must refuse (2), got %d:\n%s" % (r.returncode, r.stdout)
+    r = _backlog(["init", "--goal", "g", "--root", root,
+                  "--items-file", _plan(tmp_path, [{"goal": "x", "acs": []}])], env)
+    assert r.returncode == 2, "zero-AC item must refuse (2), got %d:\n%s" % (r.returncode, r.stdout)
+    assert "acceptance criteria" in r.stdout, r.stdout
+
+
+def test_genesis_enforcement_and_scaffold_reorder(tmp_path):
+    env = _env(tmp_path)
+    empty = tmp_path / "empty"
+    empty.mkdir()
+    plan = [{"goal": "add the endpoint", "acs": ["endpoint responds"]},
+            {"goal": "bootstrap the project", "acs": ["structure exists", "one test green"],
+             "tags": ["scaffold"]},
+            {"goal": "add the docs page", "acs": ["page renders"]}]
+    # a genesis repo without --genesis is BLOCKED (12)
+    r = _backlog(["init", "--goal", "greenfield app", "--root", str(empty),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 12, "expected BLOCKED 12, got %d:\n%s" % (r.returncode, r.stdout)
+    assert "genesis" in r.stdout.lower(), r.stdout
+    # --genesis without a scaffold-tagged item refuses (2)
+    r = _backlog(["init", "--goal", "greenfield app", "--genesis", "--root", str(empty),
+                  "--items-file", _plan(tmp_path, [{"goal": "x", "acs": ["a"]}])], env)
+    assert r.returncode == 2, r.stdout
+    assert "scaffold" in r.stdout, r.stdout
+    # --genesis with the scaffold given NOT first: freezes AND auto-orders it to T1
+    r = _backlog(["init", "--goal", "greenfield app", "--genesis", "--root", str(empty),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    n = _backlog(["next", "--json"], env)
+    assert n.returncode == 0, n.stdout + n.stderr
+    got = json.loads(n.stdout)
+    assert got["id"] == "T1" and got["goal"] == "bootstrap the project", n.stdout
+    assert "task_anchor.py set" in got["arm"], n.stdout
+
+
+def test_genesis_exit_code(tmp_path):
+    env = _env(tmp_path)
+    empty = tmp_path / "empty"
+    empty.mkdir()
+    r = _backlog(["genesis", "--root", str(empty), "--exit-code"], env)
+    assert r.returncode == 10, "expected genesis exit 10, got %d:\n%s" % (r.returncode, r.stdout)
+    assert "genesis" in r.stdout, r.stdout
+    (empty / "main.py").write_text("pass\n", encoding="utf-8")
+    r = _backlog(["genesis", "--root", str(empty), "--exit-code"], env)
+    assert r.returncode == 0, "one .py must clear genesis, got %d:\n%s" % (r.returncode, r.stdout)
+    assert "code" in r.stdout, r.stdout
+
+
+def test_next_honors_depends_on_and_reprints_claimed(tmp_path):
+    env = _env(tmp_path)
+    plan = [{"id": "T1", "goal": "first thing", "acs": ["a1"]},
+            {"id": "T2", "goal": "second thing", "acs": ["a2"], "depends_on": ["T1"]}]
+    r = _backlog(["init", "--goal", "two steps", "--root", _code_root(tmp_path),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    first = json.loads(_backlog(["next", "--json"], env).stdout)
+    assert first["id"] == "T1", first
+    again = json.loads(_backlog(["next", "--json"], env).stdout)
+    assert again["id"] == "T1" and again["verdict"] == "claimed", again  # one in flight
+    _drive_anchor_done("first thing", ["a1"], env)
+    d = _backlog(["done", "--id", "T1"], env)
+    assert d.returncode == 0, d.stdout + d.stderr
+    nxt = json.loads(_backlog(["next", "--json"], env).stdout)
+    assert nxt["id"] == "T2", "depends_on not honored:\n%s" % nxt
+
+
+def test_done_is_gated_on_the_real_anchor(tmp_path):
+    env = _env(tmp_path)
+    plan = [{"goal": "item one", "acs": ["ac one", "ac two"]},
+            {"goal": "item two", "acs": ["other ac"]}]
+    r = _backlog(["init", "--goal", "gated", "--root", _code_root(tmp_path),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    # no anchor armed at all -> BLOCKED 12
+    d = _backlog(["done", "--id", "T1"], env)
+    assert d.returncode == 12, "no-anchor done must block (12), got %d:\n%s" % (d.returncode, d.stdout)
+    assert "blocked" in d.stdout.lower(), d.stdout
+    # anchor armed for ANOTHER item's goal -> BLOCKED 12 (wrong fingerprint)
+    _drive_anchor_done("item two", ["other ac"], env)
+    d = _backlog(["done", "--id", "T1"], env)
+    assert d.returncode == 12, "wrong-fp done must block (12), got %d:\n%s" % (d.returncode, d.stdout)
+    # anchor armed for THIS item but ACs still pending -> BLOCKED 12
+    s = _anchor(["set", "--goal", "item one", "--force",
+                 "--ac", "ac one", "--ac", "ac two"], env)
+    assert s.returncode == 0, s.stdout + s.stderr
+    d = _backlog(["done", "--id", "T1"], env)
+    assert d.returncode == 12, "pending-AC done must block (12), got %d:\n%s" % (d.returncode, d.stdout)
+    # every AC verified on the real anchor -> done, evidence copied
+    _drive_anchor_done("item one", ["ac one", "ac two"], env)
+    d = _backlog(["done", "--id", "T1"], env)
+    assert d.returncode == 0, d.stdout + d.stderr
+    st = _backlog(["status"], env)
+    assert "[done   ] T1" in st.stdout, st.stdout
+
+
+def test_drain_dry_prints_exactly_empty(tmp_path):
+    env = _env(tmp_path)
+    plan = [{"goal": "only item", "acs": ["one ac"]},
+            {"goal": "doomed item", "acs": ["never"]}]
+    r = _backlog(["init", "--goal", "drain me", "--root", _code_root(tmp_path),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    _backlog(["next"], env)
+    _drive_anchor_done("only item", ["one ac"], env)
+    assert _backlog(["done", "--id", "T1"], env).returncode == 0
+    sk = _backlog(["skip", "--id", "T2"], env)
+    assert sk.returncode == 2, "skip without --reason must refuse (2):\n%s" % sk.stdout
+    assert _backlog(["skip", "--id", "T2", "--reason", "out of scope"], env).returncode == 0
+    n = _backlog(["next"], env)
+    assert n.returncode == 0, n.stdout + n.stderr
+    assert n.stdout.strip() == "empty", "dry signal must be exactly 'empty':\n%r" % n.stdout
+
+
+def test_check_drift_and_idempotent_reinit(tmp_path):
+    env = _env(tmp_path)
+    plan = [{"goal": "stable item", "acs": ["an ac"]}]
+    r = _backlog(["init", "--goal", "the frozen goal", "--root", _code_root(tmp_path),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    d = _backlog(["check", "--goal", "a totally different goal", "--exit-code"], env)
+    assert d.returncode == 11, "expected DRIFT 11, got %d:\n%s" % (d.returncode, d.stdout)
+    assert "DRIFT" in d.stdout, d.stdout
+    ok = _backlog(["check", "--goal", "the frozen goal", "--exit-code"], env)
+    assert ok.returncode == 0, ok.stdout
+    assert "BACKLOG_OK" in ok.stdout, ok.stdout
+    # progress, then re-init the SAME goal: idempotent, done state preserved
+    _backlog(["next"], env)
+    _drive_anchor_done("stable item", ["an ac"], env)
+    assert _backlog(["done", "--id", "T1"], env).returncode == 0
+    r = _backlog(["init", "--goal", "the frozen goal", "--root", _code_root(tmp_path),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    st = _backlog(["status"], env)
+    assert "[done   ] T1" in st.stdout, "re-init lost progress:\n%s" % st.stdout
+    # a CHANGED goal without --force is BLOCKED 12
+    r = _backlog(["init", "--goal", "a swapped goal", "--root", _code_root(tmp_path),
+                  "--items-file", _plan(tmp_path, plan)], env)
+    assert r.returncode == 12, "goal swap without --force must block (12):\n%s" % r.stdout
+
+
+def test_selftest_and_unknown_verb(tmp_path):
+    env = _env(tmp_path)
+    r = _backlog(["selftest"], env)
+    assert r.returncode == 0, r.stdout + r.stderr
+    assert "PASS" in r.stdout, r.stdout
+    r = _backlog(["definitely-not-a-real-verb-xyz"], env)
+    assert r.returncode == 2, r.stdout
+    assert "Traceback" not in r.stderr, "unknown verb crashed:\n%s" % r.stderr
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from _selfrun import run_module
+    run_module(globals(), "test_task_backlog")

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/tests/test_worker_cli_contract.py

@@ -19,6 +19,7 @@ WORKERS_WITH_SELFTEST = [
     "loop_journal.py",
     "billing_aggregator.py",
     "task_anchor.py",
+    "task_backlog.py",
     "pr_evidence.py",
     "flow_audit.py",
     "impact_audit.py",

{simplicio_loop-3.22.6 → simplicio_loop-3.23.0}/tests/test_worker_selftests.py

@@ -16,6 +16,7 @@ SELFTESTS = [
     ("scripts/billing_aggregator.py", "selftest"),
     ("scripts/savings_harness.py", "selftest"),
     ("scripts/task_anchor.py", "selftest"),
+    ("scripts/task_backlog.py", "selftest"),
     ("scripts/pr_evidence.py", "selftest"),
     ("scripts/flow_audit.py", "selftest"),
     ("scripts/impact_audit.py", "selftest"),
@@ -54,6 +55,12 @@ def test_task_anchor_selftest():
     assert "PASS" in r.stdout, r.stdout
 
 
+def test_task_backlog_selftest():
+    r = _run("scripts/task_backlog.py", "selftest")
+    assert r.returncode == 0, "task_backlog 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)