thwip-cli 1.2.0__tar.gz → 1.3.0__tar.gz

{thwip_cli-1.2.0 → thwip_cli-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thwip-cli
-Version: 1.2.0
+Version: 1.3.0
 Summary: Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly
 Project-URL: Homepage, https://github.com/tanmayhutt/thwip-cli
 Project-URL: Repository, https://github.com/tanmayhutt/thwip-cli
@@ -91,6 +91,7 @@ thwip
 |:---|:---|
 | `/switch [agent] [model]` | Switch active agent or model mid-conversation |
 | `/handoff [agent] [model]` | Preview a target locally without switching or sending data |
+| `/native codex` | Save and leave Thwip for the installed Codex CLI using its own authentication |
 | `/agents` | Show all detected coding agents, company status, and capabilities |
 | `/models [agent]` | List available models for current or target agent |
 | `/key [provider]` | Enter an API key securely without placing it in prompt history |
@@ -105,12 +106,26 @@ thwip
 | `/cost` | Show estimated session and cumulative cost |
 | `/project [path]` | View or change project working directory |
 | `Ctrl + S` | Quick switch agent prompt |
-
-Short aliases are available for frequent commands: `/a`, `/m`, `/s`, `/k`, `/g`, and `/t`.
 | `Ctrl + T` | Show agent status |
 | `Ctrl + H` | View history |
 | `/quit` | Exit thwip |
 
+Short aliases are available for frequent commands: `/a`, `/m`, `/s`, `/k`, `/g`, and `/t`.
+
+### Existing Codex login
+
+Use `/native codex` to open the installed native CLI without configuring a Thwip API
+key. After confirmation, Thwip saves its session and replaces itself with Codex in
+the selected project, using a read-only sandbox and on-request approvals. Codex
+owns authentication, model selection, permissions, and usage limits. An expired
+or missing login must be resolved in Codex itself.
+
+This is a launcher, not an in-REPL provider adapter. Conversation history is not
+transferred, native activity is not included in Thwip usage totals, and exiting
+Codex does not automatically restart Thwip. Restart `thwip` and use `/session load`
+to resume the saved Thwip conversation. Claude and Gemini native launchers are not
+implemented. Direct API mode remains unchanged.
+
 ---
 
 ## Auditable handoffs
@@ -154,7 +169,7 @@ See [research and prior art](docs/handoff-research.md) for the differentiation r
 | Google | Gemini API (3.1 Pro Preview, 3.7 Flash, 3.5 Flash-Lite) | Chat, File Edit, Code Run, Terminal, Git |
 | OpenAI | OpenAI API (GPT-5.6 Sol, Terra, Luna) | Chat, File Edit, Code Run, Terminal, Git |
 | DeepSeek | DeepSeek V3 / R1 Reasoner | Chat, File Edit, Code Run, Reasoning |
-| Groq | Llama 3.3 70B, Mixtral | Chat, File Edit, Code Run |
+| Groq | GPT-OSS 120B (default); Llama 3.3 for eligible enterprise accounts only | Chat, File Edit, Code Run |
 | Ollama | Local Models (Llama 3.3, Qwen Coder, DeepSeek R1) | Chat, File Edit, Code Run (Local, Offline) |
 | OpenRouter | Multi-Company Models | Gateway Routing |
 

{thwip_cli-1.2.0 → thwip_cli-1.3.0}/README.md

@@ -54,6 +54,7 @@ thwip
 |:---|:---|
 | `/switch [agent] [model]` | Switch active agent or model mid-conversation |
 | `/handoff [agent] [model]` | Preview a target locally without switching or sending data |
+| `/native codex` | Save and leave Thwip for the installed Codex CLI using its own authentication |
 | `/agents` | Show all detected coding agents, company status, and capabilities |
 | `/models [agent]` | List available models for current or target agent |
 | `/key [provider]` | Enter an API key securely without placing it in prompt history |
@@ -68,12 +69,26 @@ thwip
 | `/cost` | Show estimated session and cumulative cost |
 | `/project [path]` | View or change project working directory |
 | `Ctrl + S` | Quick switch agent prompt |
-
-Short aliases are available for frequent commands: `/a`, `/m`, `/s`, `/k`, `/g`, and `/t`.
 | `Ctrl + T` | Show agent status |
 | `Ctrl + H` | View history |
 | `/quit` | Exit thwip |
 
+Short aliases are available for frequent commands: `/a`, `/m`, `/s`, `/k`, `/g`, and `/t`.
+
+### Existing Codex login
+
+Use `/native codex` to open the installed native CLI without configuring a Thwip API
+key. After confirmation, Thwip saves its session and replaces itself with Codex in
+the selected project, using a read-only sandbox and on-request approvals. Codex
+owns authentication, model selection, permissions, and usage limits. An expired
+or missing login must be resolved in Codex itself.
+
+This is a launcher, not an in-REPL provider adapter. Conversation history is not
+transferred, native activity is not included in Thwip usage totals, and exiting
+Codex does not automatically restart Thwip. Restart `thwip` and use `/session load`
+to resume the saved Thwip conversation. Claude and Gemini native launchers are not
+implemented. Direct API mode remains unchanged.
+
 ---
 
 ## Auditable handoffs
@@ -117,7 +132,7 @@ See [research and prior art](docs/handoff-research.md) for the differentiation r
 | Google | Gemini API (3.1 Pro Preview, 3.7 Flash, 3.5 Flash-Lite) | Chat, File Edit, Code Run, Terminal, Git |
 | OpenAI | OpenAI API (GPT-5.6 Sol, Terra, Luna) | Chat, File Edit, Code Run, Terminal, Git |
 | DeepSeek | DeepSeek V3 / R1 Reasoner | Chat, File Edit, Code Run, Reasoning |
-| Groq | Llama 3.3 70B, Mixtral | Chat, File Edit, Code Run |
+| Groq | GPT-OSS 120B (default); Llama 3.3 for eligible enterprise accounts only | Chat, File Edit, Code Run |
 | Ollama | Local Models (Llama 3.3, Qwen Coder, DeepSeek R1) | Chat, File Edit, Code Run (Local, Offline) |
 | OpenRouter | Multi-Company Models | Gateway Routing |
 

thwip_cli-1.3.0/docs/verification.md

@@ -0,0 +1,28 @@
+# Verification status
+
+Verified locally on 2026-09-07 for v1.3.0. The Python suite passes 186 tests.
+Exhaustive behavior across every provider and
+configuration has not been established.
+
+| Area | Evidence | Remaining limitation |
+| --- | --- | --- |
+| Commands and aliases | Offline command smoke tests, invalid input cases | Most smoke tests check exceptions, not all rendered content |
+| Sessions | Save/load, separate fresh conversations, malformed metadata, permissions, project rebinding | Concurrent writes to the same explicitly named session are not coordinated |
+| Provider switching and handoff | All seven provider catalogs, portable history, bounded failover | Live account quotas and model availability unverified |
+| Tool execution | Real temporary-file operations, path containment, process timeout/cancellation, invalid arguments | Shell and code tools retain local user privileges; output capture memory is unbounded |
+| Native Codex launcher | Save-before-launch, consent, flags, missing binary, terminal checks, failures | Mocked process replacement; live native interaction unverified; no conversation transfer |
+| Provider responses | Mocked native tool continuations; DeepSeek/Groq/OpenRouter streaming, usage-only chunks, 429/500 errors and serialized tool arguments | Other streaming and error branches still have coverage gaps |
+| Display/config/auth | Configuration validation, display settings, credential boundaries, short-key masking | No full terminal/platform matrix |
+| Usage | Atomic writes, malformed records, valid totals | Unknown catalog pricing may appear as zero estimated cost |
+| Website | Production build and deterministic demo completion/replay test | Real browser, layout, clipboard, keyboard and accessibility checks remain incomplete |
+| Dependencies | npm audit: zero advisories; Python installed-dependency audit: none found | Python audit skipped legacy local `thwip 1.0.0` metadata |
+| Packaging | Wheel/source build and metadata checks | Publication is separately verified through the release workflow |
+
+The Python suite measured 69% statement coverage with 160 passing tests before
+the final credential-masking tests were added. Coverage is diagnostic evidence,
+not proof that every feature works. The website test uses a minimal DOM stand-in
+and controlled timers, not a browser.
+
+This pass fixed default-session save collisions, malformed session/message
+metadata acceptance, tool-argument display crashes, Rich markup interpretation
+in action output, and short-key masking leakage.

{thwip_cli-1.2.0 → thwip_cli-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thwip-cli"
-version = "1.2.0"
+version = "1.3.0"
 description = "Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly"
 readme = "README.md"
 license = "MIT"

thwip_cli-1.3.0/tests/test_audit_regressions.py

@@ -0,0 +1,164 @@
+import json
+from io import StringIO
+from types import SimpleNamespace
+
+import pytest
+from rich.console import Console
+
+from thwip.agents import AgentRegistry
+from thwip.agents.base import AgentDone, Capability, LimitHit, LimitStatus, TextDelta
+from thwip.cli import ThwipCLI
+from thwip.config import ThwipConfig, get_usage_path
+from thwip.limits import UsageTracker
+from thwip.session import Session
+from thwip.tools import ToolManager
+
+
+@pytest.fixture
+def cli(tmp_path, monkeypatch):
+    monkeypatch.setenv('THWIP_CONFIG_DIR', str(tmp_path / 'config'))
+    cli = ThwipCLI.__new__(ThwipCLI)
+    cli.config = ThwipConfig(project=str(tmp_path), auto_save=False)
+    cli.registry = AgentRegistry(cli.config)
+    for a in cli.registry.list_agents():
+        monkeypatch.setattr(a, 'is_installed', lambda: True)
+        monkeypatch.setattr(a, 'is_configured', lambda: False)
+        if a.name == 'ollama':
+            a._cached_models = a.get_handoff_models()
+    cli.current_agent = cli.registry.get_agent('claude')
+    cli.session = Session(project_path=str(tmp_path), current_agent='claude', current_model=cli.current_agent.get_default_model())
+    cli.usage_tracker = UsageTracker()
+    cli.tool_manager = ToolManager(str(tmp_path))
+    cli.detector = SimpleNamespace(scan_all=list)
+    monkeypatch.setattr('builtins.input', lambda *args: '')
+    monkeypatch.setattr('getpass.getpass', lambda *args: '')
+    console = Console(file=StringIO(), width=100, color_system=None)
+    monkeypatch.setattr('thwip.cli.console', console)
+    monkeypatch.setattr('thwip.theme.console', console)
+    return cli
+
+
+@pytest.mark.parametrize('command', [
+    '/help', '/h', '/about', '/guide', '/g', '/info', '/agents', '/a', '/list',
+    '/models', '/m', '/models flagship', '/models balanced', '/models fast', '/models google',
+    '/tools', '/t', '/status', '/limits', '/detect', '/history', '/clear', '/reset', '/cost',
+    '/project', '/session save audit', '/session load missing', '/session list', '/session clear',
+    '/key', '/key google', '/key invalid', '/key openai REJECTED_TEST_KEY',
+    '/handoff', '/handoff invalid', '/handoff google invalid', '/switch', '/switch invalid',
+    '/switch google invalid', '/unknown', '/q', '/exit', '/quit',
+])
+@pytest.mark.asyncio
+async def test_command_no_exception(cli, command):
+    await cli.handle_command(command)
+
+
+@pytest.mark.parametrize('provider', ['claude','google','openai','deepseek','groq','ollama','openrouter'])
+@pytest.mark.asyncio
+async def test_all_catalogued_handoffs(cli, provider):
+    before = list(cli.session.messages)
+    for model in cli.registry.get_agent(provider).get_handoff_models():
+        await cli.handle_command(f'/handoff {provider} {model.id}')
+    assert cli.session.messages == before
+
+
+@pytest.mark.asyncio
+async def test_project_path_with_spaces(cli, tmp_path):
+    project = tmp_path / 'project with spaces'
+    project.mkdir()
+    await cli.handle_command(f'/project {project}')
+    assert cli.session.project_path == str(project)
+
+
+def test_usage_file_private(cli):
+    cli.usage_tracker.record_usage('openai', 'gpt-5.6-terra', 10, 5)
+    assert get_usage_path().stat().st_mode & 0o777 == 0o600
+
+
+@pytest.mark.parametrize('tool,args', [
+    ('read_file', {'file_path': 12}),
+    ('list_files', {'sub_dir': ['bad']}),
+    ('run_python', {'code': None}),
+])
+def test_invalid_tool_args_return_error_not_exception(cli, tool, args):
+    result = cli.tool_manager.execute_tool(tool, args)
+    assert isinstance(result, str)
+
+
+@pytest.mark.asyncio
+async def test_history_displays_literal_markup(cli):
+    cli.session.add_user_message('Show [/not-a-tag] literally')
+    await cli.handle_command('/history')
+
+
+@pytest.mark.parametrize('value', ['wrong', None, -1, True])
+def test_corrupted_handoff_counter_rejected_or_sanitized(cli, value):
+    path = cli.session.save('damaged')
+    data = json.loads(path.read_text())
+    data['observed_tool_results'] = value
+    path.write_text(json.dumps(data))
+    loaded = Session.load('damaged')
+    assert loaded is None or (type(loaded.observed_tool_results) is int and loaded.observed_tool_results >= 0)
+
+
+def test_invalid_config_type_rejected_or_defaulted(cli):
+    cli.config._apply_toml({'defaults': {'project': 123, 'confirm_tools': 'false'}})
+    assert isinstance(cli.config.project, str)
+    assert type(cli.config.confirm_tools) is bool
+
+
+@pytest.mark.asyncio
+async def test_session_roundtrip_rebinds_tools(cli, tmp_path):
+    target = tmp_path / 'other'
+    target.mkdir()
+    saved = Session(project_path=str(target), current_agent='google', current_model='missing')
+    saved.save('loadable')
+    await cli.handle_command('/session load loadable')
+    assert cli.tool_manager.file_editor.project_path == target
+    assert cli.current_agent.name == 'google'
+    assert cli.session.current_model == cli.current_agent.get_default_model()
+
+
+def test_all_tools_and_safety(cli, tmp_path):
+    tm = cli.tool_manager
+    assert 'Successfully' in tm.execute_tool('write_file', {'file_path':'a.txt','content':'one'})
+    assert tm.execute_tool('read_file', {'file_path':'a.txt'}) == 'one'
+    assert 'Successfully' in tm.execute_tool('edit_file', {'file_path':'a.txt','old_str':'one','new_str':'two'})
+    assert 'a.txt' in tm.execute_tool('list_files', {})
+    assert '42' in tm.execute_tool('run_python', {'code':'print(6 * 7)'})
+    assert 'Exit code: 0' in tm.execute_tool('run_command', {'command':'printf audit-ok'})
+    assert isinstance(tm.execute_tool('git_status', {}), str)
+    assert isinstance(tm.execute_tool('git_diff', {}), str)
+    assert 'outside' in tm.execute_tool('read_file', {'file_path':'../outside'})
+    outside = tmp_path.parent / 'audit-outside-file'
+    outside.write_text('not accessible')
+    (tmp_path / 'link').symlink_to(outside)
+    assert 'outside' in tm.execute_tool('read_file', {'file_path':'link'})
+    assert 'Error' in tm.execute_tool('unknown', {})
+    assert {t['name'] for t in tm.get_anthropic_tools()} == {t['function']['name'] for t in tm.get_openai_tools()}
+
+
+@pytest.mark.asyncio
+async def test_failover_does_not_retry_already_failed_provider(cli, monkeypatch):
+    agents = [cli.registry.get_agent('claude'), cli.registry.get_agent('google')]
+    attempts = []
+    for agent in agents:
+        monkeypatch.setattr(agent, 'is_configured', lambda: True)
+        monkeypatch.setattr(agent, 'get_capabilities_for_model', lambda model: {Capability.CHAT})
+
+        def make_chat(name):
+            async def chat(**kwargs):
+                attempts.append(name)
+                # Stop safely after four simulated rate limits; no actual network calls.
+                if len(attempts) <= 4:
+                    yield LimitHit(error_type=LimitStatus.RATE_LIMITED, message='test quota')
+                else:
+                    yield TextDelta(content='stop test')
+                    yield AgentDone()
+            return chat
+
+        monkeypatch.setattr(agent, 'chat', make_chat(agent.name))
+    monkeypatch.setattr(cli.registry, 'get_ready_agents', lambda: agents)
+    cli.config.fallback.chain = ['claude', 'google']
+    cli.config.limits.auto_switch = True
+    await cli.process_user_message('hello')
+    assert len(attempts) <= len(agents), f'Repeated failed providers: {attempts}'

{thwip_cli-1.2.0 → thwip_cli-1.3.0}/tests/test_cli.py

@@ -75,6 +75,30 @@ class UnconfiguredAgent(ToolCallingAgent):
         return False
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("arguments", [None, [], "bad", {"file_path": "[broken]"}])
+async def test_invalid_tool_arguments_return_errors_without_crashing(tmp_path, arguments):
+    class InvalidToolAgent(ToolCallingAgent):
+        async def chat(self, messages, **kwargs):
+            self.calls.append(messages)
+            if len(self.calls) == 1:
+                yield ToolUseStart(tool_id="bad", tool_name="read_file", args=arguments)
+                yield AgentDone()
+            else:
+                assert "Error" in messages[-1]["content"]
+                yield TextDelta(content="Recovered from invalid tool arguments.")
+                yield AgentDone()
+
+    cli = ThwipCLI.__new__(ThwipCLI)
+    cli.config = SimpleNamespace(stream=True, confirm_tools=True)
+    cli.session = Session(current_agent="fake", current_model="fake-model")
+    cli.current_agent = InvalidToolAgent()
+    cli.tool_manager = ToolManager(tmp_path)
+    cli.usage_tracker = FakeUsageTracker()
+    await cli.process_user_message("Read")
+    assert cli.session.messages[-1].content == "Recovered from invalid tool arguments."
+
+
 @pytest.mark.asyncio
 async def test_unconfigured_agent_shows_setup_guidance(tmp_path):
     cli = ThwipCLI.__new__(ThwipCLI)

thwip_cli-1.3.0/tests/test_compatible_streaming.py

@@ -0,0 +1,75 @@
+"""Exercise streaming completion and provider error boundaries without network calls."""
+
+import json
+from types import SimpleNamespace
+
+import httpx
+import openai
+import pytest
+
+from thwip.agents.base import AgentDone, LimitHit, LimitStatus, TextDelta
+from thwip.agents.deepseek_agent import DeepSeekAgent
+from thwip.agents.groq_agent import GroqAgent
+from thwip.agents.openrouter_agent import OpenRouterAgent
+
+
+@pytest.mark.parametrize("agent_type", [DeepSeekAgent, GroqAgent, OpenRouterAgent])
+@pytest.mark.asyncio
+async def test_tool_continuation_serializes_arguments_without_mutating_history(agent_type):
+    original = {"role": "assistant", "content": "", "tool_calls": [{
+        "id": "call1", "type": "function", "function": {
+            "name": "read_file", "arguments": {"file_path": "note.txt"},
+        },
+    }], "_native_state": {"other": "private"}}
+
+    async def create(**kwargs):
+        sent = kwargs["messages"][0]
+        assert "_native_state" not in sent
+        assert json.loads(sent["tool_calls"][0]["function"]["arguments"]) == {"file_path": "note.txt"}
+        return SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content="done", tool_calls=[]))], usage=None)
+
+    agent = agent_type(api_key="test")
+    agent._client = SimpleNamespace(chat=SimpleNamespace(completions=SimpleNamespace(create=create)))
+    events = [event async for event in agent.chat([original], stream=False)]
+    assert any(isinstance(event, AgentDone) for event in events)
+    assert isinstance(original["tool_calls"][0]["function"]["arguments"], dict)
+    assert "_native_state" in original
+
+
+@pytest.mark.parametrize("agent_type", [DeepSeekAgent, GroqAgent, OpenRouterAgent])
+@pytest.mark.asyncio
+async def test_stream_text_and_usage_only_final_chunk(agent_type):
+    async def chunks():
+        yield SimpleNamespace(choices=[SimpleNamespace(delta=SimpleNamespace(
+            content="hello", tool_calls=None))], usage=None)
+        yield SimpleNamespace(choices=[], usage=SimpleNamespace(prompt_tokens=9, completion_tokens=3))
+
+    async def create(**kwargs):
+        assert kwargs["stream"] is True
+        return chunks()
+
+    agent = agent_type(api_key="test")
+    agent._client = SimpleNamespace(chat=SimpleNamespace(completions=SimpleNamespace(create=create)))
+    events = [event async for event in agent.chat([{"role": "user", "content": "hi"}])]
+    assert isinstance(events[0], TextDelta) and events[0].content == "hello"
+    assert isinstance(events[-1], AgentDone)
+    assert events[-1].usage.input_tokens == 9
+    assert events[-1].usage.output_tokens == 3
+    assert agent.check_limits() == LimitStatus.OK
+
+
+@pytest.mark.parametrize("agent_type", [DeepSeekAgent, GroqAgent, OpenRouterAgent])
+@pytest.mark.parametrize("status", [429, 500])
+@pytest.mark.asyncio
+async def test_provider_errors_emit_failure_not_success(agent_type, status):
+    response = httpx.Response(status, request=httpx.Request("POST", "https://example.invalid"))
+    error_type = openai.RateLimitError if status == 429 else openai.APIStatusError
+
+    async def create(**kwargs):
+        raise error_type("simulated failure", response=response, body=None)
+
+    agent = agent_type(api_key="test")
+    agent._client = SimpleNamespace(chat=SimpleNamespace(completions=SimpleNamespace(create=create)))
+    events = [event async for event in agent.chat([])]
+    assert len(events) == 1 and isinstance(events[0], LimitHit)
+    assert events[0].error_type == (LimitStatus.RATE_LIMITED if status == 429 else LimitStatus.UNKNOWN)

