simplicio-loop 3.43.9__tar.gz → 3.43.11__tar.gz

{simplicio_loop-3.43.9/simplicio_loop.egg-info → simplicio_loop-3.43.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.43.9
+Version: 3.43.11
 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-Expression: MIT
@@ -21,9 +21,9 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: simplicio-cli<0.19,>=0.18.12
-Requires-Dist: simplicio-mapper<0.27,>=0.26.29
-Requires-Dist: simplicio-fast<3,>=2.0.31
+Requires-Dist: simplicio-cli<0.19,>=0.18.13
+Requires-Dist: simplicio-mapper<0.27,>=0.26.31
+Requires-Dist: simplicio-fast<3,>=2.0.33
 Requires-Dist: simplicio-prompt<1.15,>=1.14.4
 Requires-Dist: tiktoken<1,>=0.12.0
 Provides-Extra: dev

{simplicio_loop-3.43.9 → simplicio_loop-3.43.11}/README.md

@@ -812,6 +812,143 @@ exit 0) when `gh`/network is unavailable, so an offline dev environment never lo
 `update.sh` stashes local edits, fast-forwards `main`, reinstalls from the fresh source, restarts the
 launchd/systemd services so they run the new code, and prints the live stack + savings.
 
+## 🧭 CLI command map — what each command does
+
+### Required Mapper context and automatic machine capacity
+
+Every Loop execution workflow requires **Simplicio Mapper**, including standalone,
+sequential, Prism/wave and Fast-assisted execution. Prepare context centrally and
+bind workers to its current generation and digest. Fast is an optional accelerator;
+Runtime remains optional for ordinary orchestration. Missing or stale Mapper
+context blocks work until central preparation succeeds.
+
+The intended worker default is automatic physical admission from available machine
+capacity, preserving foreground responsiveness. The source changes remove fixed
+defaults in batch/tasks/fan-out entrypoints; validation is still in progress and
+these edits are not part of the installed 3.43.10 release yet.
+
+Mapper context reuse does not itself prove a provider cache hit. Report token and
+cost savings only from attributable provider usage and passing quality gates.
+The fastest/cheapest production route is **not yet established**. See the
+[ten-task benchmark protocol, command sequence and evidence status](docs/QUEUE_BENCHMARK_PROTOCOL.md)
+before using historical synthetic scheduler measurements as a recommendation.
+
+The main `simplicio-loop` entry point is the user-facing control surface for planning, executing, verifying, and delivering work. Use the most specific `--help` for the exact options available in the installed version.
+
+**Standalone by design.** Runtime is optional: without it, Loop uses its own scheduler/hooks plus the Mapper, Fast, and Dev CLI operators. When Runtime is available, it adds governed activation, physical admission, gates, receipts, and reconciliation; it does not replace the Loop.
+
+### Zero-config execution
+
+The normal start path requires only the task and repository scope:
+
+```bash
+simplicio-loop run --task task.md --repo .
+```
+
+Loop initializes the Mapper-owned operations store when needed, runs the required
+Mapper handoff, reconciles one normal cold-start inspection internally when the index is
+still warming, derives worker demand from the task set, and lets physical CPU/RAM/disk
+admission choose the safe concurrency. For an existing run, `simplicio-loop batch RUN_ID`
+applies the same defaults; `--serial` is reserved for explicit dependency or conflict
+cases. Missing Mapper receipts, stale plans, invalid targets, failed workers, or unsafe
+machine pressure remain visible stop conditions and are never silently bypassed.
+
+> **At a glance:** `plan` creates a frozen task contract → `run` executes it with bounded iterations → `verify` checks the evidence independently → `deliver` reconciles the result with the source of record.
+
+| Area | Commands | What they do |
+|---|---|---|
+| Install and utilities | `install`, `dashboard`, `learn` | Install the bundled skills/hooks; open or stop the token-monitor dashboard; derive and persist a retrospective from completed runs. |
+| Intake and planning | `task`, `prototype`, `plan`, `orient` | Validate/preview task contracts; route prototype planning; compile Markdown into a frozen contract; build bounded Mapper/Fast context and an orientation receipt. |
+| Execution | `run`, `tick`, `batch`, `wave`, `prism`, `single-task-fast` | Arm and execute a task with evidence; execute one planned task through Dev CLI; dispatch ready tasks through bounded isolated workers and reconciled Prism waves; select the local-first route for one task. |
+| Run lifecycle | `status`, `progress`, `resume`, `cancel`, `verify`, `oracle`, `checkpoint` | Inspect a run; render progress as text/JSON/Markdown/ANSI; resume or cancel non-terminal work; run independent watcher/delivery gates; evaluate completion/parity; manage Fast V3 checkpoints. |
+| Repository and operators | `preflight`, `map`, `inspect`, `doctor`, `stack`, `extensions`, `retrieve` | Check Mapper/Dev CLI/Runtime/Fast readiness; inspect map-service receipts; inspect MapperStore capabilities; diagnose stack/source/resource/storage; lock or verify installed components; verify extension handshakes; retrieve tee-cache results. |
+| Queues and coordination | `queue`, `drain`, `agent-slots`, `generation-broker`, `ledger`, `hub-drain-plan`, `hub-drain-admit` | Operate the durable queue; evaluate or persist queue-drain receipts; inspect/reclaim Loop capacity; reconcile generation bindings; replay/validate the operational ledger; plan or admit GitHub drain work. |
+| Delivery and source control | `deliver`, `decide`, `sync-source`, `findings`, `maintenance-deferred`, `defer-maintenance` | Reconcile delivery with source evidence; apply a human decision and invalidate dependent artifacts; requery external source state; list/report/reconcile/diagnose/import findings; record deferred maintenance. `defer-maintenance` is the alias form. |
+| Economy, safety, and deployment | `economy`, `ecc`, `deploy`, `release-train` | Inspect/print/apply the economy-parallel environment; verify ECC provenance and safety policy; plan a gated deployment (`--apply` is explicit); validate release manifests and ecosystem drift. |
+
+### Candidate governed flow for 10 tasks — not yet a measured winner
+
+Ten tasks are above the three-task direct-parallel threshold, so the Loop routes them through a Prism wave: isolated worktrees, leases, a wave barrier, and serialized writes. This wave works in standalone mode; when Runtime is available, Runtime governs activation and physical admission while Prism coordinates the wave.
+
+```bash
+# 1. If using Runtime, ask its activation authority (optional integration)
+simplicio loop decide --task "complete these 10 tasks" --repo . --json
+
+# 2. Inspect the profile before applying environment changes
+# 3.43.11 recommends MCP-required flags; do not apply it blindly in CLI-only mode.
+simplicio-loop economy status --json
+
+# 3. Block until the required operators and strict mutation policy are ready
+simplicio-loop preflight --strict --json
+
+# 4. Survey and enrich context through the bound operators
+simplicio-mapper scan . --sync --json
+simplicio-mapper inspect . --json
+simplicio-mapper handoff . --task-file task.md --execution-context --json
+simplicio-fast understand --repo .
+
+# 5. Arm the drain scratchpad; this does NOT start workers
+# The CLI resolves slots=0 via its machine-capacity recommendation.
+python3 scripts/arm_drain_prism.py --repo . --slots 0 --batch-size 10 --json
+
+# 6. Each task follows claim → implement → focused gate → evidence → PR/merge
+#    The next wave starts only after reconcile-before-next.
+```
+
+Do not interpret ten logical tasks as ten unrestricted processes: physical CPU/RAM/backpressure limits are still enforced, and writes are serialized by path. For only one to three tasks, use direct parallelism instead of Prism.
+
+### Where Prism fits
+
+The public `simplicio-loop prism` and `simplicio-loop wave` commands dispatch through the same governed batch implementation, with typed receipts and a reconcile-before-next barrier. The `simplicio-prism` skill/layer classifies the work and composes Mapper, Fast, Loop, Dev CLI, and Runtime. The concrete drain-wave operator is `scripts/arm_drain_prism.py`; Runtime's `simplicio loop decide` remains the authority for Loop activation.
+
+A wave ends with lease/result reconciliation before the next group is admitted.
+Arming is preparation, not execution. In standalone operation Runtime/MCP is
+optional; Mapper remains mandatory. See the [Prism/wave interface details](docs/CLI_COMMANDS.md#prism-and-wave).
+
+**Measured benchmark status (2026-09-11):** ten simulated tasks pass the independent
+verifier after real OpenRouter proposals and native edits. This is a diagnostic
+composed route, not a completed serial/Prism/Fast comparison. No fastest or
+cheapest standard is proven. The [detailed report](docs/QUEUE_BENCHMARK_PROTOCOL.md)
+records failures, retries, commands, receipts and the remaining qualification gates.
+Open the [charts and measured command tables](.lavish/queue-benchmark-20260911/report.html)
+or the [raw metrics and receipt hashes](.lavish/queue-benchmark-20260911/summary.json).
+
+The [release qualification results](docs/BENCHMARK_RELEASE_QUALIFICATION.md)
+separately record the restarted native CLI probes, exact commands, CPU/RAM,
+and blockers. Failed admission, dry-run, and time-to-failure never qualify as
+completed tasks or a performance winner.
+
+Important nested command surfaces:
+
+- `queue`: `status`, `top`, `drain`, `resume`, `doctor`, `reclaim`, `migrate`, `gc`, `inspect`, `cancel`.
+- `findings`: `list`, `report`, `reconcile`, `doctor`, `import`.
+- `economy`: `status`, `print`, `apply`.
+- `stack`: `lock`, `verify`; `extensions` and `ecc` each expose `doctor`.
+- `release-train`: `check` validates component/ecosystem release schemas and local drift.
+
+Typical single-task commands:
+
+```bash
+simplicio-loop preflight --repo . --json
+simplicio-loop orient --task "understand this repository" --repo .
+simplicio-loop plan --task task.md --out contract.json
+simplicio-loop run --task task.md --repo . --max-iterations 5
+simplicio-loop status --repo . --text
+simplicio-loop progress --repo . --format markdown --once
+simplicio-loop queue status
+simplicio-loop verify <run_id>
+```
+
+The complete command reference is [`docs/CLI_COMMANDS.md`](docs/CLI_COMMANDS.md). The command surface can vary by installed package version, so check `simplicio-loop --version` and `simplicio-loop --help`; the current repository source is `3.43.11`.
+
+The restarted comparison includes `run`, `batch`, `batch --serial`, `tasks run`,
+Prism, wave-policy variations and a limited semaphore control. See the
+[flow matrix and mandatory Mapper/cache contract](docs/BENCHMARK_FLOW_MATRIX.md).
+The limited control is not a public legacy command; `tasks run` currently has
+a PR/merge delivery boundary and cannot be ranked against local edits alone.
+
+---
+
 ### Doctor — verify + repair
 
 ```bash

{simplicio_loop-3.43.9 → simplicio_loop-3.43.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.43.9"
+version = "3.43.11"
 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.11"
@@ -31,9 +31,9 @@ classifiers = [
 # closure.
 dependencies = [
   # Loop is the aggregate distribution. Keep one tested component train.
-  "simplicio-cli>=0.18.12,<0.19",
-  "simplicio-mapper>=0.26.29,<0.27",
-  "simplicio-fast>=2.0.31,<3",
+  "simplicio-cli>=0.18.13,<0.19",
+  "simplicio-mapper>=0.26.31,<0.27",
+  "simplicio-fast>=2.0.33,<3",
   "simplicio-prompt>=1.14.4,<1.15",
   "tiktoken>=0.12.0,<1",
 ]
@@ -53,6 +53,7 @@ Repository = "https://github.com/wesleysimplicio/simplicio-loop"
 Issues = "https://github.com/wesleysimplicio/simplicio-loop/issues"
 
 [project.scripts]
+simplicio = "simplicio_loop.savings_cli:main"
 simplicio-loop = "simplicio_loop.cli:main"
 issue-factory = "simplicio_loop.issue_factory_cli:main"
 simplicio-ecosystem-doctor = "simplicio_loop.ecosystem_doctor:main"

{simplicio_loop-3.43.9 → simplicio_loop-3.43.11}/simplicio_loop/__init__.py

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

{simplicio_loop-3.43.9 → simplicio_loop-3.43.11}/simplicio_loop/_bundle/hooks/hooks.claude.json

@@ -15,6 +15,13 @@
           { "type": "command", "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/hooks/orient_rewrite.py\"" }
         ]
       }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          { "type": "command", "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/hooks/user_prompt_submit.py\"" }
+        ]
+      }
     ]
   }
 }

simplicio_loop-3.43.11/simplicio_loop/_bundle/hooks/user_prompt_submit.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Run the canonical Claude adapter for UserPromptSubmit."""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+
+def _repo_root() -> Path:
+    current = Path(__file__).resolve()
+    for candidate in (current, *current.parents):
+        if (candidate / "adapters" / "claude" / "adapter.py").is_file():
+            return candidate
+    return current.parents[1]
+
+
+ROOT = _repo_root()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from adapters.claude.adapter import decide  # noqa: E402
+
+
+def main() -> int:
+    try:
+        event = json.loads(sys.stdin.read() or "{}")
+    except json.JSONDecodeError:
+        event = {}
+    event.setdefault("hook_event_name", "UserPromptSubmit")
+    decision = decide(event)
+    print(json.dumps(decision, ensure_ascii=False))
+    return 0 if decision.get("decision") != "block" else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{simplicio_loop-3.43.9 → simplicio_loop-3.43.11}/simplicio_loop/cli_impl.py

@@ -14,7 +14,7 @@ import tempfile
 import time
 import webbrowser
 from pathlib import Path
-from typing import Any, Mapping, Optional
+from typing import Any, Mapping, Optional, Sequence
 try:
     from scripts import release_manifest as _release_manifest
 except Exception:  # pragma: no cover - import shim for bundled scripts
@@ -86,6 +86,7 @@ from . import inspection_cli as _inspection_cli
 from .progress import stream as stream_progress
 from .oracle import evaluate_matrix, persist_completion_receipt
 from .delivery import DELIVERY_ORDER
+from .evidence import redact_sensitive_text
 from .economy_profile import (
     llm_max_speed_orientation_contract,
     prism_batches,
@@ -700,10 +701,127 @@ def resume(repo: str, run_id: str) -> int:
     return 0
 
 
+def _dispatch_failure_payload(schema: str, repo: str, run_id: str, error: Exception,
+                              task_indices: Optional[Sequence[int]] = None) -> dict:
+    payload = {
+        "schema": schema,
+        "status": "blocked",
+        "reason_code": "operator_dispatch_failed",
+        "repo": str(repo),
+        "run_id": str(run_id),
+        "task_indices": list(task_indices or []),
+        "error_type": type(error).__name__,
+        "error": redact_sensitive_text(str(error)),
+    }
+    payload["receipt_hash"] = hashlib.sha256(
+        json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    ).hexdigest()
+    return payload
+
+
+def _dispatch_exit_code(payload: Mapping[str, Any]) -> int:
+    """Return non-zero whenever a dispatch receipt is not a verified success."""
+    if not payload:
+        return 0  # preserve the thin CLI seam used by compatibility callers
+    status = str(payload.get("status") or "").lower()
+    if status in {"blocked", "held", "failed", "cancelled", "error"}:
+        return 2
+    if str(payload.get("phase") or "").lower() in {"blocked", "cancelled"}:
+        return 2
+    if str(payload.get("execution_state") or "").lower() in {"blocked", "uncertain"}:
+        return 2
+    if str(payload.get("action") or "") in {
+        "operator_failed", "operator_batch_blocked", "operator_batch_preflight_blocked",
+    }:
+        return 2
+    if payload.get("failed") or payload.get("blocked") or payload.get("dead_letter") or payload.get("blockers"):
+        return 2
+    admission = payload.get("capacity") or payload.get("admission")
+    if isinstance(admission, Mapping) and admission.get("admitted") is False:
+        return 2
+    workers = payload.get("workers")
+    if isinstance(workers, list) and any(
+        not isinstance(worker, Mapping) or worker.get("status") not in {"succeeded", "completed"}
+        for worker in workers
+    ):
+        return 2
+    if payload.get("requested_tasks") and isinstance(workers, list) and not workers:
+        return 2
+    return 0
+
+
+def _reconcile_prism_wave(task_indices: Sequence[int], result: Mapping[str, Any]) -> dict:
+    requested = [int(index) for index in task_indices]
+    requested_set = set(requested)
+    workers = result.get("workers") if isinstance(result, Mapping) else None
+    workers = workers if isinstance(workers, list) else []
+    completed = {
+        int(index) for index in (result.get("completed_tasks") or [])
+        if isinstance(index, (int, str)) and str(index).lstrip("-").isdigit()
+    } if isinstance(result, Mapping) else set()
+    worker_by_task = {}
+    failed = []
+    for worker in workers:
+        if not isinstance(worker, Mapping):
+            failed.append(None)
+            continue
+        try:
+            task_index = int(worker.get("task_index"))
+        except (TypeError, ValueError):
+            failed.append(None)
+            continue
+        worker_by_task[task_index] = worker
+        if worker.get("status") not in {"succeeded", "completed"}:
+            failed.append(task_index)
+    missing = sorted(requested_set - set(worker_by_task) - completed)
+    if failed:
+        reason_code = "wave_worker_failed"
+    elif missing:
+        reason_code = "wave_receipt_missing"
+    elif not workers and not completed:
+        reason_code = "wave_receipt_invalid"
+    elif isinstance(result, Mapping) and str(result.get("status") or "").lower() not in {"completed", "succeeded", "success"}:
+        reason_code = "wave_not_terminal"
+    else:
+        reason_code = "wave_receipts_reconciled"
+    ok = reason_code == "wave_receipts_reconciled"
+    return {
+        "schema": "simplicio.prism-wave-reconciliation/v1",
+        "status": "reconciled" if ok else "held",
+        "ok": ok,
+        "requested_tasks": requested,
+        "missing": missing,
+        "failed": sorted(index for index in failed if index is not None),
+        "reason_code": reason_code,
+    }
+
+
+def _persist_prism_wave_receipt(repo: str, run_id: str, payload: dict) -> str:
+    try:
+        status = read_status(repo, run_id)
+        run_dir = Path(status["run_dir"])
+        if not run_dir.is_dir():
+            return ""
+        path = run_dir / "prism-wave-dispatch.json"
+        payload["receipt_path"] = str(path)
+        unsigned = dict(payload)
+        unsigned.pop("receipt_hash", None)
+        payload["receipt_hash"] = hashlib.sha256(
+            json.dumps(unsigned, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        ).hexdigest()
+        path.write_text(json.dumps(payload, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
+        return str(path)
+    except (KeyError, OSError, TypeError, ValueError):
+        return ""
+
+
 def tick(repo: str, run_id: str, task_index: int) -> int:
-    payload = execute_operator(repo, run_id, task_index=task_index)
+    try:
+        payload = execute_operator(repo, run_id, task_index=task_index)
+    except Exception as exc:
+        payload = _dispatch_failure_payload("simplicio.tick-receipt/v1", repo, run_id, exc, [task_index])
     print(__import__("json").dumps(payload, ensure_ascii=False, indent=2))
-    return 0
+    return _dispatch_exit_code(payload)
 
 
 def batch(repo: str, run_id: str, task_indices: str, max_workers: int, retry_budget: int,
@@ -727,39 +845,49 @@ def batch(repo: str, run_id: str, task_indices: str, max_workers: int, retry_bud
 
     eligibility = prism_is_eligible(len(indices or []), explicit_serial=serial)
     if not eligibility["eligible"]:
-        payload = execute_operator_batch(
-            repo,
-            run_id,
-            indices,
-            max_workers=max_workers or None,
-            retry_budget=retry_budget,
-            auto_fan_out=not serial,
-        )
+        try:
+            payload = execute_operator_batch(
+                repo,
+                run_id,
+                indices,
+                max_workers=max_workers or None,
+                retry_budget=retry_budget,
+                auto_fan_out=not serial,
+            )
+        except Exception as exc:
+            payload = _dispatch_failure_payload("simplicio.operator-batch-receipt/v1", repo, run_id, exc, indices)
         payload["prism"] = {**eligibility, "batch_size": None, "waves": 1}
         print(json.dumps(payload, ensure_ascii=False, indent=2))
-        return 0
+        return _dispatch_exit_code(payload)
 
     width = resolve_prism_batch_size(batch_size)
     waves = prism_batches(indices, width)
     worker_limit = min(max_workers or width, width)
     wave_results = []
+    all_reconciled = True
     for wave_number, wave in enumerate(waves, start=1):
-        result = execute_operator_batch(
-            repo,
-            run_id,
-            wave,
-            max_workers=worker_limit,
-            retry_budget=retry_budget,
-            auto_fan_out=True,
-        )
-        wave_results.append({"wave": wave_number, "task_indices": wave, "result": result})
+        try:
+            result = execute_operator_batch(
+                repo,
+                run_id,
+                wave,
+                max_workers=worker_limit,
+                retry_budget=retry_budget,
+                auto_fan_out=True,
+            )
+        except Exception as exc:
+            result = _dispatch_failure_payload("simplicio.operator-batch-receipt/v1", repo, run_id, exc, wave)
+        reconciliation = _reconcile_prism_wave(wave, result)
+        wave_results.append({"wave": wave_number, "task_indices": wave, "result": result,
+                             "reconciliation": reconciliation})
+        if not reconciliation["ok"]:
+            all_reconciled = False
+            break
 
     workers = [worker for wave in wave_results for worker in (wave["result"].get("workers") or [])]
     payload = {
         "schema": "simplicio.prism-wave-dispatch/v1",
-        "status": "completed" if all(
-            worker.get("status") == "succeeded" for worker in workers
-        ) else "held",
+        "status": "completed" if all_reconciled and len(wave_results) == len(waves) else "held",
         "prism": {
             **eligibility,
             "batch_size": width,
@@ -770,8 +898,9 @@ def batch(repo: str, run_id: str, task_indices: str, max_workers: int, retry_bud
         "waves": wave_results,
         "workers": workers,
     }
+    _persist_prism_wave_receipt(repo, run_id, payload)
     print(json.dumps(payload, ensure_ascii=False, indent=2))
-    return 0
+    return _dispatch_exit_code(payload)
 
 
 def cancel(repo: str, run_id: str) -> int:
@@ -1397,29 +1526,36 @@ def main(argv=None) -> int:
     p_tick.add_argument("run_id", help="run id to tick")
     p_tick.add_argument("--task-index", type=int, default=1, help="1-based task index")
 
+    def _configure_batch_parser(parser):
+        parser.add_argument("--repo", default=".", help="repository root")
+        parser.add_argument("run_id", help="run id to dispatch")
+        parser.add_argument(
+            "--task-indices",
+            default="",
+            help="comma-separated 1-based task indices (default: every task in the contract)",
+        )
+        parser.add_argument(
+            "--max-workers",
+            type=int,
+            default=0,
+            help="worker demand (default/0: automatic; live CPU/RAM/disk admission governs concurrency; positive values set an explicit ceiling)",
+        )
+        parser.add_argument("--retry-budget", type=int, default=3, help="retries after the first attempt")
+        parser.add_argument(
+            "--batch-size", type=int, default=None,
+            help="Prism wave width (default/minimum: 10; no logical upper bound, e.g. 30)",
+        )
+        parser.add_argument(
+            "--serial", action="store_true",
+            help="disable the default isolated fan-out and force the shared-run serial lane",
+        )
+
     p_batch = sub.add_parser("batch", help="continuously dispatch ready tasks through simplicio-dev-cli")
-    p_batch.add_argument("--repo", default=".", help="repository root")
-    p_batch.add_argument("run_id", help="run id to dispatch")
-    p_batch.add_argument(
-        "--task-indices",
-        default="",
-        help="comma-separated 1-based task indices (default: every task in the contract)",
-    )
-    p_batch.add_argument(
-        "--max-workers",
-        type=int,
-        default=0,
-        help="maximum live operator workers (default: SIMPLICIO_LOOP_OPERATOR_WORKERS/6)",
-    )
-    p_batch.add_argument("--retry-budget", type=int, default=3, help="retries after the first attempt")
-    p_batch.add_argument(
-        "--batch-size", type=int, default=None,
-        help="Prism wave width (default/minimum: 10; no logical upper bound, e.g. 30)",
-    )
-    p_batch.add_argument(
-        "--serial", action="store_true",
-        help="disable the default isolated fan-out and force the shared-run serial lane",
-    )
+    _configure_batch_parser(p_batch)
+    p_wave = sub.add_parser("wave", help="dispatch a governed wave with reconciliation barriers")
+    _configure_batch_parser(p_wave)
+    p_prism = sub.add_parser("prism", help="dispatch work through the governed Prism route")
+    _configure_batch_parser(p_prism)
 
     p_cancel = sub.add_parser("cancel", help="cancel a non-terminal run")
     p_cancel.add_argument("--repo", default=".", help="repository root")
@@ -1709,15 +1845,16 @@ def main(argv=None) -> int:
         return verify(args.repo, args.run_id)
     if command == "progress":
         run_id = args.run_id or args.run_flag
-        if not run_id:
-            parser.error("progress requires a run id (positional or --run)")
+        # An omitted run id means the latest run in --repo, matching the
+        # status command and keeping the public zero-config progress command
+        # useful immediately after `run`.
         return progress(args.repo, run_id, args.fmt, args.once, args.interval,
                         args.no_animation, args.ascii_only)
     if command == "resume":
         return resume(args.repo, args.run_id)
     if command == "tick":
         return tick(args.repo, args.run_id, args.task_index)
-    if command == "batch":
+    if command in {"batch", "wave", "prism"}:
         return batch(args.repo, args.run_id, args.task_indices, args.max_workers, args.retry_budget, args.serial, args.batch_size)
     if command == "cancel":
         return cancel(args.repo, args.run_id)
@@ -1777,7 +1914,7 @@ def main(argv=None) -> int:
             print(json.dumps({"status": "BLOCKED", "reason_code": "invalid_task_file", "error": str(exc)}, sort_keys=True))
             return 2
         print(json.dumps(result, sort_keys=True))
-        return 0 if result["status"] != "BLOCKED" else 2
+        return 0 if result["status"] == "COMPLETED" else 2
     if command == "ledger":
         return ledger_replay(
             args.path,