simplicio-cli 0.18.0__tar.gz → 0.18.3__tar.gz

{simplicio_cli-0.18.0/simplicio_cli.egg-info → simplicio_cli-0.18.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.18.0
+Version: 0.18.3
 Summary: Deterministic task-to-code contract and verification CLI. It never executes or provisions an LLM.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -28,7 +28,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.1.0
-Requires-Dist: simplicio-mapper>=0.26.0
+Requires-Dist: simplicio-mapper>=0.26.2
 Requires-Dist: simplicio-prompt>=1.14.1
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: orjson>=3.11.9
@@ -40,7 +40,7 @@ Requires-Dist: sentence-transformers>=5.6.0; extra == "ml"
 Provides-Extra: bench
 Requires-Dist: fpdf2>=2.8.7; extra == "bench"
 Provides-Extra: fast
-Requires-Dist: simplicio-fast<1,>=0.1; extra == "fast"
+Requires-Dist: simplicio-fast<3,>=2.0.18; extra == "fast"
 Provides-Extra: performance
 Requires-Dist: uvloop>=0.21.0; sys_platform != "win32" and extra == "performance"
 Provides-Extra: all

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.18.0"
+version = "0.18.3"
 description = "Deterministic task-to-code contract and verification CLI. It never executes or provisions an LLM."
 readme = "README.md"
 license = { text = "MIT" }
@@ -45,7 +45,7 @@ classifiers = [
 # (generated, `--check`-able) for the full graph and #99 for the audit.
 dependencies = [
   "numpy>=2.1.0",
-  "simplicio-mapper>=0.26.0",
+  "simplicio-mapper>=0.26.2",
   "simplicio-prompt>=1.14.1",
   "httpx>=0.28.1",
   "orjson>=3.11.9",
@@ -62,7 +62,7 @@ ml = ["sentence-transformers>=5.6.0"]
 bench = ["fpdf2>=2.8.7"]
 # Optional canonical Fast adapter. It remains outside the base install until
 # its release train is formally promoted.
-fast = ["simplicio-fast>=0.1,<1"]
+fast = ["simplicio-fast>=2.0.18,<3"]
 # Opt-in faster asyncio event loop for the structured-concurrency runtime
 # (simplicio.runtime_async, issue #212). Never required: `install_uvloop()`
 # no-ops on Windows or when this extra is absent, falling back to stdlib

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.18.0"
+__version__ = "0.18.3"
 
 from .mapper_api import mapper_module, mapper_version
 

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/checkpoint_store.py

@@ -6,8 +6,9 @@ import hashlib
 import json
 import os
 import shutil
+from collections.abc import Sequence
 from pathlib import Path
-from typing import Any, Sequence
+from typing import Any
 
 
 class CheckpointError(RuntimeError):

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/cli.py

@@ -692,6 +692,7 @@ def _main_unwrapped(argv=None):
 
     # Stage ABI mutations fail closed before verbosity/parser/dispatch can run.
     from .mutation_dispatch import guard_mutable_dispatch
+
     guard_mutable_dispatch(argv)
 
     quiet, verbose, argv = _extract_global_verbosity(argv)
@@ -769,6 +770,7 @@ def main(argv=None):
     """Run legacy commands directly or wrap Stage ABI mutations pre-to-post."""
     args = list(sys.argv[1:] if argv is None else argv)
     from .stage_main import run_stage_or_legacy
+
     return run_stage_or_legacy(args, _main_unwrapped)
 
 

simplicio_cli-0.18.3/simplicio/codex_hooks.py

@@ -0,0 +1,65 @@
+"""Portable Codex hook bridge for the installed Simplicio CLI.
+
+Codex sends hook context as JSON on stdin.  This module deliberately keeps
+the hook observational: malformed input, unsupported events, and detector
+errors never block the host agent.  UserPromptSubmit is the one event with a
+useful side effect: it emits the existing deterministic task hint on stderr.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Any
+
+from .detect import detect
+
+
+def _payload(raw: str) -> dict[str, Any]:
+    if not raw.strip():
+        return {}
+    try:
+        value = json.loads(raw)
+    except (TypeError, ValueError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _event(payload: dict[str, Any]) -> str:
+    value = payload.get("hook_event_name") or payload.get("event") or payload.get("type")
+    return str(value or "").strip().lower()
+
+
+def _prompt(payload: dict[str, Any]) -> str:
+    for key in ("prompt", "user_prompt", "text"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    return ""
+
+
+def main() -> int:
+    if os.environ.get("SIMPLICIO_HOOK_GUARD"):
+        return 0
+
+    payload = _payload(sys.stdin.read())
+    if _event(payload) not in {"userpromptsubmit", "user_prompt_submit"}:
+        return 0
+
+    prompt = _prompt(payload)
+    if not prompt:
+        return 0
+
+    try:
+        result = detect(prompt)
+        if result.is_code_task:
+            sys.stderr.write(f"{result.hint}\n")
+    except Exception:
+        # Hooks must never take down or block the host agent.
+        return 0
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/delivery_auth.py

@@ -2,11 +2,10 @@
 
 from __future__ import annotations
 
-import hashlib
-import json
 import time
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
-from typing import Any, Callable, Mapping, Sequence
+from typing import Any
 
 from simplicio.plan_compiler.canonical_hash import canonical_hash
 

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/effect_transaction.py

@@ -58,8 +58,7 @@ class EffectTransaction:
         with self._db() as database:
             database.execute("BEGIN IMMEDIATE")
             database.execute(
-                "UPDATE transactions SET state=?, receipt=COALESCE(?, receipt) "
-                "WHERE idempotency_key=?",
+                "UPDATE transactions SET state=?, receipt=COALESCE(?, receipt) WHERE idempotency_key=?",
                 (state, encoded, key),
             )
             database.execute(
@@ -82,8 +81,7 @@ class EffectTransaction:
         with self._db() as database:
             database.execute("BEGIN IMMEDIATE")
             row = database.execute(
-                "SELECT change_set_hash,state,receipt FROM transactions "
-                "WHERE idempotency_key=?",
+                "SELECT change_set_hash,state,receipt FROM transactions WHERE idempotency_key=?",
                 (key,),
             ).fetchone()
             if row:

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/execution_mode.py

@@ -236,9 +236,15 @@ def prepare_execution_inputs(
 ) -> PreparedExecutionInputs:
     """Resolve installed-entrypoint inputs without probing in standalone mode."""
     if requested_mode(mode, root) == "standalone":
+        # Standalone still needs to consume an explicitly supplied context pack.
+        # Previously the path arguments were silently ignored in this branch, so
+        # Loop's local degraded context never reached the task precondition gate.
+        resolved_pack = (
+            context_pack if context_pack is not None else _load_context_pack(root, context_pack_path)
+        )
         return PreparedExecutionInputs(
             context_snapshot,
-            context_pack,
+            resolved_pack,
             execution_context,
             authorization,
             effect_sink,
@@ -324,7 +330,7 @@ def blocked_input_profile(
         },
         {"configured": False, "production": False, "kind": None},
         None,
-        os.environ.get("SIMPLICIO_EXECUTION_ROLLOUT", str(config.get("rollout", "shadow"))),
+        os.environ.get("SIMPLICIO_EXECUTION_ROLLOUT", str(config.get("rollout", "default"))),
         False,
         error.code,
         policy.to_dict(),
@@ -361,7 +367,7 @@ def negotiate_execution_mode(
     """Negotiate only from versioned contracts; never infer from files/help/process names."""
     requested = requested_mode(mode, root)
     config = _config(root)
-    rollout = os.environ.get("SIMPLICIO_EXECUTION_ROLLOUT", str(config.get("rollout", "shadow")))
+    rollout = os.environ.get("SIMPLICIO_EXECUTION_ROLLOUT", str(config.get("rollout", "default")))
     coordinator = {
         "kind": coordinator_kind or os.environ.get("SIMPLICIO_COORDINATOR_KIND", "unknown"),
         "id": coordinator_id or os.environ.get("SIMPLICIO_COORDINATOR_ID", ""),

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/execution_receipts.py

@@ -24,7 +24,7 @@ def execution_mode_blocker(profile: Any) -> dict[str, Any]:
                     [runtime["capability"]] if not runtime.get("capability_available") else []
                 ),
                 "runtime_version": runtime.get("version"),
-                "compatible_dev_cli_version": ">=0.16.3",
+                "compatible_dev_cli_version": ">=0.18.1",
                 "next_action": "run `simplicio-py runtime verify --json`, then retry",
             }
         )

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/fast_contracts.py

@@ -12,8 +12,8 @@ from typing import Any
 
 FAST_DISTRIBUTION = "simplicio-fast"
 FAST_MODULE = "simplicio_fast"
-FAST_MIN_VERSION = (0, 1, 0)
-FAST_MAX_MAJOR = 1
+FAST_MIN_VERSION = (2, 0, 18)
+FAST_MAX_MAJOR = 3
 CAPABILITIES_SCHEMA = "simplicio.fast-capabilities/v1"
 DOCTOR_SCHEMA = "simplicio.fast-doctor/v1"
 RECEIPT_SCHEMA = "simplicio.fast-local-receipt/v1"
@@ -87,7 +87,7 @@ def fast_preflight(*, offline: bool = False) -> FastPreflight:
             mapper_version,
             False,
             "fast-version-outside-supported-range",
-            f"install {FAST_DISTRIBUTION}>=0.1,<1",
+            f"install {FAST_DISTRIBUTION}>=2.0.18,<3",
         )
 
     parser_available = _module_available(f"{FAST_MODULE}.parsers", "SIMPLICIO_FAST_PARSER_AVAILABLE")
@@ -109,7 +109,7 @@ def capabilities_contract(*, offline: bool = False) -> dict[str, Any]:
         "schema": CAPABILITIES_SCHEMA,
         "availability": preflight.to_dict(),
         "compatibility": {
-            "fast": ">=0.1,<1",
+            "fast": ">=2.0.18,<3",
             "mapper": "installed version reported; negotiated through snapshot schema",
         },
         "schemas": [

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/hardware.py

@@ -65,7 +65,7 @@ def _ram_macos() -> float | None:
         if out.returncode != 0:
             return None
         return int(out.stdout.strip()) / (1024**3)
-    except (FileNotFoundError, subprocess.TimeoutExpired, ValueError):
+    except (OSError, subprocess.TimeoutExpired, ValueError):
         return None
 
 
@@ -95,7 +95,11 @@ def _gpu_nvidia() -> tuple[float, str] | None:
             text=True,
             timeout=5,
         )
-    except (FileNotFoundError, subprocess.TimeoutExpired):
+    # Captured console handles can be invalid under Windows test runners
+    # (WinError 6/50).  Hardware probing is advisory, so every OS-level
+    # process-launch failure must degrade to "no GPU" instead of failing
+    # `doctor --json`.
+    except (OSError, subprocess.TimeoutExpired):
         return None
     if out.returncode != 0 or not out.stdout.strip():
         return None
@@ -129,7 +133,7 @@ def _gpu_apple_silicon() -> tuple[float, str] | None:
             text=True,
             timeout=3,
         )
-    except (FileNotFoundError, subprocess.TimeoutExpired):
+    except (OSError, subprocess.TimeoutExpired):
         return None
     if out.returncode != 0:
         return None

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/litert_cli.py

@@ -11,7 +11,7 @@ import platform
 import shutil
 import sys
 from pathlib import Path
-from typing import Any, Mapping
+from typing import Any
 
 
 class LiteRTError(RuntimeError):

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/map_view.py

@@ -366,7 +366,13 @@ def get_effective_map_view(root: str | os.PathLike[str], *, force_remap: bool =
     manifest + worktree overlay from disk when the live git identity still
     matches them — this is the "no redundant full remap" path (issue #213).
     """
-    identity = resolve_git_identity(root)
+    root_path = Path(root).resolve()
+    # Mapper inspection may materialize its own cache under ``.simplicio``.
+    # Resolve that state before fingerprinting the worktree, otherwise the
+    # cache write changes ``git status`` after the overlay path is chosen and
+    # makes the just-created overlay unreachable on the next call.
+    artifacts = artifact_status(root_path)
+    identity = resolve_git_identity(root_path)
     cache_key = _cache_key(identity)
     if not force_remap and cache_key in _VIEW_CACHE:
         return _VIEW_CACHE[cache_key]
@@ -390,8 +396,6 @@ def get_effective_map_view(root: str | os.PathLike[str], *, force_remap: bool =
             if overlay_candidate.matches(identity):
                 overlay = overlay_candidate
 
-    artifacts = artifact_status(identity.root)
-
     if canonical is not None and overlay is not None:
         source = SOURCE_CANONICAL_OVERLAY_HIT
     else:

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/mapper.py

@@ -178,7 +178,7 @@ def map_ask(
     data = run_mapper_json(root, "ask", extra=extra, revision=revision, snapshot_id=snapshot_id)
     if data is None:
         return None
-    return _normalize_ask_results(data.get("results"))
+    return _normalize_ask_results(data.get("results"))
 
 
 def _safe_json(path: Path) -> dict[str, Any] | None:

simplicio_cli-0.18.3/simplicio/mutation_dispatch.py

@@ -0,0 +1,45 @@
+"""Mandatory pre-dispatch Hookwall guard for every Stage ABI mutation route."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+from .mutation_lifecycle import MUTABLE_ENTRYPOINTS
+from .mutation_worker import MutationBlocked, validate
+
+READ_ONLY = {"status", "claims", "inspect", "doctor", "versions", "file", "detect", "runtime", "fast"}
+
+
+def route_name(argv: Sequence[str]) -> str:
+    if not argv:
+        return ""
+    for length in range(min(3, len(argv)), 0, -1):
+        candidate = ".".join(argv[:length])
+        if candidate in MUTABLE_ENTRYPOINTS:
+            return candidate
+    return argv[0]
+
+
+def guard_mutable_dispatch(argv: Sequence[str], environ: Mapping[str, str] | None = None) -> None:
+    env = dict(os.environ if environ is None else environ)
+    route = route_name(argv)
+    if route in READ_ONLY or route not in MUTABLE_ENTRYPOINTS:
+        return
+    if env.get("SIMPLICIO_STAGE_ABI") != "1":
+        return  # compatibility lane; never presented as Stage ABI
+    path = env.get("SIMPLICIO_MECHANICAL_PLAN", "")
+    if not path:
+        raise MutationBlocked("MECHANICAL_PLAN_REQUIRED")
+    plan_path = Path(path)
+    try:
+        plan = json.loads(plan_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as exc:
+        raise MutationBlocked("MECHANICAL_PLAN_INVALID") from exc
+    root = Path(env.get("SIMPLICIO_WORKSPACE", ".")).resolve()
+    sealed = validate(plan, root)
+    expected = env.get("SIMPLICIO_IDEMPOTENCY_KEY")
+    if not expected or sealed["idempotency_key"] != expected:
+        raise MutationBlocked("IDEMPOTENCY_KEY_REQUIRED")

simplicio_cli-0.18.3/simplicio/mutation_lifecycle.py

@@ -0,0 +1,96 @@
+"""Recovery, verification and rollback lifecycle for the Stage ABI worker."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import Any
+
+from .mutation_worker import RECEIPT, MutationBlocked, MutationWorker, digest
+
+MUTABLE_ENTRYPOINTS = {
+    "index",
+    "task",
+    "run",
+    "cache.clear",
+    "init",
+    "env-export",
+    "mechanical-edit",
+    "changeset",
+    "edit",
+    "test.run",
+    "prototype.apply",
+    "prototype.scaffold",
+    "prototype.plan",
+    "prototype.promote",
+    "prototype.reject",
+    "prototype.batch",
+    "memory.init",
+    "memory.store",
+    "memory.handoff",
+    "token.context-cache.put",
+    "token.context-cache.invalidate",
+}
+
+
+def verify_receipt(receipt: dict[str, Any]) -> bool:
+    if receipt.get("schema") != RECEIPT:
+        return False
+    supplied = receipt.get("receipt_hash")
+    return isinstance(supplied, str) and supplied == digest(
+        {key: value for key, value in receipt.items() if key != "receipt_hash"}
+    )
+
+
+def recover(worker: MutationWorker, key: str, observer: Callable[[], dict[str, Any]]) -> dict[str, Any]:
+    with worker._db() as db:
+        row = db.execute("SELECT plan_hash,state,receipt FROM mutations WHERE key=?", (key,)).fetchone()
+    if not row or row[1] not in {"RESERVED", "UNCERTAIN"}:
+        raise MutationBlocked("RECOVERY_NOT_REQUIRED")
+    observed = observer()
+    if observed.get("status") == "committed":
+        receipt = {
+            "schema": RECEIPT,
+            "plan_id": observed["plan_id"],
+            "plan_hash": row[0],
+            "idempotency_key": key,
+            "before_hash": observed["before_hash"],
+            "after_hash": observed["after_hash"],
+            "status": "committed",
+            "operations": observed.get("operations", []),
+        }
+        receipt["receipt_hash"] = digest(receipt)
+        with worker._db() as db:
+            db.execute(
+                "UPDATE mutations SET state='VERIFIED',receipt=? WHERE key=?",
+                (json.dumps(receipt, sort_keys=True), key),
+            )
+        return receipt
+    raise MutationBlocked("RECOVERY_OBSERVATION_INSUFFICIENT")
+
+
+def rollback(
+    worker: MutationWorker, key: str, restorer: Callable[[dict[str, Any]], dict[str, Any]]
+) -> dict[str, Any]:
+    with worker._db() as db:
+        row = db.execute("SELECT state,receipt FROM mutations WHERE key=?", (key,)).fetchone()
+    if not row or row[0] not in {"VERIFIED", "UNCERTAIN"}:
+        raise MutationBlocked("ROLLBACK_NOT_ALLOWED")
+    prior = json.loads(row[1]) if row[1] else {}
+    result = restorer(prior)
+    if result.get("status") != "restored":
+        raise MutationBlocked("ROLLBACK_UNVERIFIED")
+    receipt = {
+        "schema": "simplicio.rollback-receipt/v1",
+        "idempotency_key": key,
+        "mutation_receipt_hash": prior.get("receipt_hash"),
+        "restored_hash": result["restored_hash"],
+        "status": "restored",
+    }
+    receipt["receipt_hash"] = digest(receipt)
+    with worker._db() as db:
+        db.execute(
+            "UPDATE mutations SET state='ROLLED_BACK',receipt=? WHERE key=?",
+            (json.dumps(receipt, sort_keys=True), key),
+        )
+    return receipt

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/mutation_worker.py

@@ -1,23 +1,38 @@
 """Fail-closed Stage ABI mutation worker for MechanicalPlanV1."""
+
 from __future__ import annotations
-import hashlib, json, os, sqlite3
+
+import hashlib
+import json
+import sqlite3
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 SCHEMA = "simplicio.mechanical-plan/v1"
 RECEIPT = "simplicio.mutation-receipt/v1"
 
+
 class MutationBlocked(RuntimeError):
     def __init__(self, reason_code: str):
         self.reason_code = reason_code
         super().__init__(reason_code)
 
+
 def digest(value: Any) -> str:
     return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
 
+
 def validate(plan: dict[str, Any], root: Path) -> dict[str, Any]:
-    required = ("schema", "plan_id", "source_hash", "idempotency_key", "operations",
-                "effect_set", "hookwall_pre")
+    required = (
+        "schema",
+        "plan_id",
+        "source_hash",
+        "idempotency_key",
+        "operations",
+        "effect_set",
+        "hookwall_pre",
+    )
     if any(not plan.get(key) for key in required) or plan["schema"] != SCHEMA:
         raise MutationBlocked("MECHANICAL_PLAN_INVALID")
     pre = plan["hookwall_pre"]
@@ -29,51 +44,76 @@ def validate(plan: dict[str, Any], root: Path) -> dict[str, Any]:
         if not isinstance(value, str) or Path(value).is_absolute() or ".." in Path(value).parts:
             raise MutationBlocked("PATH_ESCAPE")
         candidate = (root.resolve() / value).resolve()
-        try: candidate.relative_to(root.resolve())
-        except ValueError as exc: raise MutationBlocked("SYMLINK_ESCAPE") from exc
+        try:
+            candidate.relative_to(root.resolve())
+        except ValueError as exc:
+            raise MutationBlocked("SYMLINK_ESCAPE") from exc
     normalized["plan_hash"] = digest({k: normalized[k] for k in normalized if k != "plan_hash"})
     if plan.get("plan_hash") and plan["plan_hash"] != normalized["plan_hash"]:
         raise MutationBlocked("PLAN_TAMPERED")
     return normalized
 
+
 class MutationWorker:
     def __init__(self, root: str | Path):
         self.root = Path(root)
         self.db_path = self.root / ".simplicio" / "mutation-worker.sqlite3"
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
         with self._db() as db:
-            db.execute("CREATE TABLE IF NOT EXISTS mutations(key TEXT PRIMARY KEY, plan_hash TEXT, state TEXT, receipt TEXT)")
+            db.execute(
+                "CREATE TABLE IF NOT EXISTS mutations("
+                "key TEXT PRIMARY KEY, plan_hash TEXT, state TEXT, receipt TEXT)"
+            )
+
     def _db(self):
         db = sqlite3.connect(self.db_path, isolation_level=None)
-        db.execute("PRAGMA journal_mode=WAL"); db.execute("PRAGMA synchronous=FULL")
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA synchronous=FULL")
         return db
-    def execute(self, plan: dict[str, Any], executor: Callable[[dict[str, Any]], dict[str, Any]]) -> dict[str, Any]:
-        sealed = validate(plan, self.root); key = sealed["idempotency_key"]
+
+    def execute(
+        self, plan: dict[str, Any], executor: Callable[[dict[str, Any]], dict[str, Any]]
+    ) -> dict[str, Any]:
+        sealed = validate(plan, self.root)
+        key = sealed["idempotency_key"]
         with self._db() as db:
             db.execute("BEGIN IMMEDIATE")
             row = db.execute("SELECT plan_hash,state,receipt FROM mutations WHERE key=?", (key,)).fetchone()
             if row:
                 db.execute("COMMIT")
-                if row[0] != sealed["plan_hash"]: raise MutationBlocked("IDEMPOTENCY_LINEAGE_MISMATCH")
-                if row[1] == "VERIFIED": return json.loads(row[2])
+                if row[0] != sealed["plan_hash"]:
+                    raise MutationBlocked("IDEMPOTENCY_LINEAGE_MISMATCH")
+                if row[1] == "VERIFIED":
+                    return json.loads(row[2])
                 raise MutationBlocked("RECOVERY_REQUIRED")
             db.execute("INSERT INTO mutations VALUES(?,?,?,NULL)", (key, sealed["plan_hash"], "RESERVED"))
             db.execute("COMMIT")
         try:
             result = executor(sealed)
         except BaseException:
-            with self._db() as db: db.execute("UPDATE mutations SET state='UNCERTAIN' WHERE key=?", (key,))
+            with self._db() as db:
+                db.execute("UPDATE mutations SET state='UNCERTAIN' WHERE key=?", (key,))
             raise
         if result.get("status") != "ok" or not result.get("applied"):
-            with self._db() as db: db.execute("UPDATE mutations SET state='ROLLED_BACK' WHERE key=?", (key,))
+            with self._db() as db:
+                db.execute("UPDATE mutations SET state='ROLLED_BACK' WHERE key=?", (key,))
             raise MutationBlocked("EFFECT_NOT_COMMITTED")
-        receipt = {"schema": RECEIPT, "plan_id": sealed["plan_id"], "plan_hash": sealed["plan_hash"],
-                   "idempotency_key": key, "before_hash": result["before_hash"],
-                   "after_hash": result["after_hash"], "status": "committed",
-                   "operations": result.get("operations", [])}
+        receipt = {
+            "schema": RECEIPT,
+            "plan_id": sealed["plan_id"],
+            "plan_hash": sealed["plan_hash"],
+            "idempotency_key": key,
+            "before_hash": result["before_hash"],
+            "after_hash": result["after_hash"],
+            "status": "committed",
+            "operations": result.get("operations", []),
+        }
         receipt["receipt_hash"] = digest(receipt)
         with self._db() as db:
             db.execute("BEGIN IMMEDIATE")
-            db.execute("UPDATE mutations SET state='VERIFIED',receipt=? WHERE key=?", (json.dumps(receipt, sort_keys=True), key))
+            db.execute(
+                "UPDATE mutations SET state='VERIFIED',receipt=? WHERE key=?",
+                (json.dumps(receipt, sort_keys=True), key),
+            )
             db.execute("COMMIT")
         return receipt

{simplicio_cli-0.18.0 → simplicio_cli-0.18.3}/simplicio/pipeline.py

@@ -451,7 +451,12 @@ def run_task(
             blocked_preconditions=[blocker],
         )
     if dry_run_task:
-        blockers = _dry_run_preconditions(root, target)
+        blockers = _dry_run_preconditions(
+            root,
+            target,
+            context_pack=context_pack,
+            allow_degraded_mapper=requested_execution_mode == "standalone",
+        )
         if blockers:
             warnings = [item["message"] for item in blockers]
             return _task_result(
@@ -464,6 +469,21 @@ def run_task(
                 blocked_preconditions=blockers,
                 target_kind=target_kind(root, target),
             )
+        if os.environ.get("SIMPLICIO_STANDALONE_PREFLIGHT", "").strip().lower() in {
+            "1",
+            "true",
+            "yes",
+            "on",
+        }:
+            return _task_result(
+                target,
+                prompt,
+                "",
+                applied=False,
+                status="dry_run",
+                warnings=["standalone_preflight_provider_skipped"],
+                target_kind=target_kind(root, target),
+            )
         # Issue #210 AC6: snapshot bound paths BEFORE generate() so an
         # out-of-band mutation that happens while the provider subprocess is
         # running (e.g. the target deleted mid-stall) is caught even though
@@ -924,8 +944,6 @@ def run_task_spec(root, stack, task_spec: TaskSpec, **kwargs: Any) -> dict[str,
     """
     if not isinstance(task_spec, TaskSpec):
         raise TypeError("run_task_spec requires a simplicio.task_spec.TaskSpec")
-    if "task_spec" in kwargs:
-        raise TypeError("run_task_spec does not accept a second task_spec argument")
     narrative = task_spec.narrative
     goal = str(narrative.get("goal") or narrative.get("want") or task_spec.functionality or task_spec.task_id)
     criteria = "\n".join(