simplicio-loop 3.43.0__tar.gz → 3.43.2__tar.gz

{simplicio_loop-3.43.0/simplicio_loop.egg-info → simplicio_loop-3.43.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.43.0
+Version: 3.43.2
 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.9
-Requires-Dist: simplicio-mapper<0.27,>=0.26.18
-Requires-Dist: simplicio-fast<3,>=2.0.27
+Requires-Dist: simplicio-cli<0.19,>=0.18.10
+Requires-Dist: simplicio-mapper<0.27,>=0.26.20
+Requires-Dist: simplicio-fast<3,>=2.0.28
 Requires-Dist: tiktoken<1,>=0.12.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"

simplicio_loop-3.43.2/contracts/stage-agents/v1/.simplicio/session/orientation-delivered.json

@@ -0,0 +1 @@
+{"delivered":"code-survey","issue_kind":"existing-code","route":"code-survey-once","runtime_map":"omitted","schema":"simplicio.orientation-receipt/v1"}

{simplicio_loop-3.43.0 → simplicio_loop-3.43.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.43.0"
+version = "3.43.2"
 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"
@@ -28,9 +28,9 @@ classifiers = [
 # explicitly and the normal `pip install simplicio-loop` closure must request both distributions.
 dependencies = [
   # Loop is the aggregate distribution. Keep one tested component train.
-  "simplicio-cli>=0.18.9,<0.19",
-  "simplicio-mapper>=0.26.18,<0.27",
-  "simplicio-fast>=2.0.27,<3",
+  "simplicio-cli>=0.18.10,<0.19",
+  "simplicio-mapper>=0.26.20,<0.27",
+  "simplicio-fast>=2.0.28,<3",
   "tiktoken>=0.12.0,<1",
 ]
 

{simplicio_loop-3.43.0 → simplicio_loop-3.43.2}/simplicio_loop/__init__.py

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

simplicio_loop-3.43.2/simplicio_loop/_bundle/.simplicio/session/orientation-delivered.json

@@ -0,0 +1 @@
+{"delivered":"code-survey","issue_kind":"existing-code","route":"code-survey-once","runtime_map":"omitted","schema":"simplicio.orientation-receipt/v1"}

{simplicio_loop-3.43.0 → simplicio_loop-3.43.2}/simplicio_loop/cli_impl.py

@@ -18,6 +18,10 @@ try:
     from scripts import release_manifest as _release_manifest
 except Exception:  # pragma: no cover - import shim for bundled scripts
     _release_manifest = None
+try:
+    from scripts import release_train as _release_train
+except Exception:  # pragma: no cover - import shim for bundled scripts
+    _release_train = None
 try:
     from . import prototype_cli as _prototype_cli
 except Exception:  # pragma: no cover - keeps `simplicio-loop` importable if this is missing
@@ -95,21 +99,36 @@ def _copy_tree(src: Path, dst: Path) -> int:
     return count
 
 
-def install(target: Path, globally: bool) -> int:
-    base = (Path.home() / ".claude") if globally else (target / ".claude")
-    skills_dst = base / "skills"
-    hooks_dst = (base / "hooks") if globally else (target / "hooks")
+def install(target: Path, globally: bool, host: str = "claude",
+            dry_run: bool = False, uninstall: bool = False, verify: bool = False) -> int:
+    from .install.planner import InstallError, apply_plan, plan_install
+    from .install.planner import uninstall as remove_owned
+    from .install.planner import verify_plan
 
-    if not (BUNDLE / "skills").is_dir():
-        print("error: bundled skills not found in the installed package.", flush=True)
+    root = Path.home() if globally else target
+    if uninstall:
+        try:
+            payload = remove_owned(root)
+        except InstallError as exc:
+            print(f"error: {exc}", flush=True)
+            return 1
+        print(f"simplicio-loop uninstalled {len(payload.get('removed') or [])} owned paths")
+        return 0
+    try:
+        plan = plan_install(root, host=host, globally=globally)
+        if verify:
+            verify_plan(plan)
+            print(f"simplicio-loop install plan ok host={host} digest={plan['digest']}")
+            return 0
+        result = apply_plan(plan, dry_run=dry_run, bundle=BUNDLE)
+    except InstallError as exc:
+        print(f"error: {exc}", flush=True)
         return 1
-
-    n_skills = _copy_tree(BUNDLE / "skills", skills_dst)
-    n_hooks = _copy_tree(BUNDLE / "hooks", hooks_dst)
-
-    print(f"simplicio-loop {__version__} installed:")
-    print(f"  skills -> {skills_dst}  ({n_skills} files)")
-    print(f"  hooks  -> {hooks_dst}  ({n_hooks} files)")
+    status = "installed" if result["status"] == "applied" else result["status"]
+    print(f"simplicio-loop {__version__} {status}:")
+    print(f"  host   -> {host}")
+    print(f"  owned  -> {', '.join(result['owned'])}")
+    print(f"  files  -> {result['written']}")
     print("")
     print("Use it in your agent runtime (Claude Code, Cursor, ...):")
     print("  /simplicio-loop finish all the open issues")
@@ -363,7 +382,7 @@ def _mapper_orient_fallback(root: Path, task: str) -> dict:
 
 def orient(repo: str, task: str, fast_mode: str = "auto",
            fast_context_budget: int = 48000, fast_engine: str = "auto",
-           tee: bool = False) -> int:
+           tee: bool = False, targets: list[str] | None = None) -> int:
     """Run bounded Fast orient with an explicit Mapper fallback receipt."""
     root = Path(repo).resolve()
     if not root.is_dir() or not str(task).strip():
@@ -400,6 +419,7 @@ def orient(repo: str, task: str, fast_mode: str = "auto",
             root,
             config=FastConfig(mode=effective_mode, engine=fast_engine,
                               max_bytes=int(fast_context_budget)),
+            extra_targets=list(targets or []),
         )
         fast_payload = integration.prepare(str(task))
         if fast_mode == "on" and fast_payload.get("status") != "READY":
@@ -1096,6 +1116,10 @@ def main(argv=None) -> int:
     p_install.add_argument("--target", default=".", help="project directory to install into")
     p_install.add_argument("--global", dest="globally", action="store_true",
                            help="install into ~/.claude instead of the project")
+    p_install.add_argument("--host", default="claude", help="host id or 'all'")
+    p_install.add_argument("--dry-run", action="store_true", help="plan only; write nothing")
+    p_install.add_argument("--verify", action="store_true", help="validate plan version/digest")
+    p_install.add_argument("--uninstall", action="store_true", help="remove Loop-owned files only")
 
     p_dashboard = sub.add_parser("dashboard", help="open or stop the Token Monitor dashboard")
     p_dashboard.add_argument("--port", type=int, default=DEFAULT_DASH_PORT,
@@ -1156,6 +1180,10 @@ def main(argv=None) -> int:
     p_orient.add_argument("--fast-engine", choices=("auto", "rust", "python", "off"), default="auto",
                           help="Fast engine: Rust-first auto, explicit rust/python, or off")
     p_orient.add_argument("--tee", action="store_true", help="persist full JSON output in the reversible tee cache")
+    p_orient.add_argument(
+        "--target", dest="targets", action="append", default=[],
+        help="repo-relative source file selected by Mapper or the task (repeatable)",
+    )
 
     p_retrieve = sub.add_parser("retrieve", help="retrieve and verify a tee-cache output")
     p_retrieve.add_argument("path")
@@ -1549,6 +1577,10 @@ def main(argv=None) -> int:
         "check", help="validate component/ecosystem release schemas + local drift"
     )
     p_rt_check.add_argument("--repo", default=".", help="repository root")
+    if _release_train is not None:
+        # The check command remains owned by release_manifest for backwards compatibility;
+        # composition/promotion/rollback are the effect-gated #558 release-train operations.
+        _release_train.configure_subparsers(rt_sub)
 
     if argv_list:
         from .github_drain_intake_cli import looks_like_natural_request, main as drain_intake_main
@@ -1584,7 +1616,8 @@ def main(argv=None) -> int:
                    args.quality_provider, args.quality_policy, args.result_file,
                    args.require_handshake_fingerprint)
     if command == "orient":
-        return orient(args.repo, args.task, args.fast, args.fast_context_budget, args.fast_engine, args.tee)
+        return orient(args.repo, args.task, args.fast, args.fast_context_budget, args.fast_engine, args.tee,
+                      args.targets)
     if command == "retrieve":
         from .tee_cache import retrieve
         try:
@@ -1731,10 +1764,21 @@ def main(argv=None) -> int:
             args.ledger_command,
         )
     if command == "release-train":
