superqode 2.5.6__tar.gz → 2.6.0__tar.gz

{superqode-2.5.6 → superqode-2.6.0}/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.6.0] - 2026-10-05
+
+### Added
+
+- Durable branch-scoped RLM history with searchable, paged observations and
+  experimental selective context projection. Full session records remain intact.
+- One inference ledger and call allowance shared by root, recursive coding
+  children and semantic queries, with reported token and USD thresholds,
+  restart persistence and explicit unknown-usage reconciliation.
+- Experimental Python+Bash RLM profiles for host and Docker. Both tools share
+  the persistent environment and sandbox. Command jobs have bounded durable
+  output, idempotent admission, deadlines, process-group cancellation and
+  explicit recovery when the outcome is unknown.
+- RLM settings in `:connect`, with tool surface, sandbox, observations and
+  inference limits. Inspect profiles, family usage, history and command jobs
+  while the resident worker is running. A2A remains opt-in and retains its
+  separate hosted credit policy.
+- A coding profile pilot runner with fresh workspaces, independent graders,
+  per-attempt usage and offline execution fixtures. Experimental profiles have
+  no demonstrated model quality or cost improvement yet.
+
+### Changed
+
+- Native Python remains the default RLM surface. Monty stays a read-only
+  research profile; Python+Bash requires host POSIX process groups or Docker.
+- RLM run reports include recursive inference usage. Missing provider prices
+  and remote A2A usage are shown as unknown instead of zero cost.
+
 ## [2.5.6] - 2026-10-04
 
 ### Added

