superqode 0.2.1__tar.gz → 0.2.3__tar.gz

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

@@ -7,20 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.2.1] - 2026-06-24
+## [0.2.3] - 2026-06-24
 
 ### Added
 
 - **TUI harness wizard** - Added a step-by-step `:harness wizard` flow for creating starter HarnessSpec files from the TUI, plus `:harness init` / flag shortcuts using the same wizard builder as the CLI.
 - **TUI CLI parity** - Exposed the remaining CLI command surface in the TUI command list and routed unsupported subcommands through the CLI runner so CLI-only workflows can be launched from the TUI.
+- **First harness documentation** - Documented the TUI and CLI wizard path for creating, loading, checking, and running a first HarnessSpec in a few steps.
 
 ### 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 while preserving valid Ollama model tags such as `*-mlx`.
+- **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 final prompt** - Treated `yes`/`no` typed on the output-file step as the final load answer so the wizard no longer stores `yes` as a filename and loops back to the output prompt.
+- **Harness wizard output paths** - Picked the next available default output path such as `harness-2.yaml` when `harness.yaml` already exists, preventing default runs from bouncing back to the output prompt.
+- **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
 
-- **Release metadata** - Bumped the package version and runtime `__version__` to `0.2.1`.
+- **Release metadata** - Bumped the package version and runtime `__version__` to `0.2.3`.
 
 ## [0.2.0] - 2026-06-23
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 0.2.1
+Version: 0.2.3
 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>
@@ -230,7 +230,7 @@ Inside the TUI, the local-first MVP path is:
 | File | Purpose | Created by |
 | --- | --- | --- |
 | `superqode.yaml` | Project configuration: providers, endpoints, MCP, memory, defaults | `superqode config init` or `:init` |
-| `harness.yaml` | Portable agent run contract | `superqode harness init ...` |
+| `harness.yaml` | Portable agent run contract | `:harness wizard`, `superqode harness wizard`, or `superqode harness init ...` |
 | `superqode.local.yaml` | Local-first HarnessSpec generated for this machine | `:local init` or `superqode local init --repo .` |
 | `superqode.airplane.yaml` | Strict no-network HarnessSpec for offline local work | `:local airplane prepare` or `superqode local airplane prepare` |
 
@@ -242,7 +242,26 @@ superqode --print "inspect this repository and suggest the smallest next step"
 
 ### Your First Harness Run
 
-A harness is the repeatable contract for how an agent run behaves. Start with the default coding harness:
+A harness is the repeatable contract for how an agent run behaves. In the TUI, create and load your first harness without writing YAML:
+
+```text
+:connect local
+:harness wizard
+```
+
+Press Enter through the defaults for a runnable local coding harness, choose an output file, and answer `yes` when asked whether to load it. If `harness.yaml` already exists, the wizard uses the next available path such as `harness-2.yaml`.
+
+For the CLI path, start with the interactive wizard or the default coding template:
+
+```bash
+cd your-project
+superqode harness wizard
+superqode harness explain --spec harness.yaml
+superqode harness doctor --spec harness.yaml
+superqode harness run --spec harness.yaml --prompt "summarize the architecture"
+```
+
+Template shortcut:
 
 ```bash
 cd your-project

{superqode-0.2.1 → superqode-0.2.3}/README.md

@@ -102,7 +102,7 @@ Inside the TUI, the local-first MVP path is:
 | File | Purpose | Created by |
 | --- | --- | --- |
 | `superqode.yaml` | Project configuration: providers, endpoints, MCP, memory, defaults | `superqode config init` or `:init` |
-| `harness.yaml` | Portable agent run contract | `superqode harness init ...` |
+| `harness.yaml` | Portable agent run contract | `:harness wizard`, `superqode harness wizard`, or `superqode harness init ...` |
 | `superqode.local.yaml` | Local-first HarnessSpec generated for this machine | `:local init` or `superqode local init --repo .` |
 | `superqode.airplane.yaml` | Strict no-network HarnessSpec for offline local work | `:local airplane prepare` or `superqode local airplane prepare` |
 
@@ -114,7 +114,26 @@ superqode --print "inspect this repository and suggest the smallest next step"
 
 ### Your First Harness Run
 
-A harness is the repeatable contract for how an agent run behaves. Start with the default coding harness:
+A harness is the repeatable contract for how an agent run behaves. In the TUI, create and load your first harness without writing YAML:
+
+```text
+:connect local
+:harness wizard
+```
+
+Press Enter through the defaults for a runnable local coding harness, choose an output file, and answer `yes` when asked whether to load it. If `harness.yaml` already exists, the wizard uses the next available path such as `harness-2.yaml`.
+
+For the CLI path, start with the interactive wizard or the default coding template:
+
+```bash
+cd your-project
+superqode harness wizard
+superqode harness explain --spec harness.yaml
+superqode harness doctor --spec harness.yaml
+superqode harness run --spec harness.yaml --prompt "summarize the architecture"
+```
+
+Template shortcut:
 
 ```bash
 cd your-project

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

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "0.2.1"
+version = "0.2.3"
 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.3}/src/superqode/__init__.py

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

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

@@ -12007,7 +12007,7 @@ class SuperQodeApp(App):
                 "tool_call_format": "auto",
                 "workflow_preset": "single",
             },
-            "output": "harness.yaml",
+            "output": self._default_harness_wizard_output(),
             "load": True,
             "force": False,
         }
@@ -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)
@@ -12126,6 +12130,11 @@ class SuperQodeApp(App):
                 answers["workflow_preset"] = choice
                 self._harness_wizard_next(state, "output")
             elif step == "output":
