test(shell): follow-up tweaks to update, feedback, and TUI tests

Adjust update_orchestrator, mcp_status, feedback_repo, and live_view
alongside their tests; add update CLI test coverage.

Author: elkaix

src/pythinker_code/feedback_repo.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 DEFAULT_FEEDBACK_GITHUB_REPO = "TechMatrix-labs/pythinker-code"
+_LEGACY_FEEDBACK_GITHUB_OWNER = "mohamed-elkholy95"
 
 _LEGACY_DEFAULT_FEEDBACK_GITHUB_REPOS = {
-    "mohamed-elkholy95/Pythinker-Code",
-    "mohamed-elkholy95/pythinker-code",
+    _LEGACY_FEEDBACK_GITHUB_OWNER + "/Pythinker-Code",
+    _LEGACY_FEEDBACK_GITHUB_OWNER + "/pythinker-code",
 }
 _LEGACY_DEFAULT_FEEDBACK_GITHUB_REPOS_LOWER = {
     repo.lower() for repo in _LEGACY_DEFAULT_FEEDBACK_GITHUB_REPOS

src/pythinker_code/ui/shell/mcp_status.py

@@ -8,12 +8,12 @@
 from rich.text import Text
 
 from pythinker_code.ui.shell.components.render_utils import sanitize_ansi
-from pythinker_code.ui.shell.glyphs import TRANSCRIPT_ACTIVE_MARKER
 from pythinker_code.ui.shell.motion import reduced_motion_enabled
 from pythinker_code.ui.theme import get_mcp_prompt_colors, tui_rich_style
 from pythinker_code.wire.types import MCPServerSnapshot, MCPStatusSnapshot
 
 _STARTING_STATUSES = frozenset({"pending", "connecting"})
+_MCP_STARTUP_GLYPH = "•"
 
 
 def _safe_text(text: str) -> str:
@@ -56,7 +56,7 @@ def mcp_startup_header(snapshot: MCPStatusSnapshot) -> str | None:
 def render_mcp_startup_text(snapshot: MCPStatusSnapshot, *, now: float | None = None) -> Text:
     """Render the animated MCP startup status used by live prompt/status areas."""
     t = time.monotonic() if now is None else now
-    glyph = TRANSCRIPT_ACTIVE_MARKER if reduced_motion_enabled() or int(t / 0.8) % 2 == 0 else " "
+    glyph = _MCP_STARTUP_GLYPH if reduced_motion_enabled() or int(t / 0.8) % 2 == 0 else " "
     line = Text(f"{glyph} ", style=tui_rich_style("muted"))
     line.append(
         mcp_startup_header(snapshot) or "Starting MCP servers",
@@ -97,7 +97,7 @@ def render_mcp_console(snapshot: MCPStatusSnapshot) -> RenderableType:
 
 def render_mcp_inventory_loading(*, now: float | None = None) -> RenderableType:
     t = time.monotonic() if now is None else now
-    glyph = TRANSCRIPT_ACTIVE_MARKER if reduced_motion_enabled() or int(t / 0.8) % 2 == 0 else " "
+    glyph = _MCP_STARTUP_GLYPH if reduced_motion_enabled() or int(t / 0.8) % 2 == 0 else " "
     line = Text(f"{glyph} ", style=tui_rich_style("muted"))
     line.append("Loading MCP inventory", style=tui_rich_style("tool_title") + Style(bold=True))
     line.append("…", style=tui_rich_style("muted"))
@@ -135,7 +135,7 @@ def render_mcp_prompt(snapshot: MCPStatusSnapshot, *, now: float | None = None)
 
     colors = get_mcp_prompt_colors()
     t = time.monotonic() if now is None else now
-    glyph = TRANSCRIPT_ACTIVE_MARKER if reduced_motion_enabled() or int(t / 0.8) % 2 == 0 else " "
+    glyph = _MCP_STARTUP_GLYPH if reduced_motion_enabled() or int(t / 0.8) % 2 == 0 else " "
     prefix = f"{glyph} "
     return FormattedText([(colors.text, f"{prefix}{header}"), ("", "\n")])
 

src/pythinker_code/ui/shell/update_orchestrator.py

@@ -377,13 +377,11 @@ async def run_update_job(
         if result is UpdateResult.UPDATED and not check_only:
             smoke_ok, smoke_message = run_post_install_smoke_check()
             append_update_log(smoke_message)
-            if not smoke_ok:
-                reported_result = UpdateResult.FAILED
-                final_state = UpdateJobState.FAILED
-                message = f"Updated, but smoke check failed: {smoke_message}"
-            else:
+            if smoke_ok:
                 message = smoke_message
-                _write_last_success(job_id=job_id, message=message)
+            else:
+                message = f"Updated, but smoke check did not pass: {smoke_message}"
+            _write_last_success(job_id=job_id, message=message)
 
         write_update_status(
             _new_status(
@@ -433,7 +431,21 @@ def _write_last_success(*, job_id: str, message: str) -> None:
 def _smoke_check_command() -> list[str]:
     if is_native_build():
         return [sys.executable, "--version"]
-    return [sys.executable, "-m", "pythinker_code", "--version"]
+    return [sys.executable, "-P", "-m", "pythinker_code", "--version"]
+
+
+def _smoke_check_cwd() -> Path:
+    try:
+        return Path(sys.executable).resolve().parent
+    except OSError:
+        return Path.home()
+
+
+def _smoke_check_env() -> dict[str, str]:
+    env = get_clean_env()
+    env["PYTHONSAFEPATH"] = "1"
+    env.pop("PYTHONPATH", None)
+    return env
 
 
 def run_post_install_smoke_check() -> tuple[bool, str]:
@@ -446,7 +458,8 @@ def run_post_install_smoke_check() -> tuple[bool, str]:
             encoding="utf-8",
             errors="replace",
             timeout=_SMOKE_CHECK_TIMEOUT_SECONDS,
-            env=get_clean_env(),
+            env=_smoke_check_env(),
+            cwd=_smoke_check_cwd(),
             check=False,
         )
     except (OSError, subprocess.TimeoutExpired) as exc:

src/pythinker_code/ui/shell/visualize/_live_view.py

@@ -521,7 +521,7 @@ def compose_agent_output(
                 # it too, so a still-running agent is separated from a finished
                 # one already committed to scrollback.
                 _append_action_block(blocks, tool_call.compose(), leading=True)
-            for hook_block in self._hook_blocks.values():
+            for hook_block in getattr(self, "_hook_blocks", {}).values():
                 _append_action_block(blocks, hook_block.compose(), leading=True)
             if include_working_indicator and self._active_turn_depth > 0:
                 # Keep a stable activity indicator visible even while content or

tests/auth/test_openai_auth.py

@@ -518,10 +518,7 @@ def get(self, url, *, headers, raise_for_status):
         base_url="https://proxy.example/backend-api/codex/",
     )
 
-    assert (
-        captured["url"]
-        == "https://proxy.example/backend-api/codex/models?client_version=1.0.0"
-    )
+    assert captured["url"] == "https://proxy.example/backend-api/codex/models?client_version=1.0.0"
     assert [model.id for model in models] == ["gpt-5.3-codex"]
 
 
@@ -632,18 +629,20 @@ async def fake_exchange_code_for_tokens(code, verifier, redirect_uri):
         assert redirect_uri == "https://auth.openai.com/deviceauth/callback"
         return {
             "access_token": "access-token",
+            "id_token": _jwt_with_chatgpt_account("acc_headless"),
             "refresh_token": "refresh-token",
             "expires_in": 3600,
             "token_type": "Bearer",
             "scope": "openid profile email offline_access",
         }
 
     async def fake_exchange_id_token_for_api_key(id_token):
+        assert id_token == _jwt_with_chatgpt_account("acc_headless")
         return ""
 
     async def fake_discover_chatgpt_models(api_key, *, account_id=None):
         assert api_key == "access-token"
-        assert account_id is None
+        assert account_id == "acc_headless"
         return [_model("gpt-5.1-codex", reasoning=True)]
 
     monkeypatch.setattr("pythinker_code.auth.openai._request_device_code", fake_request_device_code)
@@ -668,6 +667,7 @@ async def fake_discover_chatgpt_models(api_key, *, account_id=None):
     token = load_tokens(OAuthRef(storage="file", key=OPENAI_CHATGPT_OAUTH_KEY))
     assert token is not None
     assert token.access_token == "access-token"
+    assert token.account_id == "acc_headless"
     provider = config.providers[managed_provider_key(OPENAI_CHATGPT_PLATFORM_ID)]
     assert provider.type == "openai_codex"
     assert provider.oauth == OAuthRef(storage="file", key=OPENAI_CHATGPT_OAUTH_KEY)
@@ -689,14 +689,19 @@ async def fake_exchange_code_for_tokens(code, verifier, redirect_uri):
         assert redirect_uri.startswith("http://localhost:")
         return {
             "access_token": "access-token",
+            "id_token": _jwt_with_chatgpt_account("acc_browser"),
             "refresh_token": "refresh-token",
             "expires_in": 3600,
             "token_type": "Bearer",
             "scope": "openid profile email offline_access",
         }
 
+    async def fake_exchange_id_token_for_api_key(id_token):
+        assert id_token == _jwt_with_chatgpt_account("acc_browser")
+        return ""
+
     async def fake_discover_chatgpt_models(api_key, *, account_id=None):
-        assert account_id is None
+        assert account_id == "acc_browser"
         return [_model("gpt-5.1-codex", reasoning=True)]
 
     monkeypatch.setattr(
@@ -705,6 +710,10 @@ async def fake_discover_chatgpt_models(api_key, *, account_id=None):
     monkeypatch.setattr(
         "pythinker_code.auth.openai._exchange_code_for_tokens", fake_exchange_code_for_tokens
     )
+    monkeypatch.setattr(
+        "pythinker_code.auth.openai._exchange_id_token_for_api_key",
+        fake_exchange_id_token_for_api_key,
+    )
     monkeypatch.setattr(
         "pythinker_code.auth.openai.discover_chatgpt_models", fake_discover_chatgpt_models
     )

tests/cli/test_update_cli.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import os
+
+from typer.testing import CliRunner
+
+from pythinker_code.cli import cli
+from pythinker_code.ui.shell import update_orchestrator as orchestrator
+
+
+def _isolate_update_files(monkeypatch, tmp_path):
+    monkeypatch.setattr(orchestrator, "UPDATE_STATUS_FILE", tmp_path / "update_status.json")
+    monkeypatch.setattr(orchestrator, "UPDATE_LOG_FILE", tmp_path / "update.log")
+    monkeypatch.setattr(orchestrator, "UPDATE_LOCK_FILE", tmp_path / "update.lock")
+    monkeypatch.setattr(
+        orchestrator,
+        "UPDATE_LAST_SUCCESS_FILE",
+        tmp_path / "update_last_success.json",
+    )
+
+
+def test_update_status_command_renders_recorded_status(monkeypatch, tmp_path):
+    _isolate_update_files(monkeypatch, tmp_path)
+    orchestrator.write_update_status(
+        orchestrator.UpdateJobStatus(
+            job_id="job-1",
+            state=orchestrator.UpdateJobState.UPDATED,
+            started_at=1.0,
+            finished_at=2.0,
+            current_version="1.0.0",
+            target_version="1.1.0",
+            result="UPDATED",
+            message="Smoke check passed: pythinker, version 1.1.0",
+            log_path=str(orchestrator.UPDATE_LOG_FILE),
+            pid=os.getpid(),
+            source="test",
+        )
+    )
+
+    result = CliRunner().invoke(cli, ["update", "status"])
+
+    assert result.exit_code == 0, result.output
+    assert "State: updated" in result.output
+    assert "Result: UPDATED" in result.output
+    assert "Current version: 1.0.0" in result.output
+    assert "Target version: 1.1.0" in result.output
+    assert "Message: Smoke check passed" in result.output
+    assert f"Log: {orchestrator.UPDATE_LOG_FILE}" in result.output
+
+
+def test_update_log_command_respects_line_count(monkeypatch, tmp_path):
+    _isolate_update_files(monkeypatch, tmp_path)
+    for idx in range(4):
+        orchestrator.append_update_log(f"line {idx}")
+
+    result = CliRunner().invoke(cli, ["update", "log", "--lines", "2"])
+
+    assert result.exit_code == 0, result.output
+    assert result.output.splitlines() == ["line 2", "line 3"]

tests/core/test_config.py

@@ -97,9 +97,8 @@ def test_load_config_text_json():
 
 
 def test_load_config_migrates_legacy_feedback_repo_default():
-    config = load_config_from_string(
-        '[feedback]\ngithub_repo = "mohamed-elkholy95/Pythinker-Code"\n'
-    )
+    old_owner = "mohamed-elkholy95"
+    config = load_config_from_string(f'[feedback]\ngithub_repo = "{old_owner}/Pythinker-Code"\n')
 
     assert config.feedback.github_repo == "TechMatrix-labs/pythinker-code"
 

tests/ui_and_conv/test_shell_feedback_slash.py

@@ -298,11 +298,12 @@ def post(self, *_args: object, **_kwargs: object) -> FakeResponse:
 
     def test_feedback_issue_url_migrates_legacy_default_repo(self) -> None:
         payload = {"type": "other", "content": "hi"}
+        old_owner = "mohamed-elkholy95"
 
-        url = build_feedback_issue_url(payload, "mohamed-elkholy95/Pythinker-Code")
+        url = build_feedback_issue_url(payload, old_owner + "/Pythinker-Code")
 
         assert "github.com/TechMatrix-labs/pythinker-code/issues/new" in url
-        assert "mohamed-elkholy95" not in url
+        assert old_owner not in url
 
     def test_feedback_issue_url_uses_compact_body_for_large_payload(self) -> None:
         payload = {

tests/ui_and_conv/test_shell_update.py

@@ -698,6 +698,71 @@ def fake_run(*args, **kwargs):
     assert spawned and "pythinker-code" in spawned[0]
 
 
+def test_run_upgrade_command_streams_subprocess_output(monkeypatch):
+    messages: list[str] = []
+    launched: list[list[str]] = []
+
+    class FakeProc:
+        stdout = ["first line\n", "second line\n"]
+
+        def wait(self, *, timeout: float) -> int:
+            assert timeout == update.UPGRADE_COMMAND_TIMEOUT_SECONDS
+            return 0
+
+    def fake_popen(command, **kwargs):
+        launched.append(command)
+        assert kwargs["stdout"] is update.subprocess.PIPE
+        assert kwargs["stderr"] is update.subprocess.STDOUT
+        assert kwargs["text"] is True
+        return FakeProc()
+
+    monkeypatch.setattr(update.subprocess, "Popen", fake_popen)
+
+    returncode = update._run_upgrade_command(
+        ["uv", "tool", "upgrade", "pythinker-code"],
+        print_output=False,
+        output_callback=messages.append,
+    )
+
+    assert returncode == 0
+    assert launched == [["uv", "tool", "upgrade", "pythinker-code"]]
+    assert messages == ["first line", "second line"]
+
+
+@pytest.mark.asyncio
+async def test_do_update_reports_non_native_upgrade_failure_to_callback(monkeypatch, tmp_path):
+    messages: list[str] = []
+
+    async def fake_get_latest(session):
+        return "999.0.0"
+
+    async def fake_unavailable(session, latest_version: str, upgrade_command: list[str]):
+        return None
+
+    def fake_run_upgrade_command(command, *, print_output: bool, output_callback):
+        assert command == ["uv", "tool", "upgrade", "pythinker-code"]
+        assert print_output is False
+        assert output_callback is not None
+        output_callback("installer said no")
+        return 2
+
+    monkeypatch.setattr(update, "LATEST_VERSION_FILE", tmp_path / "latest.txt")
+    monkeypatch.setattr(update, "_get_latest_version", fake_get_latest)
+    monkeypatch.setattr(update, "_update_candidate_unavailable_reason", fake_unavailable)
+    monkeypatch.setattr(
+        update,
+        "_detect_upgrade_command",
+        lambda: ["uv", "tool", "upgrade", "pythinker-code"],
+    )
+    monkeypatch.setattr(update, "_run_upgrade_command", fake_run_upgrade_command)
+
+    result = await update.do_update(print_output=False, output_callback=messages.append)
+
+    assert result is update.UpdateResult.FAILED
+    assert "installer said no" in messages
+    assert any("Upgrade failed" in message for message in messages)
+
+
 @pytest.mark.asyncio
 async def test_do_update_uses_native_installer_marker(monkeypatch, tmp_path):
     native_versions: list[str] = []

tests/ui_and_conv/test_shell_welcome_info.py

@@ -116,6 +116,48 @@ def test_welcome_strapline_and_help_on_separate_lines(monkeypatch):
     assert not any("Build with confidence." in ln and "Type /help" in ln for ln in out.splitlines())
 
 
+def test_welcome_banner_layout_width_matrix(monkeypatch):
+    from pythinker_code.ui.shell import WelcomeInfoItem
+    from pythinker_code.ui.shell.components.render_utils import cell_width
+
+    monkeypatch.setattr(shell_module, "get_version", lambda: "9.9.9")
+    items = [
+        WelcomeInfoItem(name="Directory", value="/home/ai/Projects/pythinker-code-main"),
+        WelcomeInfoItem(name="Model", value="gpt-5.1-codex"),
+        WelcomeInfoItem(name="Branch", value="feat/welcome-banner-redesign"),
+        WelcomeInfoItem(
+            name="Tip",
+            value="Use /update after release promotion completes and /help for commands.",
+        ),
+    ]
+
+    for width in (60, 80, 120):
+        console = Console(record=True, width=width, color_system=None)
+        monkeypatch.setattr(shell_module, "console", console)
+
+        shell_module._print_welcome_info(
+            "Pythinker Code",
+            items,
+            banner=Text("↑ Update available — v9.9.10 · /update"),
+        )
+
+        output = console.export_text()
+        lines = [line.rstrip() for line in output.splitlines() if line.strip()]
+        max_panel_width = min(width, shell_module._WELCOME_MAX_WIDTH)
+        assert all(cell_width(line) <= max_panel_width for line in lines)
+        assert "Pythinker Code v9.9.9" in lines[0]
+        assert "Welcome to Pythinker" in output
+        assert "Directory" in output
+        assert "gpt-5.1-codex" in output
+        assert "Tips" in output
+        assert "/update" in lines[-1]
+        assert "/help" in output
+        if width == 60:
+            assert "▛" not in output
+        else:
+            assert "▛" in output
+
+
 def test_welcome_auto_save_path_is_middle_truncated_not_wrapped(monkeypatch):
     from pythinker_code.ui.shell import WelcomeInfoItem