simplicio-loop 3.38.8__tar.gz → 3.38.9__tar.gz

{simplicio_loop-3.38.8/simplicio_loop.egg-info → simplicio_loop-3.38.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.38.8
+Version: 3.38.9
 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

{simplicio_loop-3.38.8 → simplicio_loop-3.38.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.38.8"
+version = "3.38.9"
 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"

{simplicio_loop-3.38.8 → simplicio_loop-3.38.9}/simplicio_loop/__init__.py

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

simplicio_loop-3.38.9/simplicio_loop/client_integrations.py

@@ -0,0 +1,103 @@
+"""Client-requested integrations — never auto-wired into the core loop path.
+
+Integrations (Orca card sync, vendor MCP hosts, third-party boards, …) run only
+when the **client explicitly opts in**. Default is an empty set: a plain
+Loop/Mapper/Fast/Dev-CLI armada has zero host side-channels.
+
+Enable via either:
+
+* env ``SIMPLICIO_LOOP_CLIENT_INTEGRATIONS`` — comma-separated names
+  (e.g. ``orca`` or ``orca,linear``)
+* file ``.simplicio/client-integrations.json`` in the repo (or path in
+  ``SIMPLICIO_LOOP_CLIENT_INTEGRATIONS_FILE``)::
+
+      {"schema": "simplicio.client-integrations/v1", "integrations": ["orca"]}
+
+Legacy env ``SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC=1`` still enables the **orca**
+integration alone (compat). New clients should use the list above.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, FrozenSet, Iterable, Mapping
+
+SCHEMA = "simplicio.client-integrations/v1"
+KNOWN = frozenset(
+    {
+        "orca",
+        "linear",
+        "jira",
+        "azure-devops",
+        "slack",
+        "discord",
+    }
+)
+
+
+def _split_csv(raw: str) -> list[str]:
+    return [part.strip().lower() for part in raw.split(",") if part.strip()]
+
+
+def _from_env() -> set[str]:
+    out: set[str] = set()
+    raw = str(os.environ.get("SIMPLICIO_LOOP_CLIENT_INTEGRATIONS") or "").strip()
+    if raw:
+        out.update(_split_csv(raw))
+    # Legacy single-integration opt-in for Orca card projection.
+    legacy = str(os.environ.get("SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC") or "").strip().lower()
+    if legacy in {"1", "true", "yes", "on", "enabled"}:
+        out.add("orca")
+    return out
+
+
+def _from_file(path: Path) -> set[str]:
+    if not path.is_file():
+        return set()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return set()
+    if not isinstance(data, Mapping):
+        return set()
+    items = data.get("integrations") or data.get("enabled") or []
+    if not isinstance(items, Iterable) or isinstance(items, (str, bytes)):
+        return set()
+    return {str(item).strip().lower() for item in items if str(item).strip()}
+
+
+def resolve_integrations(*, repo_root: str | Path | None = None) -> FrozenSet[str]:
+    """Return the frozen set of client-requested integration names (may be empty)."""
+    found = _from_env()
+    file_raw = str(os.environ.get("SIMPLICIO_LOOP_CLIENT_INTEGRATIONS_FILE") or "").strip()
+    if file_raw:
+        found |= _from_file(Path(file_raw).expanduser())
+    elif repo_root is not None:
+        found |= _from_file(Path(repo_root) / ".simplicio" / "client-integrations.json")
+    else:
+        # Best-effort: cwd project file (hosts often cwd at repo root).
+        found |= _from_file(Path.cwd() / ".simplicio" / "client-integrations.json")
+    # Unknown names are kept (forward-compatible) but never invent defaults.
+    return frozenset(found)
+
+
+def integration_enabled(name: str, *, repo_root: str | Path | None = None) -> bool:
+    """True only when the client explicitly requested ``name``."""
+    key = str(name or "").strip().lower()
+    if not key:
+        return False
+    return key in resolve_integrations(repo_root=repo_root)
+
+
+def describe(*, repo_root: str | Path | None = None) -> dict[str, Any]:
+    enabled = sorted(resolve_integrations(repo_root=repo_root))
+    return {
+        "schema": SCHEMA,
+        "enabled": enabled,
+        "known": sorted(KNOWN),
+        "default": [],
+        "policy": "opt-in-only-per-client-request",
+        "orca_lifecycle_sync": integration_enabled("orca", repo_root=repo_root),
+    }

{simplicio_loop-3.38.8 → simplicio_loop-3.38.9}/simplicio_loop/orca_lifecycle.py

@@ -1,10 +1,14 @@
-"""Best-effort Orca Dev worktree-card lifecycle projection.
+"""Best-effort Orca Dev worktree-card lifecycle projection (**client opt-in only**).
 
-Orca is a host rather than a second source-of-truth API.  The adapter therefore
-uses the public ``orca worktree`` CLI and scopes every write to the active
-worktree only after ``worktree current`` proves that an Orca context exists.
-Outside Orca this is an explicit no-op, so a local or GitHub-only run cannot
-touch another workspace's card.
+Not part of the default loop path. The runner only enters this module when the
+client requested the ``orca`` integration (see ``client_integrations.py``):
+
+* ``SIMPLICIO_LOOP_CLIENT_INTEGRATIONS=orca``
+* ``.simplicio/client-integrations.json`` listing ``"orca"``
+* legacy ``SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC=1``
+
+When enabled, uses the public ``orca worktree`` CLI and scopes writes to the
+active worktree after ``worktree current``. Outside Orca: explicit no-op.
 """
 from __future__ import annotations
 
@@ -13,6 +17,8 @@ import os
 import subprocess
 from typing import Any, Callable, Dict, Mapping, Sequence
 
+from .client_integrations import integration_enabled
+
 
 ORCA_STATUS_BY_LIFECYCLE = {
     "DISCOVERED": "todo",
@@ -89,16 +95,8 @@ def lifecycle_to_orca_canonical_status(state: str) -> str:
 
 
 def _disabled() -> bool:
-    """Orca is opt-in only.
-
-    Default (unset) is disabled so a normal loop never depends on Orca.
-    Enable explicitly with ``SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC=1`` (or true/on/yes).
-    """
-    raw = str(os.environ.get("SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC") or "").strip().lower()
-    if raw in {"1", "true", "yes", "on", "enabled", "canonical"}:
-        return False
-    # Unset, empty, off, 0, false, no, legacy → disabled (optional host integration).
-    return True
+    """True unless the client explicitly requested the Orca integration."""
+    return not integration_enabled("orca")
 
 
 def _command() -> str:

{simplicio_loop-3.38.8 → simplicio_loop-3.38.9}/simplicio_loop/runner.py

@@ -21,6 +21,7 @@ from .delivery import (build_delivery_receipt, normalize_delivery_target,
 from .evidence import build_evidence_receipt, redact_sensitive_text
 from .source_state import github_delivery_payload, infer_github_delivery_state
 from . import github_lifecycle as _github_lifecycle
+from .client_integrations import integration_enabled
 from .orca_lifecycle import sync_orca_status
 from .source_adapter import GitHubSourceAdapter
 from .task_contract import compile_many, validate_contract
@@ -1747,16 +1748,20 @@ def _record_event(run_dir: Path, state: Dict[str, Any], event: Dict[str, Any],
     _write_json(run_dir / "state.json", state)
     _append_jsonl(run_dir / "events.jsonl", event)
     _sync_github_lifecycle(run_dir, state, event)
-    _sync_orca_lifecycle(run_dir, state, event)
+    # Host integrations (Orca cards, boards, chat) are NEVER default — only when
+    # the client explicitly requested them via SIMPLICIO_LOOP_CLIENT_INTEGRATIONS
+    # / .simplicio/client-integrations.json (see client_integrations.py).
+    if integration_enabled("orca"):
+        _sync_orca_lifecycle(run_dir, state, event)
     return state
 
 
 def _sync_orca_lifecycle(run_dir: Path, state: Dict[str, Any], event: Dict[str, Any]) -> None:
-    """Project the same lifecycle event onto the active Orca Dev card.
+    """Project lifecycle onto an Orca worktree card **only** for Orca clients.
 
-    Orca is optional and host-local: a missing Orca context is recorded as a
-    typed skip rather than treated as a failed delivery or a reason to touch a
-    different worktree.
+    Not a core loop hook. Requires client opt-in via
+    ``integration_enabled("orca")`` (caller already gated). Missing Orca context
+    is a typed skip — never a delivery failure.
     """
     lifecycle_state = _github_lifecycle.lifecycle_state_for_phase_event(
         str(event.get("kind") or event.get("phase") or ""))

{simplicio_loop-3.38.8 → simplicio_loop-3.38.9/simplicio_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.38.8
+Version: 3.38.9
 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

{simplicio_loop-3.38.8 → simplicio_loop-3.38.9}/simplicio_loop.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ simplicio_loop/capability_negotiation.py
 simplicio_loop/checkpoint_lifecycle.py
 simplicio_loop/cli.py
 simplicio_loop/cli_impl.py
+simplicio_loop/client_integrations.py
 simplicio_loop/completion_auditor.py
 simplicio_loop/consumer_cli.py
 simplicio_loop/context_graph_fanout.py
@@ -424,6 +425,7 @@ tests/test_cli_oracle_unit.py
 tests/test_cli_preflight_runtime_optional_unit.py
 tests/test_cli_preflight_status_json_unit.py
 tests/test_cli_run_delivery_choices_559_unit.py
+tests/test_client_integrations_unit.py
 tests/test_code_hub_transport.py
 tests/test_completion_auditor_431_unit.py
 tests/test_completion_oracle_matrix_unit.py
@@ -523,6 +525,7 @@ tests/test_hooks_coverage_integration.py
 tests/test_hookwall_gate_783.py
 tests/test_hookwall_persistence_783.py
 tests/test_hookwall_rollout_783.py
+tests/test_host_rule_sync_and_arm_prism_unit.py
 tests/test_hub_agent_executor.py
 tests/test_hub_agent_store.py
 tests/test_hub_daemon.py

simplicio_loop-3.38.9/tests/test_client_integrations_unit.py

@@ -0,0 +1,56 @@
+"""Client integrations are opt-in; Orca is never default."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from simplicio_loop.client_integrations import (
+    describe,
+    integration_enabled,
+    resolve_integrations,
+)
+from simplicio_loop.orca_lifecycle import _disabled
+
+
+def test_default_has_no_integrations(monkeypatch, tmp_path):
+    monkeypatch.delenv("SIMPLICIO_LOOP_CLIENT_INTEGRATIONS", raising=False)
+    monkeypatch.delenv("SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC", raising=False)
+    monkeypatch.delenv("SIMPLICIO_LOOP_CLIENT_INTEGRATIONS_FILE", raising=False)
+    monkeypatch.chdir(tmp_path)
+    assert resolve_integrations(repo_root=tmp_path) == frozenset()
+    assert integration_enabled("orca", repo_root=tmp_path) is False
+    assert _disabled() is True
+
+
+def test_env_list_enables_orca(monkeypatch, tmp_path):
+    monkeypatch.setenv("SIMPLICIO_LOOP_CLIENT_INTEGRATIONS", "orca")
+    monkeypatch.delenv("SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC", raising=False)
+    monkeypatch.chdir(tmp_path)
+    assert integration_enabled("orca", repo_root=tmp_path) is True
+    assert _disabled() is False
+
+
+def test_legacy_orca_env_maps_to_integration(monkeypatch, tmp_path):
+    monkeypatch.delenv("SIMPLICIO_LOOP_CLIENT_INTEGRATIONS", raising=False)
+    monkeypatch.setenv("SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC", "1")
+    monkeypatch.chdir(tmp_path)
+    assert integration_enabled("orca", repo_root=tmp_path) is True
+
+
+def test_repo_file_enables_named_integrations(monkeypatch, tmp_path):
+    monkeypatch.delenv("SIMPLICIO_LOOP_CLIENT_INTEGRATIONS", raising=False)
+    monkeypatch.delenv("SIMPLICIO_LOOP_ORCA_LIFECYCLE_SYNC", raising=False)
+    cfg = tmp_path / ".simplicio" / "client-integrations.json"
+    cfg.parent.mkdir(parents=True)
+    cfg.write_text(
+        json.dumps({"schema": "simplicio.client-integrations/v1", "integrations": ["linear"]}),
+        encoding="utf-8",
+    )
+    monkeypatch.chdir(tmp_path)
+    assert integration_enabled("linear", repo_root=tmp_path) is True
+    assert integration_enabled("orca", repo_root=tmp_path) is False
+    payload = describe(repo_root=tmp_path)
+    assert payload["policy"] == "opt-in-only-per-client-request"
+    assert payload["enabled"] == ["linear"]

simplicio_loop-3.38.9/tests/test_host_rule_sync_and_arm_prism_unit.py

@@ -0,0 +1,55 @@
+"""host_rule_sync + arm_drain_prism unit tests."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import host_rule_sync
+import arm_drain_prism
+
+
+def test_host_rule_sync_writes_project_rules(tmp_path, monkeypatch):
+    monkeypatch.setenv("SIMPLICIO_HOME", str(tmp_path / "home"))
+    # force module home via env already set for global; only project target
+    receipt = host_rule_sync.sync(do_global=False, target=tmp_path / "repo")
+    assert receipt["ok"] is True
+    assert receipt["count"] >= 1
+    rule = tmp_path / "repo" / ".claude" / "rules" / "simplicio-loop-operator-flow.md"
+    assert rule.is_file()
+    text = rule.read_text(encoding="utf-8")
+    assert "SIMPLICIO_LOOP_STRICT" in text
+    assert "simplicio-mapper" in text
+
+
+def test_host_rule_sync_global_env_files(tmp_path, monkeypatch):
+    home = tmp_path / "home"
+    monkeypatch.setenv("SIMPLICIO_HOME", str(home))
+    monkeypatch.setenv("HOME", str(home))
+    # host_rule_sync._home uses SIMPLICIO_HOME first
+    receipt = host_rule_sync.sync(do_global=True, target=None)
+    assert receipt["ok"] is True
+    env_sh = home / ".simplicio" / "loop-env.sh"
+    assert env_sh.is_file()
+    assert "SIMPLICIO_LOOP_STRICT=1" in env_sh.read_text(encoding="utf-8")
+    grok_rule = home / ".grok" / "rules" / "simplicio-loop-operator-flow.md"
+    assert grok_rule.is_file()
+
+
+def test_arm_drain_prism_writes_scratchpad(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    repo = tmp_path / "proj"
+    repo.mkdir()
+    (repo / ".git").mkdir()
+    receipt = arm_drain_prism.arm(repo, slots=3, max_iterations=50, promise="done-when-empty")
+    assert receipt["ok"] is True
+    assert receipt["prism_slots"] == 3
+    assert receipt["prism_logical_capacity"] == 30
+    scratch = Path(receipt["scratchpad"])
+    assert scratch.is_file()
+    body = scratch.read_text(encoding="utf-8")
+    assert "mode: drain" in body
+    assert "prism_slots: 3" in body
+    assert "forbid_hand_edit: true" in body
+    assert "done-when-empty" in body