{superqode-2.5.6 → superqode-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.5.6
+Version: 2.6.0
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

superqode-2.6.0/examples/rlm-profile-eval/README.md

@@ -0,0 +1,42 @@
+# Native RLM profile coding pilot
+
+Run the offline execution smoke test without provider calls:
+
+```bash
+python -m superqode.rlm.evaluation \
+  --tasks examples/rlm-profile-eval/tasks.json \
+  --output /tmp/rlm-profile-smoke --repetitions 2
+```
+
+Use an empty output directory. Each attempt gets a fresh workspace and an
+independent grader whose source is supplied externally. Modified code is
+graded inside the selected execution boundary, including Docker; it is never
+imported on the host for a Docker attempt. Grader processes have bounded output
+and process-group deadlines. Outputs include
+`attempts.jsonl`, `scorecard.json`, session logs and a shared inference ledger.
+Attempts record the task digest, profile settings, provider/model, usage and time.
+
+A live pilot requires explicit model selection and reported-spend limits:
+
+```bash
+python -m superqode.rlm.evaluation \
+  --tasks examples/rlm-profile-eval/tasks.json \
+  --output /tmp/rlm-profile-live --live \
+  --provider YOUR_PROVIDER --model YOUR_MODEL \
+  --max-cost-usd 5 --max-calls 100 --repetitions 2 \
+  --profiles python hybrid selective hybrid-selective --sandbox docker
+```
+
+The provider must be configured in the environment used to run SuperQode. Provider
+credentials remain outside Docker. The Docker image must have the dependencies
+needed by the fixture. Host Python+Bash requires a POSIX host with Bash.
+
+A USD threshold stops subsequent requests after provider-reported charges. The
+current request may exceed it; this is not an absolute provider billing cap.
+Missing prices stop the live pilot and remain unknown in the scorecard. A2A is
+not enabled by this runner.
+
+The 12 bundled tasks exercise small single-file Python bug fixes. Scripted edits
+are supplied solely for the offline smoke test. Offline passes do not measure
+model quality or cost. Live results are exploratory; add representative repository
+tasks and repeated measurements before promoting an experimental profile.

{superqode-2.5.6 → superqode-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.5.6"
+version = "2.6.0"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.5.6"
+__version__ = "2.6.0"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/app/constants.py

@@ -413,6 +413,12 @@ COMMANDS = [
     ":rlm autonomous",
     ":rlm sandbox",
     ":rlm usage",
+    ":rlm settings",
+    ":rlm profile",
+    ":rlm budget",
+    ":rlm history",
+    ":rlm jobs",
+    ":rlm job",
     ":rlm agents",
     ":rlm a2a",
     ":rlm routing",

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/app/mixins/agent_run.py

@@ -1085,7 +1085,7 @@ class AgentRunMixin:
                     stats.get("prompt_tokens", 0),
                     stats.get("completion_tokens", 0),
                     stats.get("thinking_tokens", 0),
-                    stats.get("total_cost", 0.0),
+                    stats.get("cost_usd", stats.get("total_cost", 0.0)),
                 )
                 if hasattr(self._pure_mode, "get_pending_approvals"):
                     self._announce_pending_approvals(self._pure_mode, log)

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/app/mixins/connect.py

@@ -2178,6 +2178,19 @@ class ConnectMixin:
                 spec=spec,
                 on_back=lambda: self._show_connect_type_picker(log, menu=CONNECT_MENU_RLM),
             )
+        elif conn == "rlm-settings":
+            from superqode.harness.templates import get_harness_template
+            from superqode.providers.connection_profiles import CONNECT_MENU_RLM
+
+            pure = getattr(self, "_pure_mode", None)
+            spec = getattr(pure, "_harness_spec", None)
+            if getattr(getattr(spec, "runtime", None), "backend", "") != "rlm":
+                spec = get_harness_template("rlm")
+            self._open_rlm_settings(
+                log,
+                spec=spec,
+                on_back=lambda: self._show_connect_type_picker(log, menu=CONNECT_MENU_RLM),
+            )
         elif conn == "harness-catalog":
             # Remember the entry point so Esc returns to the harness step.
             self._harness_picker_from_connect = True

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/app/mixins/rlm_commands.py

@@ -8,6 +8,12 @@ from typing import Any
 from superqode.app.constants import THEME
 
 _COMMANDS = (
+    ("settings", "Configure tools, sandbox, observations and shared budgets for a new session"),
+    ("profile", "Show the active tool and observation profile"),
+    ("budget", "Show the shared inference allowance and unsettled usage"),
+    ("history", "Search branch history or read a handle: history read <id> [start] [size]"),
+    ("jobs", "List durable command jobs"),
+    ("job", "Inspect, read, wait, cancel or reconcile a command job"),
     ("status", "Show the resident root worker and active turn"),
     ("attach", "Attach to the active resident RLM turn"),
     ("detach", "Leave the worker running without cancelling it"),
@@ -58,8 +64,58 @@ class RLMCommandMixin:
         if sub == "a2a":
             self._open_rlm_routing(log)
             return
+        if sub == "settings":
+            self._open_rlm_settings(log)
+            return
         getattr(self, "run_worker")(self._rlm_run(sub, rest, log), exclusive=False)
 
+    def _open_rlm_settings(self, log, *, spec=None, on_back=None):
+        from superqode.widgets.rlm_settings import RLMSettingsScreen
+
+        pure = getattr(self, "_pure_mode", None)
+        spec = spec or getattr(pure, "_harness_spec", None)
+        config = dict(getattr(getattr(spec, "runtime", None), "config", None) or {})
+
+        def selected(result):
+            if result is None:
+                if on_back is not None:
+                    on_back()
+                return
+            try:
+                import shlex
+                from superqode.app.rlm_routing import save_runtime_profile
+
+                if result.action == "start" and getattr(self, "is_busy", False):
+                    raise ValueError(
+                        "Wait for the current turn to finish before starting a new session"
+                    )
+                mode = getattr(self, "_pure_mode", None) or self._ensure_pure_mode()
+                root = Path(getattr(mode.session, "working_directory", None) or Path.cwd())
+                path = save_runtime_profile(spec, result.config, root)
+                log.add_success(f"RLM profile saved: {path}")
+                if result.action == "start":
+                    fork = " --fork" if mode.get_current_session_id() else ""
+                    self._harness_cmd(f"switch {shlex.quote(str(path))}{fork}", log)
+                else:
+                    log.add_info(
+                        f"Activate in a new session with :harness switch {shlex.quote(str(path))} --fork"
+                    )
+            except Exception as error:
+                log.add_error(f"RLM setup failed: {error}")
+
+        try:
+            from superqode.rlm.sandbox import RLMSandboxConfig
+
+            config = {
+                **config,
+                **RLMSandboxConfig.from_config(
+                    config, execution_policy=getattr(spec, "execution_policy", None)
+                ).to_dict(),
+            }
+            self.push_screen(RLMSettingsScreen(config), callback=selected)
+        except ValueError as error:
+            log.add_error(f"Invalid RLM profile: {error}")
+
     def _open_rlm_routing(self, log, *, spec=None, on_back=None) -> None:
         from superqode.widgets.rlm_routing import RLMRoutingScreen
 
@@ -168,7 +224,7 @@ class RLMCommandMixin:
         text.append("\n  ◈ ", style=f"bold {THEME['purple']}")
         text.append("RLM\n", style=f"bold {THEME['text']}")
         text.append(
-            "  Native recursive coding with one persistent Python tool.\n\n",
+            "  Native recursive coding with persistent Python and optional Bash.\n\n",
             style=THEME["muted"],
         )
         width = max(len(name) for name, _ in _COMMANDS)
@@ -301,7 +357,9 @@ class RLMCommandMixin:
             log.add_info(f"id       {info.id}")
             log.add_info(f"path     {session.session_path}")
             log.add_info(f"messages {info.message_count}")
-            log.add_info("tools    python (serializable state checkpointed)")
+            log.add_info(
+                f"tools    {', '.join(getattr(getattr(session, 'profile', None), 'tools', ('python',)))} (serializable state checkpointed)"
+            )
             log.add_info("workers  detached Python processes with journal reattachment")
             log.add_info(f"sandbox  {self._rlm_sandbox_config(session).backend} (:rlm sandbox)")
             return

superqode-2.6.0/src/superqode/app/rlm_routing.py

@@ -0,0 +1,68 @@
+"""Persist new RLM routing profiles without changing an existing worker."""
+
+from copy import deepcopy
+from dataclasses import replace
+from pathlib import Path
+from uuid import uuid4
+
+from superqode.harness.loader import save_harness_spec
+from superqode.rlm.delegation_policy import DelegationPolicy
+
+
+def save_routing_profile(spec, config: dict, root: Path) -> Path:
+    if spec is None or spec.runtime.backend != "rlm":
+        raise ValueError("Select a native RLM harness before configuring A2A.")
+    DelegationPolicy.from_config(config)
+    name = f"rlm-routing-{uuid4().hex[:12]}"
+    profile = replace(
+        spec,
+        name=name,
+        description="Native RLM with explicitly configured optional A2A routing.",
+        runtime=replace(
+            spec.runtime, config={**deepcopy(spec.runtime.config), "a2a": deepcopy(config)}
+        ),
+        metadata={**deepcopy(spec.metadata), "customized_from": spec.name},
+    )
+    return save_harness_spec(profile, root / ".superqode" / "harnesses" / f"{name}.yaml")
+
+
+def save_runtime_profile(spec, config: dict, root: Path) -> Path:
+    from superqode.rlm.budget import BudgetPolicy
+    from superqode.rlm.profile import RLMProfile
+    from superqode.rlm.sandbox import RLMSandboxConfig
+
+    if spec is None or spec.runtime.backend != "rlm":
+        raise ValueError("Select a native RLM harness before configuring its profile")
+    selected = RLMProfile.from_config(config)
+    sandbox = RLMSandboxConfig.from_config(config, execution_policy=spec.execution_policy)
+    selected.validate_sandbox(sandbox)
+    BudgetPolicy.from_config(config.get("budget"))
+    DelegationPolicy.from_config(config.get("a2a"))
+    name = f"rlm-profile-{uuid4().hex[:12]}"
+    profile = replace(
+        spec,
+        name=name,
+        description=f"Native RLM: {selected.tool_surface}, {selected.observations} observations.",
+        runtime=replace(spec.runtime, config=deepcopy(config)),
+        execution_policy=replace(
+            spec.execution_policy,
+            sandbox=sandbox.backend,
+            allow_read=sandbox.policy.allow_read,
+            allow_write=sandbox.policy.allow_write,
+            allow_shell=sandbox.policy.allow_shell,
+            allow_network=sandbox.allow_network,
+        ),
+        agents=tuple(replace(agent, tools=selected.tools) for agent in spec.agents),
+        metadata={
+            **deepcopy(spec.metadata),
+            "customized_from": spec.name,
+            "model_tool_count": len(selected.tools),
+            "pure_permissions": not sandbox.isolated,
+            "selection_warning": "Host execution uses process permissions."
+            if not sandbox.isolated
+            else f"{sandbox.backend} execution boundary; networking {'on' if sandbox.allow_network else 'off'}.",
+            "experimental": selected.tool_surface != "python"
+            or selected.observations != "transcript",
+        },
+    )
+    return save_harness_spec(profile, root / ".superqode" / "harnesses" / f"{name}.yaml")

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/app/widgets.py

@@ -3529,10 +3529,10 @@ class ConversationLog(RichLog):
         self,
         success: bool = True,
         response_text: str = "",
-        prompt_tokens: int = 0,
-        completion_tokens: int = 0,
+        prompt_tokens: int | None = 0,
+        completion_tokens: int | None = 0,
         thinking_tokens: int = 0,
-        cost: float = 0.0,
+        cost: float | None = 0.0,
     ):
         """
         End the agent output session with a rich Mission Report summary.
@@ -3591,7 +3591,7 @@ class ConversationLog(RichLog):
             tool_counts[name] = tool_counts.get(name, 0) + 1
 
         files_mod = getattr(self, "_files_modified", set())
-        total_tokens = prompt_tokens + completion_tokens
+        total_tokens = (prompt_tokens or 0) + (completion_tokens or 0)
 
         stats_line = []
         if duration > 0:
@@ -3600,9 +3600,13 @@ class ConversationLog(RichLog):
             stats_line.append(f"{sum(tool_counts.values())} tools")
         if files_mod:
             stats_line.append(f"{len(files_mod)} changed")
-        if total_tokens > 0:
+        if prompt_tokens is None or completion_tokens is None:
+            stats_line.append("tokens unknown")
+        elif total_tokens > 0:
             stats_line.append(f"{total_tokens:,} toks")
-        if cost > 0:
+        if cost is None:
+            stats_line.append("cost unknown")
+        elif cost > 0:
             stats_line.append(f"${cost:.4f}")
 
         if stats_line:

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/harness/backends/rlm.py

@@ -39,6 +39,7 @@ class RLMHarnessBackend:
         tool_calls = 0
         turns = 0
         usage: dict[str, Any] = {}
+        family_usage = None
         stopped_reason = "complete"
         error: str | None = None
         async for event in self._events(request):
@@ -55,6 +56,25 @@ class RLMHarnessBackend:
             elif event.type in {"error", "run.failed"}:
                 stopped_reason = "error"
                 error = str(event.data.get("error") or "RLM run failed")
+            elif event.type == "rlm.usage":
+                family_usage = event.data
+        if family_usage is not None:
+            total = family_usage["total"]
+            usage = {
+                "input_tokens": total.get("input_tokens")
+                if not total.get("unknown_token_calls")
+                else None,
+                "output_tokens": total.get("output_tokens")
+                if not total.get("unknown_token_calls")
+                else None,
+                "total_tokens": total.get("tokens")
+                if not total.get("unknown_token_calls")
+                else None,
+                "cost_usd": total.get("cost_usd")
+                if not total.get("unknown_cost_calls")
+                and family_usage.get("remote_usage_known", True)
+                else None,
+            }
         response = AgentResponse(
             content="".join(text),
             messages=[],
@@ -74,7 +94,8 @@ class RLMHarnessBackend:
             runtime=self.name,
             metadata={
                 "events": events,
-                "model_tools": ["python"],
+                "model_tools": _model_tools(request),
+                "rlm_usage": family_usage,
                 "persistent_python": True,
                 "pure_permissions": _pure_permissions(request),
             },
@@ -125,6 +146,12 @@ def _pure_permissions(request: HarnessBackendRequest) -> bool:
     ).isolated
 
 
+def _model_tools(request):
+    from superqode.rlm.profile import RLMProfile
+
+    return list(RLMProfile.from_config(request.spec.runtime.config).tools)
+
+
 def _accumulate(totals: dict[str, Any], raw: dict[str, Any]) -> dict[str, Any]:
     merged = dict(totals)
     for key, value in raw.items():

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/harness/hub.py

@@ -742,6 +742,15 @@ _LANGUAGE_BY_ID: dict[str, HubLanguage] = {
         "confirmed",
         "Runs in the SuperQode engine (SuperagenticAI/superqode, Python).",
     ),
+    "rlm-hybrid": HubLanguage(
+        "Python", "confirmed", "Native SuperQode RLM with Python and Bash tool surfaces."
+    ),
+    "rlm-hybrid-docker": HubLanguage(
+        "Python", "confirmed", "Native SuperQode RLM with Python and Bash inside Docker."
+    ),
+    "rlm-selective": HubLanguage(
+        "Python", "confirmed", "Native SuperQode RLM with selective observations."
+    ),
     "rlm-monty": HubLanguage(
         "Python",
         "confirmed",
@@ -1496,7 +1505,16 @@ def _native_details(item: HarnessPickerItem) -> dict[str, Any]:
         **_spec_lifecycle_commands(item_reference),
     }
     if item.runtime == "rlm":
-        details["tui_commands"] += (":rlm a2a", ":rlm routing", ":rlm delegations")
+        details["tui_commands"] += (
+            ":rlm settings",
+            ":rlm profile",
+            ":rlm budget",
+            ":rlm history",
+            ":rlm jobs",
+            ":rlm a2a",
+            ":rlm routing",
+            ":rlm delegations",
+        )
     if item.id == "uhp":
         details.update(
             install_command=":connect uhp",

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/harness/rlm_adapter.py

@@ -90,7 +90,7 @@ class RLMHarnessProtocolAdapter:
                 "model": request.model,
                 "working_directory": str(working_directory),
                 "session_path": str(coding_session.session_path),
-                "model_tools": list(DEFAULT_TOOLS),
+                "model_tools": list(_model_tools(request.metadata)),
                 "persistent_python": True,
                 "pure_permissions": pure_permissions,
             },
@@ -142,7 +142,7 @@ class RLMHarnessProtocolAdapter:
             metadata={
                 **metadata,
                 "session_path": str(coding_session.session_path),
-                "model_tools": list(DEFAULT_TOOLS),
+                "model_tools": list(_model_tools(metadata)),
                 "pure_permissions": _pure_permissions(metadata),
             },
         )
@@ -169,7 +169,7 @@ class RLMHarnessProtocolAdapter:
             "provider": request.provider,
             "model": request.model,
             "working_directory": str(working_directory),
-            "model_tools": list(DEFAULT_TOOLS),
+            "model_tools": list(_model_tools(request.metadata)),
             "persistent_python": True,
             "pure_permissions": _pure_permissions(request.metadata),
             "resident_root": True,
@@ -213,6 +213,8 @@ class RLMHarnessProtocolAdapter:
         from superqode.rlm.context import ContextPolicy
         from superqode.rlm.sandbox import RLMSandboxConfig
         from superqode.rlm.subcalls import SubcallPolicy
+        from superqode.rlm.profile import RLMProfile
+        from superqode.rlm.budget import BudgetPolicy
 
         limits = dict(request.metadata.get("rlm_config") or {})
         # The backend resolves the profile once, where the HarnessSpec and its
@@ -222,7 +224,7 @@ class RLMHarnessProtocolAdapter:
         options = RLMCodingSessionOptions(
             cwd=working_directory,
             model=resolve_model(request.model or "", provider=request.provider or ""),
-            tool_names=DEFAULT_TOOLS,
+            tool_names=RLMProfile.from_config(limits).tools,
             max_depth=int(limits.get("max_depth", 3)),
             max_children=int(limits.get("max_children", 8)),
             max_parallel=int(limits.get("max_parallel", 4)),
@@ -236,6 +238,8 @@ class RLMHarnessProtocolAdapter:
             subcall_policy=SubcallPolicy.from_config(limits),
             context_policy=ContextPolicy.from_config(limits),
             a2a_config=limits.get("a2a"),
+            profile=RLMProfile.from_config(limits),
+            budget_policy=BudgetPolicy.from_config(limits.get("budget")),
         )
         if session_path and Path(session_path).is_file():
             return await RLMCodingSession.resume(options, session_path=session_path)
@@ -256,6 +260,28 @@ class RLMHarnessProtocolAdapter:
                 yield event
             return
         coding_session = await self._require(session)
+        budget = getattr(coding_session, "budget", None)
+        before = budget.snapshot() if budget is not None else None
+        manager = getattr(coding_session, "delegation_manager", None)
+        remote_before = len(manager.store.records(manager.root)) if manager is not None else 0
+        async for event in self._send_inprocess(coding_session, message):
+            if event.type in {"run_end", "run.failed"} and budget is not None:
+                from superqode.rlm.budget import usage_delta
+
+                remote_after = (
+                    len(manager.store.records(manager.root)) if manager is not None else 0
+                )
+                yield HarnessEvent(
+                    type="rlm.usage",
+                    data={
+                        **usage_delta(before, budget.snapshot()),
+                        "remote_tasks": remote_after - remote_before,
+                        "remote_usage_known": remote_after == remote_before,
+                    },
+                )
+            yield event
+
+    async def _send_inprocess(self, coding_session, message):
         model = coding_session.harness.get_model()
         yield HarnessEvent(
             type="model.requested",
@@ -323,6 +349,17 @@ class RLMHarnessProtocolAdapter:
                     )
                     return
             policy = coding_session.policy
+            command_errors = (
+                await coding_session.command_completion_errors()
+                if hasattr(coding_session, "command_completion_errors")
+                else []
+            )
+            if command_errors:
+                yield HarnessEvent(
+                    type="run.failed",
+                    data={"error": "; ".join(command_errors), "error_type": "CommandIncomplete"},
+                )
+                return
             if not policy.autonomous or not policy.gates:
                 yield HarnessEvent(type="run_end", data={"status": "completed"})
                 return
@@ -514,4 +551,10 @@ def _read_index(index: Path) -> dict[str, str]:
     )
 
 
+def _model_tools(metadata):
+    from superqode.rlm.profile import RLMProfile
+
+    return RLMProfile.from_config(metadata.get("rlm_config")).tools
+
+
 __all__ = ["DEFAULT_TOOLS", "RLMHarnessProtocolAdapter"]

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/harness/templates.py

@@ -350,6 +350,60 @@ def rlm_docker_template(*, name: str = "rlm-docker") -> HarnessSpec:
     )
 
 
+def rlm_hybrid_template(*, name: str = "rlm-hybrid") -> HarnessSpec:
+    """Experimental Python+Bash surface over the native RLM core."""
+    from dataclasses import replace
+
+    base = rlm_template(name=name)
+    return replace(
+        base,
+        description="Experimental native RLM with persistent Python, explicit Bash jobs and shared history. Host execution; A2A off.",
+        runtime=replace(
+            base.runtime, config={**base.runtime.config, "tool_surface": "python-bash"}
+        ),
+        agents=(AgentSpec(id="rlm", role="recursive-coding", tools=("python", "bash")),),
+        metadata={
+            **base.metadata,
+            "template": "rlm-hybrid",
+            "experimental": True,
+            "model_tool_count": 2,
+        },
+    )
+
+
+def rlm_hybrid_docker_template(*, name: str = "rlm-hybrid-docker") -> HarnessSpec:
+    from dataclasses import replace
+
+    base = rlm_docker_template(name=name)
+    hybrid = rlm_hybrid_template(name=name)
+    return replace(
+        base,
+        description="Experimental Python+Bash RLM inside Docker. Networking off; A2A off.",
+        agents=hybrid.agents,
+        runtime=replace(
+            base.runtime, config={**base.runtime.config, "tool_surface": "python-bash"}
+        ),
+        metadata={
+            **base.metadata,
+            "template": "rlm-hybrid-docker",
+            "experimental": True,
+            "model_tool_count": 2,
+        },
+    )
+
+
+def rlm_selective_template(*, name: str = "rlm-selective") -> HarnessSpec:
+    from dataclasses import replace
+
+    base = rlm_template(name=name)
+    return replace(
+        base,
+        description="Experimental native RLM with selective stored observations and branch-scoped history. Host execution; A2A off.",
+        runtime=replace(base.runtime, config={**base.runtime.config, "observations": "selective"}),
+        metadata={**base.metadata, "template": "rlm-selective", "experimental": True},
+    )
+
+
 def rlm_monty_template(*, name: str = "rlm-monty") -> HarnessSpec:
     """Native RLM restricted to read-only analysis under Pydantic Monty."""
     base = rlm_template(name=name)
@@ -968,6 +1022,9 @@ BUILTIN_TEMPLATES = {
     "pipy": pipy_template,
     "rlm": rlm_template,
     "rlm-docker": rlm_docker_template,
+    "rlm-hybrid": rlm_hybrid_template,
+    "rlm-hybrid-docker": rlm_hybrid_docker_template,
+    "rlm-selective": rlm_selective_template,
     "rlm_docker": rlm_docker_template,
     "rlm-monty": rlm_monty_template,
     "rlm_monty": rlm_monty_template,

{superqode-2.5.6 → superqode-2.6.0}/src/superqode/providers/connection_profiles.py

@@ -627,6 +627,42 @@ _RLM_PROFILES: List[ConnectionProfile] = [
         menu=CONNECT_MENU_RLM,
         detect=lambda: True,
     ),
+    ConnectionProfile(
+        id="rlm-hybrid",
+        label="Try RLM Python + Bash",
+        description="Experimental two-tool profile. Persistent Python and durable Bash jobs on host; A2A off",
+        connector="harness-use",
+        runtime="rlm-hybrid",
+        menu=CONNECT_MENU_RLM,
+        detect=lambda: True,
+    ),
+    ConnectionProfile(
+        id="rlm-hybrid-docker",
+        label="Try RLM Python + Bash in Docker",
+        description="Experimental two-tool profile inside Docker. Networking off; A2A off",
+        connector="harness-use",
+        runtime="rlm-hybrid-docker",
+        menu=CONNECT_MENU_RLM,
+        detect=lambda: True,
+    ),
+    ConnectionProfile(
+        id="rlm-selective",
+        label="Try RLM selective context",
+        description="Experimental stored observations with bounded previews and branch-scoped history reads",
+        connector="harness-use",
+        runtime="rlm-selective",
+        menu=CONNECT_MENU_RLM,
+        detect=lambda: True,
+    ),
+    ConnectionProfile(
+        id="rlm-settings",
+        label="Configure RLM profile and budgets",
+        description="Choose tools, sandbox, observation mode and shared model-call/spend limits",
+        connector="rlm-settings",
+        runtime="rlm",
+        menu=CONNECT_MENU_RLM,
+        detect=lambda: True,
+    ),
 ]
 
 # Step two: where the model comes from. Each answers that one question.