thwip_cli-1.3.0/tests/test_native_launcher.py

@@ -0,0 +1,69 @@
+"""Native launch boundaries without executing a provider or reading credentials."""
+
+from types import SimpleNamespace
+
+import pytest
+
+from thwip.cli import ThwipCLI
+
+
+@pytest.fixture
+def launcher(tmp_path, monkeypatch):
+    events = []
+    cli = ThwipCLI.__new__(ThwipCLI)
+    cli.session = SimpleNamespace(project_path=str(tmp_path))
+    cli.session.save = lambda: events.append("save") or tmp_path / "session.json"
+    monkeypatch.setattr("thwip.cli.shutil.which", lambda name: "/installed/codex")
+    monkeypatch.setattr("thwip.cli.sys.stdin.isatty", lambda: True)
+    monkeypatch.setattr("thwip.cli.sys.stdout.isatty", lambda: True)
+    monkeypatch.setattr("thwip.cli.console.input", lambda prompt: "yes")
+    monkeypatch.setattr("thwip.cli.print_info", lambda message: None)
+    monkeypatch.setattr("thwip.cli.print_error", lambda message: events.append("error"))
+    monkeypatch.setattr("thwip.cli.os.execv", lambda path, args: events.append((path, args)))
+    return cli, events
+
+
+@pytest.mark.asyncio
+async def test_native_command_saves_before_replacing_process(launcher):
+    cli, events = launcher
+    await cli.handle_command("/native codex")
+    assert events == ["save", ("/installed/codex", [
+        "/installed/codex", "--cd", cli.session.project_path,
+        "--sandbox", "read-only", "--ask-for-approval", "on-request",
+    ])]
+
+
+@pytest.mark.parametrize("command", ["/native", "/native claude", "/native codex --dangerously-bypass-approvals-and-sandbox"])
+@pytest.mark.asyncio
+async def test_native_rejects_unsupported_arguments(launcher, command):
+    cli, events = launcher
+    await cli.handle_command(command)
+    assert events == []
+
+
+def test_native_decline_does_not_save_or_launch(launcher, monkeypatch):
+    cli, events = launcher
+    monkeypatch.setattr("thwip.cli.console.input", lambda prompt: "")
+    cli.cmd_native("codex")
+    assert events == []
+
+
+@pytest.mark.parametrize("failure", ["missing", "noninteractive", "project", "save", "exec"])
+def test_native_failure_stays_in_thwip(launcher, monkeypatch, failure):
+    cli, events = launcher
+
+    def fail(*args):
+        raise OSError("private detail")
+
+    if failure == "missing":
+        monkeypatch.setattr("thwip.cli.shutil.which", lambda name: None)
+    elif failure == "noninteractive":
+        monkeypatch.setattr("thwip.cli.sys.stdin.isatty", lambda: False)
+    elif failure == "project":
+        cli.session.project_path += "/missing"
+    elif failure == "save":
+        cli.session.save = fail
+    else:
+        monkeypatch.setattr("thwip.cli.os.execv", fail)
+    cli.cmd_native("codex")
+    assert events == (["save", "error"] if failure == "exec" else ["error"])