-        if _release_manifest is None:
-            parser.error("release_manifest script not importable")
-        return _release_manifest.release_train_check(args.repo)
-    return install(Path(args.target).resolve(), args.globally)
+        if args.release_train_command == "check":
+            if _release_manifest is None:
+                parser.error("release_manifest script not importable")
+            return _release_manifest.release_train_check(args.repo)
+        if _release_train is None:
+            parser.error("release_train script not importable")
+        return _release_train.run_namespace(args)
+    return install(
+        Path(args.target).resolve(),
+        args.globally,
+        getattr(args, "host", "claude"),
+        getattr(args, "dry_run", False),
+        getattr(args, "uninstall", False),
+        getattr(args, "verify", False),
+    )
 
 
 if __name__ == "__main__":

{simplicio_loop-3.43.0 → simplicio_loop-3.43.2}/simplicio_loop/fast_integration.py

@@ -105,6 +105,15 @@ _PATH_TOKEN = re.compile(
     r"(?<![\w.-])(?:[A-Za-z]:)?[\\/]?(?:[A-Za-z0-9_.-]+[\\/])+"
     r"[A-Za-z0-9_.-]*[\\/]?"
 )
+_BARE_CODE_TOKEN = re.compile(
+    r"(?<![\w/\\])(?P<name>[A-Za-z0-9_-]+\.(?:py|tsx?|js|rs))(?![A-Za-z0-9_/\\-])"
+)
+_TECH_FILE_HINTS = frozenset({
+    "node.js", "next.js", "vue.js", "react.js", "express.js", "deno.js",
+    "bun.js", "alpine.js", "ember.js", "gatsby.js", "nuxt.js", "svelte.js",
+    "backbone.js", "jquery.js",
+})
+_CODE_SUFFIXES = (".py", ".ts", ".tsx", ".js", ".rs")
 INTENT_POLICY_SCHEMA = "simplicio.loop-fast-intent-policy/v1"
 
 