+                load_answer = self._parse_yes_no(raw) if raw else None
+                if load_answer is not None:
+                    state["load"] = load_answer
+                    self._finish_harness_wizard_flow(log)
+                    return True
                 if raw:
                     state["output"] = raw
                 self._harness_wizard_next(state, "load")
@@ -12157,6 +12166,17 @@ class SuperQodeApp(App):
         state.setdefault("history", []).append(state["step"])
         state["step"] = next_step
 
+    @staticmethod
+    def _default_harness_wizard_output() -> str:
+        base = Path("harness.yaml")
+        if not base.exists():
+            return str(base)
+        for index in range(2, 1000):
+            candidate = Path(f"harness-{index}.yaml")
+            if not candidate.exists():
+                return str(candidate)
+        return "harness-new.yaml"
+
     @staticmethod
     def _parse_yes_no(raw: str) -> bool | None:
         lowered = raw.strip().lower()
@@ -12270,11 +12290,11 @@ class SuperQodeApp(App):
                 default = " (default)" if key == "single" else ""
                 t.append(f"  {index}. {key:<22} {label}{default}\n", style=THEME["text"])
         elif step == "output":
-            t.append("  Step 9/9  Output file\n", style=f"bold {THEME['cyan']}")
+            t.append("  Step 9/10  Output file\n", style=f"bold {THEME['cyan']}")
             t.append(f"  Default: {state['output']}\n", style=THEME["muted"])
             t.append("  Example: harness.yaml\n", style=THEME["text"])
         elif step == "load":
-            t.append("  Final  Load this harness now?\n", style=f"bold {THEME['cyan']}")
+            t.append("  Step 10/10  Load this harness now?\n", style=f"bold {THEME['cyan']}")
             t.append("  Default: yes\n", style=THEME["muted"])
             t.append("  Answer: yes or no\n", style=THEME["text"])
 
@@ -12289,7 +12309,10 @@ class SuperQodeApp(App):
         load_after_write = bool(state.get("load", True))
 
         if output.exists() and not state.get("force", False):
-            log.add_error(f"{output} already exists. Type a different output path or cancel.")
+            state["output"] = self._default_harness_wizard_output()
+            log.add_error(
+                f"{output} already exists. Suggested next available path: {state['output']}"
+            )
             state["step"] = "output"
             self._render_harness_wizard_step(log)
             return
@@ -14849,6 +14872,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.3}/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,52 @@ 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."""
+        return
+
     def get_providers_for_picker(self) -> List[Dict[str, Any]]:
         """Get providers formatted for the TUI picker."""
         providers = []
@@ -271,6 +320,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 +332,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 +387,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.3/src/superqode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 0.2.1
+Version: 0.2.3
 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>
@@ -230,7 +230,7 @@ Inside the TUI, the local-first MVP path is:
 | File | Purpose | Created by |
 | --- | --- | --- |
 | `superqode.yaml` | Project configuration: providers, endpoints, MCP, memory, defaults | `superqode config init` or `:init` |
-| `harness.yaml` | Portable agent run contract | `superqode harness init ...` |
+| `harness.yaml` | Portable agent run contract | `:harness wizard`, `superqode harness wizard`, or `superqode harness init ...` |
 | `superqode.local.yaml` | Local-first HarnessSpec generated for this machine | `:local init` or `superqode local init --repo .` |
 | `superqode.airplane.yaml` | Strict no-network HarnessSpec for offline local work | `:local airplane prepare` or `superqode local airplane prepare` |
 
@@ -242,7 +242,26 @@ superqode --print "inspect this repository and suggest the smallest next step"
 
 ### Your First Harness Run
 
-A harness is the repeatable contract for how an agent run behaves. Start with the default coding harness:
+A harness is the repeatable contract for how an agent run behaves. In the TUI, create and load your first harness without writing YAML:
+
+```text
+:connect local
+:harness wizard
+```
+
+Press Enter through the defaults for a runnable local coding harness, choose an output file, and answer `yes` when asked whether to load it. If `harness.yaml` already exists, the wizard uses the next available path such as `harness-2.yaml`.
+
+For the CLI path, start with the interactive wizard or the default coding template:
+
+```bash
+cd your-project
+superqode harness wizard
+superqode harness explain --spec harness.yaml
+superqode harness doctor --spec harness.yaml
+superqode harness run --spec harness.yaml --prompt "summarize the architecture"
+```
+
+Template shortcut:
 
 ```bash
 cd your-project

{superqode-0.2.1 → superqode-0.2.3}/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,93 @@ 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_allows_ollama_mlx_tagged_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)
+
+    provider, model = pure._resolve_harness_route()
+
+    assert provider == "ollama"
+    assert model == "qwen3.6:35b-mlx"
+
+
+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.3}/tests/test_tui_smoke.py

@@ -1213,6 +1213,92 @@ 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_harness_wizard_yes_on_output_step_loads_default_path(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(8):
+        app._handle_harness_wizard_input("", log)
+    assert "Output file" in render_plain(log.items[-1])
+
+    app._handle_harness_wizard_input("yes", log)
+
+    assert (tmp_path / "harness.yaml").exists()
+    assert not (tmp_path / "yes").exists()
+    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["path"].endswith("harness.yaml")
+
+
+def test_tui_harness_wizard_defaults_use_next_available_output(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "harness.yaml").write_text("existing: true\n")
+    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)
+
+    assert (tmp_path / "harness-2.yaml").exists()
+    assert (tmp_path / "harness.yaml").read_text() == "existing: true\n"
+    assert app._awaiting_harness_wizard is False
+    status = app._pure_mode.get_status()["harness"]
+    assert status["enabled"] is True
+    assert status["path"].endswith("harness-2.yaml")
+
+
 def test_tui_help_surfaces_developer_workflows():
     app = make_app()
     log = FakeLog()