superqode 0.2.1__tar.gz → 0.2.2__tar.gz

{superqode-0.2.1 → superqode-0.2.2}/CHANGELOG.md

@@ -17,6 +17,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - **Smoke script source checkout support** - Made the Omnigent agent-session smoke script import SuperQode reliably when run directly from a checkout.
+- **Harness model routing** - Made `model_policy.primary` override the active TUI connection for harness runs and added a clear local-provider warning when an MLX-tagged model is routed through Ollama.
+- **Harness wizard defaults** - Made Enter-through defaults in the TUI wizard create a runnable Qwen local harness with an explicit `ollama/qwen3-coder` model policy.
+- **Harness wizard loading** - Fixed the final “Load this harness now?” step so loaded harnesses remain visible after reconnect/disconnect state changes, and stale `SUPERQODE_HARNESS` paths no longer crash Pure Mode startup.
+- **Harness streaming** - Forwarded builtin harness `model_delta` events through Pure Mode so TUI harness runs no longer report `chunks=0` when the model did stream content.
 
 ### Changed
 

{superqode-0.2.1/src/superqode.egg-info → superqode-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 0.2.1
+Version: 0.2.2
 Summary: SuperQode: harness engineering framework for coding agents, optimized for local and open models
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-0.2.1 → superqode-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "0.2.1"
+version = "0.2.2"
 description = "SuperQode: harness engineering framework for coding agents, optimized for local and open models"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-0.2.1 → superqode-0.2.2}/src/superqode/__init__.py

@@ -30,4 +30,4 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{superqode-0.2.1 → superqode-0.2.2}/src/superqode/app_main.py

@@ -12042,7 +12042,11 @@ class SuperQodeApp(App):
                     answers["name"] = raw
                 self._harness_wizard_next(state, "starter")
             elif step == "starter":
-                starter = self._harness_wizard_choice(raw, [key for key, _ in self._wizard_starters()])
+                starter = self._harness_wizard_choice(
+                    raw,
+                    [key for key, _ in self._wizard_starters()],
+                    default=str(answers.get("starter") or "qwen-coding"),
+                )
                 if starter is None:
                     log.add_error("Choose a starter by number or name.")
                     self._render_harness_wizard_step(log)
@@ -14849,6 +14853,15 @@ class SuperQodeApp(App):
 
         provider = self._pure_mode.session.provider
         model = self._pure_mode.session.model
