simplicio-cli 0.18.2__tar.gz → 0.18.4__tar.gz

{simplicio_cli-0.18.2/simplicio_cli.egg-info → simplicio_cli-0.18.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.18.2
+Version: 0.18.4
 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.1
+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

{simplicio_cli-0.18.2 → simplicio_cli-0.18.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.18.2"
+version = "0.18.4"
 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.1",
+  "simplicio-mapper>=0.26.2",
   "simplicio-prompt>=1.14.1",
   "httpx>=0.28.1",
   "orjson>=3.11.9",

{simplicio_cli-0.18.2 → simplicio_cli-0.18.4}/simplicio/__init__.py

@@ -1,5 +1,5 @@
-__version__ = "0.18.2"
-
-from .mapper_api import mapper_module, mapper_version
-
-__all__ = ["__version__", "mapper_module", "mapper_version"]
+__version__ = "0.18.4"
+
+from .mapper_api import mapper_module, mapper_version
+
+__all__ = ["__version__", "mapper_module", "mapper_version"]

{simplicio_cli-0.18.2 → simplicio_cli-0.18.4}/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.2 → simplicio_cli-0.18.4}/simplicio/cli.py

@@ -541,7 +541,12 @@ def _build_parser() -> argparse.ArgumentParser:
     p_runtime_verify = runtime_sub.add_parser(
         "verify", help="verify the real reserved Simplicio Runtime identity and capabilities"
     )
-    p_runtime_verify.add_argument("--timeout", type=int, default=30)
+    p_runtime_verify.add_argument(
+        "--timeout",
+        type=int,
+        default=None,
+        help="optional Runtime probe deadline in seconds (default: no deadline)",
+    )
     p_runtime_capabilities = runtime_sub.add_parser("capabilities")
     p_runtime_capabilities.add_argument("--root", default=".")
     p_runtime_capabilities.add_argument("--mode", choices=["auto", "integrated", "standalone"])
@@ -692,6 +697,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 +775,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.2 → simplicio_cli-0.18.4}/simplicio/codex_hooks.py

@@ -1,65 +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:
-            print(result.hint, file=sys.stderr)
-    except Exception:
-        # Hooks must never take down or block the host agent.
-        return 0
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+"""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.2 → simplicio_cli-0.18.4}/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.2 → simplicio_cli-0.18.4}/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.2 → simplicio_cli-0.18.4}/simplicio/execution_mode.py

@@ -240,9 +240,7 @@ def prepare_execution_inputs(
         # 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)
+            context_pack if context_pack is not None else _load_context_pack(root, context_pack_path)
         )
         return PreparedExecutionInputs(
             context_snapshot,

{simplicio_cli-0.18.2 → simplicio_cli-0.18.4}/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.2 → simplicio_cli-0.18.4}/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.2 → simplicio_cli-0.18.4}/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.4/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.4/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.2 → simplicio_cli-0.18.4}/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.2 → simplicio_cli-0.18.4}/simplicio/pipeline.py

@@ -470,7 +470,10 @@ def run_task(
                 target_kind=target_kind(root, target),
             )
         if os.environ.get("SIMPLICIO_STANDALONE_PREFLIGHT", "").strip().lower() in {
-            "1", "true", "yes", "on",
+            "1",
+            "true",
+            "yes",
+            "on",
         }:
             return _task_result(
                 target,
@@ -941,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(

{simplicio_cli-0.18.2 → simplicio_cli-0.18.4}/simplicio/pipeline_stages.py

@@ -27,7 +27,6 @@ _TEST_COMMAND_PLACEHOLDERS = {
     "echo 'configure SIMPLICIO_TEST_CMD'",
     'echo "configure SIMPLICIO_TEST_CMD"',
 }
-_DEFAULT_VERIFY_TIMEOUT_S = 120
 
 
 @dataclass
@@ -71,15 +70,17 @@ def _configured_test_command() -> tuple[str | None, str | None]:
     return raw, None
 
 
-def _verification_timeout_seconds() -> int:
+def _verification_timeout_seconds() -> int | None:
     raw = os.environ.get("SIMPLICIO_TEST_TIMEOUT_S", "").strip()
     if not raw:
-        return _DEFAULT_VERIFY_TIMEOUT_S
+        return None
+    if raw.lower() in {"0", "off", "none", "unlimited"}:
+        return None
     try:
         value = int(raw)
     except ValueError:
-        return _DEFAULT_VERIFY_TIMEOUT_S
-    return value if value > 0 else _DEFAULT_VERIFY_TIMEOUT_S
+        return None
+    return value if value > 0 else None
 
 
 def _patch_receipt(candidate: PatchCandidate | None, files: list[str] | None = None) -> dict[str, Any] | None: