Open-source AI penetration testing tool to find and fix your app’s vulnerabilities.
Python agentsai-hackingai-penetration-testingai-pentestingai-securityartificial-intelligencebug-bountycode-qualityctf-toolscybersecuritycybersecurity-toolsethical-hackinghackingllm-securityoffensive-securitypenetration-testingpentesting-toolsred-teamingsecuritysecurity-automation
fix(tui): run environment and model checks on the no-target start screen
Ahmed Allam46b4e6cb6468
diff --git a/strix/interface/main.py b/strix/interface/main.pyindex 107f1bdc..297c4838 100644--- a/strix/interface/main.py+++ b/strix/interface/main.py@@ -391,13 +391,10 @@ def _print_model_connection_error(exc: BaseException, model_name: str) -> None:def _bootstrap_scan(args: argparse.Namespace) -> None:"""Warm up the model and prepare the run for a non-interactive scan.- Interactive launches only validate the environment here; the model- preflight and run preparation happen inside the TUI so the interface- paints immediately instead of waiting on a model round trip.+ Interactive launches skip this: the model preflight and run preparation+ happen inside the TUI so the interface paints immediately instead of+ waiting on a model round trip."""- validate_environment()- if not args.non_interactive:- returntry:asyncio.run(warm_up_llm(show_model_warning=True))except ModelConnectionError as exc:@@ -467,10 +464,9 @@ def main() -> None:check_docker_installed()pull_docker_image()+ validate_environment()- # In setup mode the TUI collects the target, then runs prepare_run(),- # warm-up, and telemetry itself once the user starts the scan.- if not args.needs_setup:+ if args.non_interactive:_bootstrap_scan(args)from strix.report.state import get_global_report_state@@ -511,6 +507,7 @@ def main() -> None:if not args.run_name:# Setup mode where the user quit before starting a scan: nothing ran.+ notify_update(Console())returnresults_path = run_dir_for(args.run_name)diff --git a/strix/interface/tui/backend/controller.py b/strix/interface/tui/backend/controller.pyindex da9ee34f..6f3b3fb3 100644--- a/strix/interface/tui/backend/controller.py+++ b/strix/interface/tui/backend/controller.py@@ -36,7 +36,8 @@ if TYPE_CHECKING:_STOPPABLE_AGENT_STATUSES = frozenset({"running", "waiting", "budget_paused"})ChangeCallback = Callable[[], None]-StartCallback = Callable[[bool], Awaitable[None]]+StartCallback = Callable[[], Awaitable[None]]+VerifyCallback = Callable[[], Awaitable[None]]QuitCallback = Callable[[], Awaitable[None]]@@ -51,6 +52,7 @@ class TuiController:coordinator: Any = None,report_state: ReportState | None = None,on_start: StartCallback | None = None,+ on_verify: VerifyCallback | None = None,on_quit: QuitCallback | None = None,on_change: ChangeCallback | None = None,) -> None:@@ -99,7 +101,6 @@ class TuiController:# A target-less launch enters the live view and asks there before# anything is prepared; this holds the directory awaiting that answer.self.pending_workspace_mount: str | None = None- self._pending_verify = Trueself.messages: list[dict[str, str]] = []self._next_message_id = 1self.error: str | None = None@@ -112,6 +113,7 @@ class TuiController:self.viewer_url: str | None = Noneself._viewer_httpd: Any = Noneself._on_start = on_start+ self._on_verify = on_verifyself._on_quit = on_quitself._on_change = on_change@@ -328,12 +330,6 @@ class TuiController:async def _start(self, payload: dict[str, Any]) -> dict[str, Any]:if self.scan_started or self._start_in_progress:raise RuntimeError("Scan is already starting or running")- # A bare prompt launches optimistically, like a coding agent: it skips- # the network model preflight and surfaces any model error live. A named- # target keeps the preflight so a real scan does not commit blind.- verify = payload.get("verify", True)- if not isinstance(verify, bool):- raise TypeError("verify must be a boolean")# Launching with no target mounts the working directory, so it requires# the user's explicit confirmation rather than happening silently.mount_working_dir = payload.get("mount_working_dir", False)@@ -344,27 +340,44 @@ class TuiController:raise ValueError("No model configured. Set STRIX_LLM first.")if self._on_start is None:raise RuntimeError("Scan start is unavailable")+ if not self.targets and not mount_working_dir:+ raise ValueError("No target set. Add a target first.")+ # The model check runs while still on the start screen, for a bare+ # prompt as much as for a named target, so a failure lands in the setup+ # log where the user can fix it and retry rather than in a dead run.+ await self._verify_model()if not self.targets:- if not mount_working_dir:- raise ValueError("No target set. Add a target first.")# Mounting the working directory needs the user's confirmation, and# that is asked in the live view. Enter it now and prepare nothing# until the answer arrives, so declining leaves no run behind.self.pending_workspace_mount = str(Path.cwd())- self._pending_verify = verifyself.setup_mode = Falseself.scan_started = Trueself.scan_state = "preparing"return {"started": True}- await self._begin_scan(verify)+ await self._begin_scan()return {"started": True}- async def _begin_scan(self, verify: bool) -> None:+ async def _verify_model(self) -> None:+ if self._on_verify is None:+ return+ self._start_in_progress = True+ try:+ await self._on_verify()+ finally:+ self._start_in_progress = False++ async def _begin_scan(self) -> None:if self._on_start is None:raise RuntimeError("Scan start is unavailable")self._start_in_progress = Truetry:- await self._on_start(verify)+ await self._on_start()+ except Exception as exc:+ if not self.setup_mode:+ # The live view is already up, so the failure has to show there.+ self.fail_preparation(str(exc))+ raisefinally:self._start_in_progress = Falseself.setup_mode = False@@ -384,7 +397,7 @@ class TuiController:# the whole of the input either way; the working directory is only an# extra the agent may look at, so the run goes ahead without one.self.workspace_mount = mount if approved else None- await self._begin_scan(self._pending_verify)+ await self._begin_scan()return {"approved": approved}async def _send_message(self, payload: dict[str, Any]) -> dict[str, Any]:diff --git a/strix/interface/tui/internal/app/setup.go b/strix/interface/tui/internal/app/setup.goindex a7525fbf..7a02cf34 100644--- a/strix/interface/tui/internal/app/setup.go+++ b/strix/interface/tui/internal/app/setup.go@@ -45,23 +45,20 @@ func (m *Model) submitSetupPrompt(value string) (tea.Model, tea.Cmd) {if len(fields) > targets {commands = append(commands, send(m.client, "setup.set_instruction", map[string]any{"instruction": value}))}- // With a target, verify the model connection before the scan commits to it.- // A bare prompt launches optimistically, like a coding agent, and mounts the- // working directory - the backend asks about that from the live view, so the- // prompt is held here in case it is declined.- verify := targets > 0 || len(m.snapshot.Targets) > 0- payload := map[string]any{"verify": verify}- if verify {- m.setupMsg("Verifying model connection...", render.Col(amber))- } else {+ // The backend verifies the model connection before either kind of launch+ // and reports on it through the setup log. A bare prompt mounts the working+ // directory - the backend asks about that from the live view, so the prompt+ // is held here in case it is declined.+ payload := map[string]any{}+ if targets == 0 && len(m.snapshot.Targets) == 0 {m.pendingPrompt = valuepayload["mount_working_dir"] = true}commands = append(commands, send(m.client, "setup.start", payload))// Ordered, not batched: setup.start leaves setup mode, so it must be the- // last command to reach the backend. Batched sends race, and once the- // preflight is skipped setup.start wins, making the target and instruction- // commands land after the guard closes and fail with a red error.+ // last command to reach the backend. Batched sends race, and if setup.start+ // wins the target and instruction commands land after the guard closes and+ // fail with a red error.return *m, tea.Sequence(commands...)}diff --git a/strix/interface/tui/internal/app/setup_prompt_test.go b/strix/interface/tui/internal/app/setup_prompt_test.goindex 63a0170f..7ac2ed82 100644--- a/strix/interface/tui/internal/app/setup_prompt_test.go+++ b/strix/interface/tui/internal/app/setup_prompt_test.go@@ -94,25 +94,6 @@ func commandTypes(envelopes []protocol.Envelope) []string {return types}-// startVerify returns the verify flag on the setup.start command, and whether-// a setup.start command was present at all.-func startVerify(t *testing.T, envelopes []protocol.Envelope) (verify, found bool) {- t.Helper()- for _, envelope := range envelopes {- if envelope.Type != "setup.start" {- continue- }- var payload struct {- Verify bool `json:"verify"`- }- if err := json.Unmarshal(envelope.Payload, &payload); err != nil {- t.Fatal(err)- }- return payload.Verify, true- }- return false, false-}-func contains(values []string, want string) bool {for _, value := range values {if value == want {@@ -160,10 +141,6 @@ func TestSetupPromptWithoutTargetLaunchesAndRequestsMount(t *testing.T) {if mount, found := startPayloadFlag(t, envelopes, "mount_working_dir"); !found || !mount {t.Fatalf("mount was not requested: mount_working_dir=%v found=%v", mount, found)}- // A bare prompt launches optimistically: no model preflight.- if verify, found := startVerify(t, envelopes); !found || verify {- t.Fatalf("bare prompt should launch with verify=false, got verify=%v found=%v", verify, found)- }// setup.start leaves setup mode, so it must be the last command sent.if start, instr := firstIndex(types, "setup.start"), lastIndex(types, "setup.set_instruction"); start < instr {t.Fatalf("setup.start (%d) must come after setup.set_instruction (%d): %v", start, instr, types)@@ -273,9 +250,8 @@ func TestSetupPromptWithTargetLaunches(t *testing.T) {t.Fatalf("missing %s in %v", want, types)}}- // A named target keeps the upfront model check.- if verify, found := startVerify(t, envelopes); !found || !verify {- t.Fatalf("targeted prompt should launch with verify=true, got verify=%v found=%v", verify, found)+ if _, found := startPayloadFlag(t, envelopes, "mount_working_dir"); found {+ t.Fatalf("a targeted prompt must not ask to mount the working directory: %v", types)}// The target and instruction must reach the backend before setup.start// closes the setup guard.diff --git a/strix/interface/tui/runtime.py b/strix/interface/tui/runtime.pyindex 8e8ebb89..728e7023 100644--- a/strix/interface/tui/runtime.py+++ b/strix/interface/tui/runtime.py@@ -63,11 +63,14 @@ class GoTuiRuntime:self.scan_error: BaseException | None = Noneself._last_sync_fingerprint = ""self._error_noted_agents: set[str] = set()+ self.model_verified = False+ self._setup_preflight: asyncio.Task[None] | None = Noneself.controller = TuiController(args,live_view=self.live_view,coordinator=self.coordinator,on_start=self.start_from_setup,+ on_verify=self.ensure_model_verified,on_quit=self.quit,)self.server = TuiBackendServer(self.controller)@@ -107,7 +110,51 @@ class GoTuiRuntime:)self.controller.notify_changed()- async def start_from_setup(self, verify: bool = True) -> None:+ async def check_setup_model(self) -> None:+ """Verify the model route as soon as the start screen is up.++ The same round trip a direct launch makes in prepare_and_start, run in+ the background so the screen paints first and the outcome lands in the+ setup log before the user has finished typing.+ """+ if not (load_settings().llm.model or "").strip():+ return+ try:+ await self._preflight_model()+ except Exception as exc:+ logger.exception("Go TUI setup model preflight failed")+ self.controller.add_message(f"Model connection failed: {exc}", "error")+ return+ self.controller.add_message("Model connection verified")++ async def ensure_model_verified(self) -> None:+ """Hold a setup launch until the model has answered once."""+ preflight = self._setup_preflight+ if preflight is not None and not preflight.done():+ await asyncio.shield(preflight)+ if self.model_verified:+ return+ try:+ await self._preflight_model()+ except Exception as exc:+ logger.exception("Go TUI setup model preflight failed")+ raise RuntimeError(f"Model connection failed: {exc}") from exc++ async def _preflight_model(self) -> None:+ model = (load_settings().llm.model or "").strip()+ self.controller.add_message("Verifying model connection...")+ await preflight_model_connection(model)+ self.model_verified = True++ def _start_preparation(self) -> asyncio.Task[None]:+ """Kick off the work that runs behind the freshly painted TUI."""+ if self.controller.setup_mode:+ self._setup_preflight = asyncio.create_task(self.check_setup_model())+ return self._setup_preflight+ self.controller.begin_preparation()+ return asyncio.create_task(self.prepare_and_start())++ async def start_from_setup(self) -> None:candidate = deepcopy(self.args)candidate.scan_mode = self.controller.scan_modecandidate.instruction = self.controller.instruction@@ -124,16 +171,7 @@ class GoTuiRuntime:if isinstance(target, dict) and target.get("original")]targets_changed = self.controller.targets != existing_targets- model = (load_settings().llm.model or "").strip()- # A bare prompt launches optimistically: it skips the network preflight- # and lets any model error surface once the agent starts, like a coding- # agent. A named target keeps the upfront check.- if verify:- try:- await preflight_model_connection(model)- except Exception as exc:- logger.exception("Go TUI setup model preflight failed")- raise RuntimeError(f"Model connection failed: {exc}") from exc+ persist_current()# A confirmed target-less launch mounts the working directory for the# agent to work in, without making it a scan target.candidate.workspace_mount = self.controller.workspace_mount@@ -376,9 +414,7 @@ class GoTuiRuntime:)process, backend_socket = await launch_tui_process(command, env, cwd)await self.server.start(backend_socket)- if not self.controller.setup_mode:- self.controller.begin_preparation()- prepare_task = asyncio.create_task(self.prepare_and_start())+ prepare_task = self._start_preparation()sync_task = asyncio.create_task(self.sync_state())return_code = await wait_process(process)check_return_code(return_code)diff --git a/tests/test_go_tui_runtime.py b/tests/test_go_tui_runtime.pyindex a1cb6369..05f81ece 100644--- a/tests/test_go_tui_runtime.py+++ b/tests/test_go_tui_runtime.py@@ -343,15 +343,19 @@ async def test_setup_preflights_model_before_starting(assert candidate.scope_mode == "diff"assert candidate.diff_base == "origin/main"+ monkeypatch.setattr(go_tui, "persist_current", lambda: calls.append("persist"))monkeypatch.setattr(go_tui, "build_targets_info", build)monkeypatch.setattr(go_tui, "prepare_run", prepare)monkeypatch.setattr(go_tui, "telemetry_start", lambda _args: calls.append("telemetry"))monkeypatch.setattr(runtime, "init_run_state", lambda: calls.append("state"))monkeypatch.setattr(runtime, "start_scan", lambda: calls.append("scan"))+ # The controller runs these two in turn for every setup launch.+ await runtime.ensure_model_verified()await runtime.start_from_setup()- assert calls == ["preflight", "targets", "prepare", "telemetry", "state", "scan"]+ # The same steps, in the same order, as a direct launch's prepare_and_start.+ assert calls == ["preflight", "persist", "targets", "prepare", "telemetry", "state", "scan"]assert runtime.args.scan_mode == "quick"assert runtime.args.instruction == ""assert runtime.args.max_budget_usd == 8.5@@ -360,35 +364,138 @@ async def test_setup_preflights_model_before_starting(assert runtime.args.diff_base == "origin/main"+def _setup_model(+ monkeypatch: pytest.MonkeyPatch, model: str | None = "openrouter/test-model"+) -> None:+ monkeypatch.setattr(+ go_tui,+ "load_settings",+ lambda: SimpleNamespace(llm=SimpleNamespace(model=model)),+ )+++def _setup_messages(runtime: GoTuiRuntime) -> list[tuple[str, str]]:+ return [(message["level"], message["text"]) for message in runtime.controller.messages]++@pytest.mark.asyncio-async def test_optimistic_setup_skips_model_preflight(+async def test_setup_model_check_reports_success_in_the_setup_log(monkeypatch: pytest.MonkeyPatch,) -> None:runtime = GoTuiRuntime(args())- runtime.controller.targets = [str(Path.cwd())]calls: list[str] = []+ async def preflight(model: str) -> None:+ calls.append(model)++ _setup_model(monkeypatch)+ monkeypatch.setattr(go_tui, "preflight_model_connection", preflight)++ await runtime.check_setup_model()++ assert calls == ["openrouter/test-model"]+ assert runtime.model_verified is True+ assert _setup_messages(runtime) == [+ ("info", "Verifying model connection..."),+ ("info", "Model connection verified"),+ ]+++async def test_setup_model_check_reports_failure_without_leaving_setup(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ runtime = GoTuiRuntime(args())+async def preflight(_model: str) -> None:- calls.append("preflight")+ raise TimeoutError("connection timed out")+ _setup_model(monkeypatch)+ monkeypatch.setattr(go_tui, "preflight_model_connection", preflight)++ await runtime.check_setup_model()++ assert runtime.model_verified is False+ assert runtime.controller.setup_mode is True+ assert runtime.controller.scan_state == "setup"+ assert _setup_messages(runtime)[-1] == (+ "error",+ "Model connection failed: connection timed out",+ )+++async def test_setup_model_check_waits_for_a_configured_model(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ runtime = GoTuiRuntime(args())++ _setup_model(monkeypatch, model=None)monkeypatch.setattr(go_tui,- "load_settings",- lambda: SimpleNamespace(llm=SimpleNamespace(model="openrouter/test-model")),+ "preflight_model_connection",+ lambda _model: pytest.fail("nothing to check without a model"),)++ await runtime.check_setup_model()++ assert runtime.model_verified is False+ assert runtime.controller.messages == []+++async def test_ensure_model_verified_reuses_the_startup_check(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ runtime = GoTuiRuntime(args())+ release = asyncio.Event()+ calls: list[str] = []++ async def preflight(_model: str) -> None:+ calls.append("preflight")+ await release.wait()++ _setup_model(monkeypatch)monkeypatch.setattr(go_tui, "preflight_model_connection", preflight)- monkeypatch.setattr(go_tui, "build_targets_info", lambda _args, **_kw: calls.append("targets"))- monkeypatch.setattr(go_tui, "prepare_run", lambda _args: calls.append("prepare"))- monkeypatch.setattr(go_tui, "telemetry_start", lambda _args: calls.append("telemetry"))- monkeypatch.setattr(runtime, "init_run_state", lambda: calls.append("state"))- monkeypatch.setattr(runtime, "start_scan", lambda: calls.append("scan"))+ runtime._setup_preflight = asyncio.create_task(runtime.check_setup_model())+ await asyncio.sleep(0)++ # A launch that arrives mid-check waits for it rather than racing a second+ # round trip.+ ensure = asyncio.create_task(runtime.ensure_model_verified())+ await asyncio.sleep(0)+ assert not ensure.done()+ release.set()+ await ensure++ assert calls == ["preflight"]+ assert runtime.model_verified is True+++async def test_ensure_model_verified_retries_after_a_failed_startup_check(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ runtime = GoTuiRuntime(args())+ outcomes = iter([TimeoutError("connection timed out"), None])+ calls: list[str] = []++ async def preflight(_model: str) -> None:+ calls.append("preflight")+ outcome = next(outcomes)+ if outcome is not None:+ raise outcome- await runtime.start_from_setup(verify=False)+ _setup_model(monkeypatch)+ monkeypatch.setattr(go_tui, "preflight_model_connection", preflight)++ await runtime.check_setup_model()+ assert runtime.model_verified is False++ await runtime.ensure_model_verified()- # No preflight: the scan launches straight through and any model error- # surfaces once the agent runs.- assert "preflight" not in calls- assert calls == ["targets", "prepare", "telemetry", "state", "scan"]+ assert calls == ["preflight", "preflight"]+ assert runtime.model_verified is True@pytest.mark.asyncio@@ -400,15 +507,8 @@ async def test_confirmed_target_less_launch_mounts_workspace_without_targets(runtime.controller.workspace_mount = str(Path.home())prepared: list[argparse.Namespace] = []- async def preflight(_model: str) -> None:- return None-- monkeypatch.setattr(- go_tui,- "load_settings",- lambda: SimpleNamespace(llm=SimpleNamespace(model="openrouter/test-model")),- )- monkeypatch.setattr(go_tui, "preflight_model_connection", preflight)+ _setup_model(monkeypatch)+ monkeypatch.setattr(go_tui, "persist_current", lambda: None)monkeypatch.setattr(go_tui,"build_targets_info",@@ -419,7 +519,7 @@ async def test_confirmed_target_less_launch_mounts_workspace_without_targets(monkeypatch.setattr(runtime, "init_run_state", lambda: None)monkeypatch.setattr(runtime, "start_scan", lambda: None)- await runtime.start_from_setup(verify=False)+ await runtime.start_from_setup()assert prepared[0].workspace_mount == str(Path.home())assert prepared[0].targets_info == []@@ -442,15 +542,8 @@ async def test_setup_preserves_prepared_cli_targets(runtime = GoTuiRuntime(runtime_args)calls: list[str] = []- async def preflight(_model: str) -> None:- calls.append("preflight")-- monkeypatch.setattr(- go_tui,- "load_settings",- lambda: SimpleNamespace(llm=SimpleNamespace(model="openrouter/test-model")),- )- monkeypatch.setattr(go_tui, "preflight_model_connection", preflight)+ _setup_model(monkeypatch)+ monkeypatch.setattr(go_tui, "persist_current", lambda: calls.append("persist"))monkeypatch.setattr(go_tui,"build_targets_info",@@ -465,7 +558,7 @@ async def test_setup_preserves_prepared_cli_targets(assert runtime.controller.targets == ["https://example.com"]assert runtime.args.targets_info[0]["type"] == "web"- assert calls == ["preflight", "prepare", "telemetry", "state", "scan"]+ assert calls == ["persist", "prepare", "telemetry", "state", "scan"]@pytest.mark.asyncio@@ -798,19 +891,17 @@ async def test_setup_preflight_failure_does_not_start_scan(nonlocal startedstarted = True- monkeypatch.setattr(- go_tui,- "load_settings",- lambda: SimpleNamespace(llm=SimpleNamespace(model="openrouter/test-model")),- )+ _setup_model(monkeypatch)monkeypatch.setattr(go_tui, "preflight_model_connection", preflight)+ monkeypatch.setattr(go_tui, "persist_current", mark_started)monkeypatch.setattr(go_tui, "build_targets_info", mark_started)monkeypatch.setattr(runtime, "init_run_state", mark_started)monkeypatch.setattr(runtime, "start_scan", mark_started)with pytest.raises(RuntimeError, match="Model connection failed: 401 Unauthorized"):- await runtime.start_from_setup()+ await runtime.ensure_model_verified()+ assert runtime.model_verified is Falseassert started is Falseassert runtime.scan_task is Nonediff --git a/tests/test_tui_backend_controller.py b/tests/test_tui_backend_controller.pyindex 078a0324..3a28d020 100644--- a/tests/test_tui_backend_controller.py+++ b/tests/test_tui_backend_controller.py@@ -155,7 +155,7 @@ def test_setup_restores_prepared_cli_targets() -> None:async def test_start_validates_model_before_callback() -> None:started = False- async def start(_verify: bool = True) -> None:+ async def start() -> None:nonlocal startedstarted = True@@ -170,7 +170,7 @@ async def test_start_validates_model_before_callback() -> None:async def test_start_launches_with_a_configured_model() -> None:started = False- async def start(_verify: bool = True) -> None:+ async def start() -> None:nonlocal startedstarted = True@@ -189,7 +189,7 @@ async def test_start_launches_with_a_configured_model() -> None:async def test_start_without_target_requires_mount_consent() -> None:started = False- async def start(_verify: bool = True) -> None:+ async def start() -> None:nonlocal startedstarted = True@@ -200,7 +200,7 @@ async def test_start_without_target_requires_mount_consent() -> None:# Mounting the working directory is never silent.with pytest.raises(ValueError, match="No target set"):- await controller.handle("setup.start", {"verify": False})+ await controller.handle("setup.start", {})assert started is Falseassert controller.targets == []assert controller.workspace_mount is None@@ -211,7 +211,7 @@ async def test_target_less_start_enters_live_view_and_waits_for_the_mount() -> N"""Nothing is prepared until the live-view confirmation is answered."""started = False- async def start(_verify: bool = True) -> None:+ async def start() -> None:nonlocal startedstarted = True@@ -220,7 +220,7 @@ async def test_target_less_start_enters_live_view_and_waits_for_the_mount() -> Nloader._cached = Nonecontroller = TuiController(args(), on_start=start)- result = await controller.handle("setup.start", {"verify": False, "mount_working_dir": True})+ result = await controller.handle("setup.start", {"mount_working_dir": True})assert result == {"started": True}# The live view is up so the prompt can be shown there, but the scan has not@@ -236,26 +236,23 @@ async def test_target_less_start_enters_live_view_and_waits_for_the_mount() -> N@pytest.mark.asyncioasync def test_confirming_the_mount_starts_the_scan_without_a_target() -> None:started = False- seen_verify: bool | None = None- async def start(verify: bool = True) -> None:- nonlocal started, seen_verify+ async def start() -> None:+ nonlocal startedstarted = True- seen_verify = verifyos.environ["STRIX_LLM"] = "anthropic/claude-sonnet-4"os.environ["ANTHROPIC_API_KEY"] = "test-key"loader._cached = Nonecontroller = TuiController(args(), on_start=start)- await controller.handle("setup.start", {"verify": False, "mount_working_dir": True})+ await controller.handle("setup.start", {"mount_working_dir": True})result = await controller.handle("setup.confirm_mount", {"approved": True})assert result == {"approved": True}assert started is True- # Launched optimistically, and mounted as a workspace: the scan genuinely- # has no target, so the instruction is the only source of truth.- assert seen_verify is False+ # Mounted as a workspace: the scan genuinely has no target, so the+ # instruction is the only source of truth.assert controller.workspace_mount == str(Path.cwd())assert controller.targets == []assert controller.scan_state == "running"@@ -264,22 +261,23 @@ async def test_confirming_the_mount_starts_the_scan_without_a_target() -> None:@pytest.mark.asyncioasync def test_declining_the_mount_runs_without_one() -> None:- started: list[bool] = []+ started = 0- async def start(verify: bool = True) -> None:- started.append(verify)+ async def start() -> None:+ nonlocal started+ started += 1os.environ["STRIX_LLM"] = "anthropic/claude-sonnet-4"os.environ["ANTHROPIC_API_KEY"] = "test-key"loader._cached = Nonecontroller = TuiController(args(), on_start=start)- await controller.handle("setup.start", {"verify": False, "mount_working_dir": True})+ await controller.handle("setup.start", {"mount_working_dir": True})result = await controller.handle("setup.confirm_mount", {"approved": False})assert result == {"approved": False}# Declining skips the directory; it does not abandon the scan.- assert started == [False]+ assert started == 1assert controller.workspace_mount is Noneassert controller.pending_workspace_mount is Noneassert controller.setup_mode is False@@ -289,21 +287,22 @@ async def test_declining_the_mount_runs_without_one() -> None:@pytest.mark.asyncioasync def test_approving_the_mount_runs_with_it() -> None:- started: list[bool] = []+ started = 0- async def start(verify: bool = True) -> None:- started.append(verify)+ async def start() -> None:+ nonlocal started+ started += 1os.environ["STRIX_LLM"] = "anthropic/claude-sonnet-4"os.environ["ANTHROPIC_API_KEY"] = "test-key"loader._cached = Nonecontroller = TuiController(args(), on_start=start)- await controller.handle("setup.start", {"verify": False, "mount_working_dir": True})+ await controller.handle("setup.start", {"mount_working_dir": True})result = await controller.handle("setup.confirm_mount", {"approved": True})assert result == {"approved": True}- assert started == [False]+ assert started == 1assert controller.workspace_mount == str(Path.cwd())assert controller.scan_state == "running"@@ -352,23 +351,91 @@ async def test_user_message_updates_live_agent_projection_immediately() -> None:@pytest.mark.asyncio-async def test_start_forwards_verify_flag_by_default() -> None:- seen_verify: bool | None = None+async def test_start_verifies_the_model_before_a_targeted_launch() -> None:+ order: list[str] = []++ async def verify() -> None:+ order.append("verify")- async def start(verify: bool = True) -> None:- nonlocal seen_verify- seen_verify = verify+ async def start() -> None:+ order.append("start")os.environ["STRIX_LLM"] = "anthropic/claude-sonnet-4"os.environ["ANTHROPIC_API_KEY"] = "test-key"loader._cached = None- controller = TuiController(args(), on_start=start)+ controller = TuiController(args(), on_start=start, on_verify=verify)await controller.handle("setup.add_target", {"target": "https://example.com"})- # A named target keeps the upfront model check.await controller.handle("setup.start", {})- assert seen_verify is True+ assert order == ["verify", "start"]+++async def test_start_verifies_the_model_before_a_bare_prompt_leaves_setup() -> None:+ """A bare prompt gets the same model check as a named target, while the+ setup log is still on screen to show the outcome."""+ verified = 0++ async def verify() -> None:+ nonlocal verified+ verified += 1++ async def start() -> None:+ return None++ os.environ["STRIX_LLM"] = "anthropic/claude-sonnet-4"+ os.environ["ANTHROPIC_API_KEY"] = "test-key"+ loader._cached = None+ controller = TuiController(args(), on_start=start, on_verify=verify)++ await controller.handle("setup.start", {"mount_working_dir": True})++ assert verified == 1+ assert controller.setup_mode is False+ assert controller.pending_workspace_mount == str(Path.cwd())+++async def test_failed_model_check_keeps_the_start_screen() -> None:+ async def verify() -> None:+ raise RuntimeError("Model connection failed: timed out")++ async def start() -> None:+ pytest.fail("the scan must not start when the model check fails")++ os.environ["STRIX_LLM"] = "anthropic/claude-sonnet-4"+ os.environ["ANTHROPIC_API_KEY"] = "test-key"+ loader._cached = None+ controller = TuiController(args(), on_start=start, on_verify=verify)++ with pytest.raises(RuntimeError, match="Model connection failed"):+ await controller.handle("setup.start", {"mount_working_dir": True})++ # Still on the start screen, so the error lands in the setup log and the+ # user can retry; no run was prepared behind a stuck live view.+ assert controller.setup_mode is True+ assert controller.scan_started is False+ assert controller.scan_state == "setup"+ assert controller.pending_workspace_mount is None+++async def test_confirmed_mount_launch_failure_is_reported_in_the_live_view() -> None:+ async def start() -> None:+ raise ValueError("Scan preparation failed")++ os.environ["STRIX_LLM"] = "anthropic/claude-sonnet-4"+ os.environ["ANTHROPIC_API_KEY"] = "test-key"+ loader._cached = None+ controller = TuiController(args(), on_start=start)+ await controller.handle("setup.start", {"mount_working_dir": True})++ with pytest.raises(ValueError, match="Scan preparation failed"):+ await controller.handle("setup.confirm_mount", {"approved": True})++ assert controller.scan_state == "failed"+ assert controller.error == "Scan preparation failed"@pytest.mark.asyncio@@ -376,7 +443,7 @@ async def test_start_rejects_concurrent_and_repeated_submissions() -> None:entered = asyncio.Event()release = asyncio.Event()- async def start(_verify: bool = True) -> None:+ async def start() -> None:entered.set()await release.wait()