+        if getattr(self._pure_mode, "harness_enabled", False) and hasattr(
+            self._pure_mode, "_resolve_harness_route"
+        ):
+            try:
+                provider, model = self._pure_mode._resolve_harness_route()
+            except Exception:
+                # Let the run path raise the user-facing error with full context.
+                provider = self._pure_mode.session.provider
+                model = self._pure_mode.session.model
         plan_mode_for_run = bool(getattr(self, "_active_plan_mode_for_current_message", False))
         if plan_mode_for_run:
             text = (

{superqode-0.2.1 → superqode-0.2.2}/src/superqode/pure_mode.py

@@ -22,7 +22,11 @@ from .agent.system_prompts import SystemPromptLevel
 from .agent.session_manager import SessionManager, SessionMetadata
 from .tools.base import ToolRegistry, ToolResult
 from .providers.gateway.litellm_gateway import LiteLLMGateway
-from .providers.model_specs import normalize_model_for_provider, normalize_provider_id
+from .providers.model_specs import (
+    normalize_model_for_provider,
+    normalize_provider_id,
+    split_provider_model_ref,
+)
 from .providers.registry import PROVIDERS, ProviderTier, ProviderCategory
 from .runtime import AgentRuntime, create_runtime, resolve_runtime_name
 
@@ -87,6 +91,8 @@ class PureMode:
         path = os.getenv("SUPERQODE_HARNESS", "").strip()
         if not path:
             return
+        if not Path(path).expanduser().exists():
+            return
         self.load_harness(path)
 
     def load_harness(self, path: str | Path):
@@ -99,6 +105,7 @@ class PureMode:
         self._harness_kernel = None
         self._harness_session = None
         self._harness_session_id = ""
+        self._sync_harness_session_fields()
         return self._harness_spec
 
     def set_harness(self, spec, *, path: str | Path | None = None) -> None:
@@ -108,6 +115,7 @@ class PureMode:
         self._harness_kernel = None
         self._harness_session = None
         self._harness_session_id = ""
+        self._sync_harness_session_fields()
 
     def clear_harness(self) -> None:
         """Return to direct runtime mode."""
@@ -116,11 +124,57 @@ class PureMode:
         self._harness_kernel = None
         self._harness_session = None
         self._harness_session_id = ""
+        self.session.harness_name = ""
+        self.session.harness_path = ""
+        self.session.harness_flavor = ""
+        self.session.harness_runtime = ""
+
+    def _sync_harness_session_fields(self) -> None:
+        """Mirror the loaded HarnessSpec into user-visible session status."""
+        if self._harness_spec is None:
+            self.session.harness_name = ""
+            self.session.harness_path = ""
+            self.session.harness_flavor = ""
+            self.session.harness_runtime = ""
+            return
+        self.session.harness_name = self._harness_spec.name
+        self.session.harness_path = self._harness_path
+        self.session.harness_flavor = self._harness_spec.flavor.value
+        self.session.harness_runtime = self._harness_spec.runtime.backend
 
     @property
     def harness_enabled(self) -> bool:
         return self._harness_spec is not None
 
+    def _resolve_harness_route(self) -> tuple[str, str]:
+        """Return the provider/model the active harness should run against."""
+        provider = self.session.provider
+        model = self.session.model
+        if self._harness_spec is None:
+            return provider, model
+
+        primary = str(getattr(self._harness_spec.model_policy, "primary", "") or "").strip()
+        configured_provider = str(
+            getattr(self._harness_spec.model_policy, "config", {}).get("provider") or ""
+        ).strip()
+        if primary:
+            parsed = split_provider_model_ref(primary, default_provider=configured_provider)
+            provider = normalize_provider_id(parsed.provider or configured_provider or provider)
+            model = normalize_model_for_provider(provider, parsed.model or primary)
+
+        self._validate_harness_route(provider, model)
+        return provider, model
+
+    @staticmethod
+    def _validate_harness_route(provider: str, model: str) -> None:
+        """Catch common local provider/model mismatches before streaming."""
+        if provider == "ollama" and model.lower().endswith("-mlx"):
+            raise RuntimeError(
+                "The active harness is trying to run an MLX-tagged model through Ollama: "
+                f"ollama/{model}. Use the exact Ollama model tag from `ollama list`, or set "
+                "`model_policy.primary: mlx/<model>` and connect with the MLX provider."
+            )
+
     def get_providers_for_picker(self) -> List[Dict[str, Any]]:
         """Get providers formatted for the TUI picker."""
         providers = []
@@ -271,6 +325,7 @@ class PureMode:
         self._harness_kernel = None
         self._harness_session = None
         self._harness_session_id = ""
+        self._sync_harness_session_fields()
 
     def set_system_level(self, level: SystemPromptLevel):
         """Change the system prompt level."""
@@ -282,11 +337,12 @@ class PureMode:
     async def run(self, prompt: str, plan_mode: Optional[bool] = None) -> AgentResponse:
         """Run a task in Pure Mode."""
         if self._harness_spec is not None:
+            provider, model = self._resolve_harness_route()
             session = await self._ensure_harness_session()
             result = await session.prompt(
                 prompt,
-                provider=self.session.provider,
-                model=self.session.model,
+                provider=provider,
+                model=model,
                 working_directory=self.session.working_directory,
                 runtime=self._harness_spec.runtime.backend,
             )
@@ -336,15 +392,16 @@ class PureMode:
     async def run_streaming(self, prompt: str, plan_mode: Optional[bool] = None):
         """Run a task with streaming output."""
         if self._harness_spec is not None:
+            provider, model = self._resolve_harness_route()
             session = await self._ensure_harness_session()
             async for event in session.stream(
                 prompt,
-                provider=self.session.provider,
-                model=self.session.model,
+                provider=provider,
+                model=model,
                 working_directory=self.session.working_directory,
                 runtime=self._harness_spec.runtime.backend,
             ):
-                if event.type != "delta":
+                if event.type not in {"delta", "model_delta"}:
                     continue
                 chunk = str(event.data.get("text", ""))
                 if self.on_stream_chunk:

{superqode-0.2.1 → superqode-0.2.2/src/superqode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 0.2.1
+Version: 0.2.2
 Summary: SuperQode: harness engineering framework for coding agents, optimized for local and open models
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-0.2.1 → superqode-0.2.2}/tests/test_harness_kernel.py

@@ -1,5 +1,6 @@
 """Tests for the minimal v2 HarnessKernel."""
 
+from dataclasses import replace
 from pathlib import Path
 
 from pydantic import BaseModel
@@ -10,6 +11,7 @@ from superqode.harness import (
     FileHarnessStore,
     HarnessBackendResult,
     HarnessFlavor,
+    ModelPolicySpec,
     get_harness_template,
     init_harness,
 )
@@ -151,6 +153,16 @@ class FakeApprovalBackend(FakeBackend):
         )
 
 