@@ -133,7 +142,155 @@ def _path_within_root(root: Path, relative: str) -> bool:
     return True
 
 
-def _explicit_targets(task: str) -> tuple[list[tuple[str, bool]], list[str]]:
+def _is_code_target(path: str) -> bool:
+    return path.lower().endswith(_CODE_SUFFIXES)
+
+
+def _existing_repo_file(root: Path, relative: str) -> bool:
+    candidate = root / Path(relative)
+    return candidate.is_file() and _path_within_root(root, relative)
+
+
+def _bare_existing_targets(task: str, root: Path) -> list[str]:
+    found: list[str] = []
+    without_urls = re.sub(r"\b[A-Za-z][A-Za-z0-9+.-]*://\S+", "", str(task))
+    for match in _BARE_CODE_TOKEN.finditer(without_urls):
+        raw = match.group("name").strip()
+        if raw.lower() in _TECH_FILE_HINTS:
+            continue
+        normalized = _normalize_repo_path(raw)
+        if normalized is None or not _is_code_target(normalized):
+            continue
+        if _existing_repo_file(root, normalized) and normalized not in found:
+            found.append(normalized)
+    return found
+
+
+def _load_json_object(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _pack_selected_targets(payload: Mapping[str, Any], root: Path) -> list[str]:
+    found: list[str] = []
+
+    def add(raw: Any) -> None:
+        if not isinstance(raw, str):
+            return
+        normalized = _normalize_repo_path(raw.replace("\\", "/"))
+        if (
+            normalized
+            and _is_code_target(normalized)
+            and normalized.lower() not in _TECH_FILE_HINTS
+            and _existing_repo_file(root, normalized)
+            and normalized not in found
+        ):
+            found.append(normalized)
+
+    add(payload.get("explicit_target_added"))
+    add(payload.get("target"))
+    for key in ("targets", "selected_targets"):
+        values = payload.get(key)
+        if isinstance(values, str):
+            add(values)
+        elif isinstance(values, Sequence) and not isinstance(values, (str, bytes)):
+            for item in values:
+                add(item if isinstance(item, str) else (item.get("path") if isinstance(item, Mapping) else None))
+
+    files = payload.get("files")
+    if isinstance(files, Sequence) and not isinstance(files, (str, bytes)):
+        explicit_files: list[str] = []
+        code_files: list[str] = []
+        for item in files:
+            path = ""
+            reason = ""
+            if isinstance(item, Mapping):
+                path = str(item.get("path") or "")
+                reason = str(item.get("selection_reason") or "")
+            elif isinstance(item, str):
+                path = item
+            if reason == "explicit_task_target":
+                explicit_files.append(path)
+            if _is_code_target(path.replace("\\", "/")):
+                code_files.append(path)
+        for path in explicit_files:
+            add(path)
+        if not found and 1 <= len(code_files) <= 3:
+            for path in code_files:
+                add(path)
+    return found
+
+
+def _unwrap_context_pack(payload: Mapping[str, Any]) -> Mapping[str, Any]:
+    handoff = payload.get("handoff") if isinstance(payload.get("handoff"), Mapping) else {}
+    stdout = handoff.get("stdout") if isinstance(handoff.get("stdout"), Mapping) else payload
+    pack = stdout.get("context_pack") if isinstance(stdout, Mapping) and isinstance(stdout.get("context_pack"), Mapping) else payload
+    return pack if isinstance(pack, Mapping) else payload
+
+
+def mapper_selected_targets(root: Path) -> list[str]:
+    """Read the newest Mapper handoff / run context for an existing code target."""
+    found: list[str] = []
+    simplicio = root / ".simplicio"
+    if not simplicio.is_dir():
+        return found
+
+    def absorb(payload: Mapping[str, Any]) -> None:
+        for path in _pack_selected_targets(_unwrap_context_pack(payload), root):
+            if path not in found:
+                found.append(path)
+        for path in _pack_selected_targets(payload, root):
+            if path not in found:
+                found.append(path)
+
+    objects = simplicio / "handoff-objects"
+    if objects.is_dir():
+        packs = sorted(
+            objects.glob("context_pack-*.json"),
+            key=lambda item: item.stat().st_mtime,
+            reverse=True,
+        )
+        for pack_path in packs[:4]:
+            absorb(_load_json_object(pack_path))
+            if found:
+                return found
+
+    runs = simplicio / "loop-runs"
+    if runs.is_dir():
+        run_dirs = sorted(
+            (item for item in runs.iterdir() if item.is_dir()),
+            key=lambda item: item.stat().st_mtime,
+            reverse=True,
+        )
+        for run_dir in run_dirs[:4]:
+            for name in ("mapper-context.json", "context-pack.json"):
+                candidate = run_dir / name
+                if candidate.is_file():
+                    absorb(_load_json_object(candidate))
+                    if found:
+                        return found
+
+    anchor = simplicio / "orchestrator" / "loop" / "anchor.json"
+    if anchor.is_file():
+        payload = _load_json_object(anchor)
+        blob = " ".join(
+            [
+                str(payload.get("goal") or ""),
+                *(str(item.get("text") or item.get("title") or "")
+                  for item in (payload.get("criteria") or [])
+                  if isinstance(item, Mapping)),
+            ]
+        )
+        for path in _bare_existing_targets(blob, root):
+            if path not in found:
+                found.append(path)
+    return found
+
+
+def _explicit_targets(task: str, root: Path | None = None) -> tuple[list[tuple[str, bool]], list[str]]:
     targets: dict[str, bool] = {}
     invalid: list[str] = []
     without_urls = re.sub(r"\b[A-Za-z][A-Za-z0-9+.-]*://\S+", "", str(task))
@@ -145,9 +302,34 @@ def _explicit_targets(task: str) -> tuple[list[tuple[str, bool]], list[str]]:
             invalid.append(raw)
             continue
         targets[normalized] = targets.get(normalized, False) or is_dir
+    if root is not None:
+        for path in _bare_existing_targets(task, root):
+            targets.setdefault(path, False)
     return sorted(targets.items()), sorted(set(invalid))
 
 
+def _merge_targets(
+    targets: dict[str, bool], extras: Sequence[str],
+) -> dict[str, bool]:
+    merged = dict(targets)
+    for raw in extras:
+        normalized = _normalize_repo_path(str(raw).replace("\\", "/"))
+        if normalized:
+            merged.setdefault(normalized, False)
+    return merged
+
+
+def _next_orient_command(root: Path, task: str, suggested: str) -> str:
+    return (
+        "simplicio-loop orient --repo "
+        + str(root)
+        + " --task "
+        + json.dumps(task)
+        + " --fast auto --target "
+        + suggested
+    )
+
+
 def _context_paths(value: Any) -> list[str]:
     if isinstance(value, Mapping):
         found: list[str] = []
@@ -201,10 +383,16 @@ def _blocker(reason: str, message: str, next_surface: str) -> dict[str, Any]:
 
 
 def _validate_plan_policy(
-    root: Path, task: str, understanding: Mapping[str, Any], plan: Mapping[str, Any]
+    root: Path, task: str, understanding: Mapping[str, Any], plan: Mapping[str, Any],
+    extra_targets: Sequence[str] = (),
 ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
     read_only = _read_only_intent(task)
-    targets, invalid_targets = _explicit_targets(task)
+    extracted, invalid_targets = _explicit_targets(task, root)
+    selected = mapper_selected_targets(root)
+    merged = _merge_targets({path: is_dir for path, is_dir in extracted}, extra_targets)
+    if not merged:
+        merged = _merge_targets(merged, selected)
+    targets = sorted(merged.items())
     target_names = [path + ("/" if is_dir else "") for path, is_dir in targets]
     policy = {
         "schema": INTENT_POLICY_SCHEMA,
@@ -309,14 +497,20 @@ def _validate_plan_policy(
             if not (candidate.is_dir() if is_dir else candidate.is_file()):
                 unresolved.append(path + ("/" if is_dir else ""))
         if unresolved:
-            blockers.append(
-                _blocker(
-                    "TARGET_PATH_UNRESOLVED",
-                    "explicit target paths must resolve under the orientation repository: "
-                    + ", ".join(unresolved),
-                    "target",
-                )
+            suggested = next((path for path in (*extra_targets, *selected) if _existing_repo_file(root, path)), "")
+            if not suggested:
+                suggested = next(iter(_bare_existing_targets(task, root)), "plugin.js")
+            blocker = _blocker(
+                "TARGET_PATH_UNRESOLVED",
+                "explicit target paths must resolve under the orientation repository: "
+                + ", ".join(unresolved)
+                + ". Use a repo-relative file that exists, e.g. --target "
+                + suggested,
+                "target",
             )
+            blocker["next_command"] = _next_orient_command(root, task, suggested)
+            blocker["accepted_target_form"] = "repo-relative existing file, e.g. plugin.js"
+            blockers.append(blocker)
         if mutation_nodes and not allowed_files:
             blockers.append(
                 _blocker(
@@ -535,13 +729,15 @@ class FastLoopIntegration:
     def __init__(self, root: str | Path, *, config: FastConfig | None = None,
                  runtime_apply: Callable[[Mapping[str, Any]], Mapping[str, Any]] | None = None,
                  fallback_apply: Callable[[Mapping[str, Any]], Mapping[str, Any]] | None = None,
-                 runner: Callable[..., subprocess.CompletedProcess[str]] | None = None) -> None:
+                 runner: Callable[..., subprocess.CompletedProcess[str]] | None = None,
+                 extra_targets: Sequence[str] = ()) -> None:
         self.root = Path(root).resolve()
         if not self.root.is_dir():
             raise ValueError("Fast root must be a directory")
         self.config = config or FastConfig.from_env()
         self.runtime_apply = runtime_apply
         self.fallback_apply = fallback_apply
+        self.extra_targets = tuple(str(item).strip() for item in extra_targets if str(item).strip())
         self._runner = runner or subprocess.run
         self._probe_cache: FastProbe | None = None
         self._ingest_receipt: dict[str, Any] | None = None
@@ -750,7 +946,9 @@ class FastLoopIntegration:
                              "--max-bytes", str(self.config.max_bytes)])
         if payload.get("schema") != FAST_PLAN_SCHEMA:
             raise FastIntegrationError("Fast plan schema is not v2")
-        policy, blockers = _validate_plan_policy(self.root, task, understanding, payload)
+        policy, blockers = _validate_plan_policy(
+            self.root, task, understanding, payload, extra_targets=self.extra_targets
+        )
         if blockers:
             payload = _redact_blocked_plan(payload, policy, blockers)
         result = dict(payload)
@@ -918,4 +1116,4 @@ class FastLoopIntegration:
 
 __all__ = ["APPLY_RECEIPT_SCHEMA", "FAST_CHANGESET_SCHEMA", "FAST_PLAN_SCHEMA", "FastConfig",
            "FastIntegrationError", "FastLoopIntegration", "FastProbe", "FastStaleChangeset",
-           "FastUnavailable", "SCHEMA", "validate_changeset"]
+           "FastUnavailable", "SCHEMA", "mapper_selected_targets", "validate_changeset"]

simplicio_loop-3.43.2/simplicio_loop/install/__init__.py

@@ -0,0 +1,5 @@
+"""Host-aware Loop installer shipped in the wheel."""
+
+from .planner import HOSTS, InstallError, apply_plan, plan_install, uninstall
+
+__all__ = ["HOSTS", "InstallError", "apply_plan", "plan_install", "uninstall"]

simplicio_loop-3.43.2/simplicio_loop/install/__main__.py

@@ -0,0 +1,38 @@
+"""python -m simplicio_loop.install --host claude --target DIR"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .planner import InstallError, apply_plan, plan_install, uninstall, verify_plan
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="simplicio-loop install")
+    parser.add_argument("--host", default="claude", help="host id or 'all'")
+    parser.add_argument("--target", default=".", help="project directory")
+    parser.add_argument("--global", dest="globally", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--verify", action="store_true")
+    parser.add_argument("--uninstall", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        if args.uninstall:
+            payload = uninstall(args.target)
+        else:
+            plan = plan_install(args.target, host=args.host, globally=args.globally)
+            if args.verify:
+                payload = verify_plan(plan)
+            else:
+                payload = apply_plan(plan, dry_run=args.dry_run)
+    except InstallError as exc:
+        print(json.dumps({"status": "BLOCKED", "error": str(exc)}), flush=True)
+        return 2
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())