thwip_cli-1.3.0/tests/test_repair_verification.py

@@ -0,0 +1,177 @@
+"""Focused verification of repaired settings and native continuation."""
+
+import asyncio
+import json
+import time
+from types import SimpleNamespace
+
+import pytest
+from rich.text import Text
+
+from thwip.agents.base import AgentDone
+from thwip.agents.claude_agent import ClaudeAgent
+from thwip.agents.google_agent import GoogleAgent
+from thwip.agents.openai_agent import OpenAIAgent
+from thwip.cli import ThwipCLI
+from thwip.config import ThwipConfig
+from thwip.detector import SystemDetector
+from thwip.limits import UsageTracker
+from thwip.session import Session
+from thwip.tools.terminal import TerminalRunner
+
+
+@pytest.mark.parametrize("field,value", [
+    ("estimated_cost", float("nan")), ("estimated_cost", float("inf")),
+    ("estimated_cost", True), ("estimated_cost", 10 ** 400),
+    ("last_limit_hit_timestamp", -1), ("last_limit_hit_timestamp", "bad"),
+    ("last_limit_hit_timestamp", float("nan")), ("last_error", []),
+])
+def test_usage_rejects_corrupt_values_without_losing_other_agents(tmp_path, monkeypatch, field, value):
+    path = tmp_path / "usage.json"
+    path.write_text(json.dumps({"bad": {field: value}, "good": {"estimated_cost": 0.5}}))
+    monkeypatch.setattr("thwip.limits.get_usage_path", lambda: path)
+    tracker = UsageTracker()
+    assert set(tracker.stats) == {"good"}
+    assert tracker.get_summary()["total_cost"] == 0.5
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("provider,auth", [("ollama", "none"), ("openai", "subscription"), ("google", "oauth"), ("claude", "none")])
+async def test_setup_guidance_matches_transport(monkeypatch, provider, auth):
+    panels = []
+    monkeypatch.setattr("thwip.cli.console.print", lambda panel: panels.append(panel))
+    cli = ThwipCLI.__new__(ThwipCLI)
+    cli.current_agent = SimpleNamespace(
+        name=provider, display_name="Provider [literal]", auth_method=auth,
+        is_configured=lambda: False,
+    )
+    cli.session = Session(current_model="model [literal]")
+    await cli.process_user_message("hello")
+    text = panels[0].renderable.plain
+    assert not cli.session.messages
+    if provider == "ollama":
+        assert "ollama serve" in text and "No API key is required" in text
+        assert "/key" not in text
+    else:
+        assert "model [literal]" in text and f"/key {provider}" in text
+        assert ("sign-in was detected" in text) == (auth in ("oauth", "subscription"))
+
+
+def test_display_switches_hide_status_fields():
+    cli = ThwipCLI.__new__(ThwipCLI)
+    cli.config = ThwipConfig()
+    cli.current_agent = OpenAIAgent(api_key="test")
+    cli.session = Session(current_model=cli.current_agent.get_default_model())
+    cli.session.add_assistant_message("done", "openai", cli.session.current_model, tokens=42)
+    cli.usage_tracker = SimpleNamespace(get_summary=lambda: {"total_cost": 1.25})
+    visible = cli._render_status().plain
+    assert "42 tok" in visible and "$1.2500" in visible and "[chat]" in visible
+    for name in ("show_agent_badge", "show_token_count", "show_cost", "show_capabilities"):
+        setattr(cli.config.display, name, False)
+    assert cli._render_status().plain == ""
+    cli.config.display.markdown = False
+    assert isinstance(cli._render_response("**literal**"), Text)
+    assert cli._render_response("**literal**").plain == "**literal**"
+
+
+@pytest.mark.parametrize("content,expected", [
+    ('{"userID":"metadata-only"}', False),
+    ('{"apiKey":""}', False),
+    ('{"apiKey":42}', False),
+    ('{"apiKey":"test-key"}', True),
+    ('{"credentials":{"apiKey":"test-key"}}', True),
+])
+def test_detector_requires_actual_key_field(tmp_path, monkeypatch, content, expected):
+    path = tmp_path / "claude.json"
+    path.write_text(content)
+    monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
+    monkeypatch.setattr("thwip.detector.KNOWN_CLI_TOOLS", [{
+        "name": "Claude", "company": "Anthropic", "binaries": [], "category": "CLI Agent",
+        "key_env": "ANTHROPIC_API_KEY", "config_files": [str(path)], "capabilities": [],
+    }])
+    monkeypatch.setattr("thwip.detector.KNOWN_APPS", [])
+    monkeypatch.setattr("thwip.detector.subprocess.run", lambda *a, **k: SimpleNamespace(returncode=1))
+    found = SystemDetector().scan_all()
+    assert bool(found) is expected
+
+
+@pytest.mark.asyncio
+async def test_openai_preserves_reasoning_and_function_items():
+    captured = []
+    items = [SimpleNamespace(type="reasoning", id="r1", encrypted_content="opaque", summary=[]),
+             SimpleNamespace(type="function_call", call_id="c1", name="read_file", arguments='{"file_path":"x"}')]
+
+    async def create(**kwargs):
+        captured.append(kwargs)
+        return SimpleNamespace(output_text="", output=items, usage=None)
+
+    agent = OpenAIAgent(api_key="test")
+    agent._client = SimpleNamespace(responses=SimpleNamespace(create=create))
+    events = [e async for e in agent.chat(messages=[{"role": "user", "content": "read"}], stream=False)]
+    done = next(e for e in events if isinstance(e, AgentDone))
+    messages = [{"role": "assistant", "content": "", "_native_state": done.native_state},
+                {"role": "tool", "tool_call_id": "c1", "content": "result"}]
+    _ = [e async for e in agent.chat(messages=messages, stream=False)]
+    assert captured[-1]["input"][:2] == [vars(item) for item in items]
+    assert captured[-1]["input"][2]["type"] == "function_call_output"
+    assert captured[-1]["store"] is False
+
+
+@pytest.mark.asyncio
+async def test_claude_preserves_thinking_signature():
+    captured = []
+    blocks = [SimpleNamespace(type="thinking", thinking="thought", signature="signature"),
+              SimpleNamespace(type="tool_use", id="c1", name="read_file", input={"file_path":"x"})]
+
+    async def create(**kwargs):
+        captured.append(kwargs)
+        return SimpleNamespace(content=blocks, usage=SimpleNamespace(input_tokens=1, output_tokens=1), stop_reason="tool_use")
+
+    agent = ClaudeAgent(api_key="test")
+    agent._client = SimpleNamespace(messages=SimpleNamespace(create=create))
+    events = [e async for e in agent.chat(messages=[], stream=False)]
+    done = next(e for e in events if isinstance(e, AgentDone))
+    _ = [e async for e in agent.chat(messages=[{"role":"assistant", "_native_state":done.native_state}], stream=False)]
+    assert captured[-1]["messages"][0]["content"] == [vars(block) for block in blocks]
+
+
+@pytest.mark.asyncio
+async def test_google_preserves_thought_signature():
+    from google.genai import types
+
+    captured = []
+    content = types.Content(role="model", parts=[types.Part(
+        function_call=types.FunctionCall(name="read_file", args={"file_path":"x"}),
+        thought_signature=b"opaque-signature",
+    )])
+
+    def generate(**kwargs):
+        captured.append(kwargs)
+        return SimpleNamespace(candidates=[SimpleNamespace(content=content)], usage_metadata=None)
+
+    agent = GoogleAgent(api_key="test")
+    agent._client = SimpleNamespace(models=SimpleNamespace(generate_content=generate))
+    events = [e async for e in agent.chat(messages=[], stream=False)]
+    done = next(e for e in events if isinstance(e, AgentDone))
+    _ = [e async for e in agent.chat(messages=[{"role":"assistant", "_native_state":done.native_state}], stream=False)]
+    assert captured[-1]["contents"][0].parts[0].thought_signature == b"opaque-signature"
+
+
+def test_sync_timeout_stops_child_writes(tmp_path):
+    runner = TerminalRunner(tmp_path)
+    result = runner.run_command("sleep 0.3; printf unwanted > late.txt", timeout=0.03)
+    assert "timed out" in result
+    time.sleep(0.4)
+    assert not (tmp_path / "late.txt").exists()
+
+
+@pytest.mark.asyncio
+async def test_async_cancellation_stops_child_writes(tmp_path):
+    runner = TerminalRunner(tmp_path)
+    task = asyncio.create_task(runner.run_command_async("sleep 0.3; printf unwanted > late.txt"))
+    await asyncio.sleep(0.03)
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+    await asyncio.sleep(0.4)
+    assert not (tmp_path / "late.txt").exists()