+class FakeModelDeltaBackend:
+    async def stream(self, request):
+        from superqode.harness import HarnessEvent
+
+        yield HarnessEvent(type="model_request", data={"runtime": "fake"})
+        yield HarnessEvent(type="model_delta", data={"text": "hello"})
+        yield HarnessEvent(type="model_delta", data={"text": "-streamed"})
+        yield HarnessEvent(type="end", data={"runtime": "fake"})
+
+
 @pytest.mark.asyncio
 async def test_no_tool_kernel_runs_with_empty_registry(monkeypatch, tmp_path: Path):
     backend = FakeBackend()
@@ -308,6 +320,91 @@ async def test_pure_mode_can_stream_through_harness_spec(monkeypatch, tmp_path:
     assert status["harness"]["name"] == spec.name
 
 
+@pytest.mark.asyncio
+async def test_pure_mode_harness_primary_overrides_active_connection(monkeypatch, tmp_path: Path):
+    from superqode.pure_mode import PureMode
+
+    created = {}
+
+    def fake_create_runtime(name, **kwargs):
+        created["config"] = kwargs["config"]
+        return FakeRuntime(**kwargs)
+
+    monkeypatch.setattr("superqode.harness.backends.runtime.create_runtime", fake_create_runtime)
+    spec = replace(
+        get_harness_template("no-tool"),
+        model_policy=ModelPolicySpec(primary="mlx/qwen3.6:35b-mlx"),
+    )
+    pure = PureMode()
+    pure.set_harness(spec)
+    assert pure.connect("ollama", "qwen3.6:35b-a3b", working_directory=tmp_path)
+
+    chunks = [chunk async for chunk in pure.run_streaming("hello")]
+
+    assert "".join(chunks) == "hello-streamed"
+    assert created["config"].provider == "mlx"
+    assert created["config"].model == "qwen3.6:35b-mlx"
+
+
+def test_pure_mode_harness_warns_for_ollama_mlx_model(tmp_path: Path):
+    from superqode.pure_mode import PureMode
+
+    pure = PureMode()
+    pure.set_harness(get_harness_template("no-tool"))
+    assert pure.connect("ollama", "qwen3.6:35b-mlx", working_directory=tmp_path)
+
+    with pytest.raises(RuntimeError, match="MLX-tagged model through Ollama"):
+        pure._resolve_harness_route()
+
+
+def test_pure_mode_set_harness_updates_visible_status(tmp_path: Path):
+    from superqode.pure_mode import PureMode
+
+    spec = get_harness_template("qwen-coding")
+    pure = PureMode()
+    pure.set_harness(spec, path=tmp_path / "harness.yaml")
+
+    status = pure.get_status()["harness"]
+    assert status["enabled"] is True
+    assert status["name"] == "qwen-coding"
+    assert status["path"].endswith("harness.yaml")
+    assert status["flavor"] == "coding"
+    assert status["runtime"] == "builtin"
+
+
+def test_pure_mode_disconnect_preserves_loaded_harness_status(tmp_path: Path):
+    from superqode.pure_mode import PureMode
+
+    spec = get_harness_template("qwen-coding")
+    pure = PureMode()
+    pure.set_harness(spec, path=tmp_path / "harness.yaml")
+    assert pure.connect("ollama", "qwen3-coder", working_directory=tmp_path)
+
+    pure.disconnect()
+
+    status = pure.get_status()["harness"]
+    assert status["enabled"] is True
+    assert status["name"] == "qwen-coding"
+    assert status["path"].endswith("harness.yaml")
+
+
+@pytest.mark.asyncio
+async def test_pure_mode_harness_stream_forwards_model_delta_events(monkeypatch, tmp_path: Path):
+    from superqode.pure_mode import PureMode
+
+    monkeypatch.setattr(
+        "superqode.harness.kernel.create_harness_backend",
+        lambda name: FakeModelDeltaBackend(),
+    )
+    pure = PureMode()
+    pure.set_harness(get_harness_template("qwen-coding"), path=tmp_path / "harness.yaml")
+    assert pure.connect("ollama", "qwen3-coder", working_directory=tmp_path)
+
+    chunks = [chunk async for chunk in pure.run_streaming("hello")]
+
+    assert chunks == ["hello", "-streamed"]
+
+
 @pytest.mark.asyncio
 async def test_pure_mode_resumes_harness_approval(monkeypatch, tmp_path: Path):
     from superqode.pure_mode import PureMode

{superqode-0.2.1 → superqode-0.2.2}/tests/test_tui_smoke.py

@@ -1213,6 +1213,50 @@ def test_tui_harness_wizard_guided_steps_write_and_load_spec(tmp_path, monkeypat
     assert app._pure_mode.harness_enabled
 
 
+def test_tui_harness_wizard_enter_defaults_create_runnable_spec(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    app = make_app()
+    log = FakeLog()
+    app._show_command_output = lambda target_log, content, clear_log=True: target_log.write(content)
+
+    app._harness_cmd("wizard", log)
+    for _ in range(10):
+        app._handle_harness_wizard_input("", log)
+
+    spec = load_harness_spec(tmp_path / "harness.yaml")
+    assert spec.name == "my-harness"
+    assert spec.metadata["template"] == "qwen-coding"
+    assert spec.model_policy.primary == "ollama/qwen3-coder"
+    assert spec.model_policy.pack == "qwen-coder"
+    assert app._awaiting_harness_wizard is False
+    assert app._pure_mode is not None
+    assert app._pure_mode.harness_enabled
+
+
+def test_tui_harness_wizard_final_yes_loads_and_exits(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    app = make_app()
+    log = FakeLog()
+    app._show_command_output = lambda target_log, content, clear_log=True: target_log.write(content)
+
+    app._harness_cmd("wizard", log)
+    for _ in range(9):
+        app._handle_harness_wizard_input("", log)
+    assert "Load this harness now" in render_plain(log.items[-1])
+
+    app._handle_harness_wizard_input("yes", log)
+
+    assert app._awaiting_harness_wizard is False
+    assert app._harness_wizard_state is None
+    assert app._pure_mode is not None
+    status = app._pure_mode.get_status()["harness"]
+    assert status["enabled"] is True
+    assert status["name"] == "my-harness"
+    assert status["path"].endswith("harness.yaml")
+    rendered = "\n".join(render_plain(item) if not isinstance(item, str) else item for item in log.items)
+    assert "Loaded harness my-harness" in rendered
+
+
 def test_tui_help_surfaces_developer_workflows():
     app = make_app()
     log = FakeLog()