sylliptor-agent-cli 0.9.3__tar.gz → 0.9.4__tar.gz

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.4] - 2026-06-16
+
+### Added
+
+- Polished Forge CLI planning and execution feedback with clearer readiness, next-step,
+  completion, and swarm trace status lines.
+
+### Fixed
+
+- Kept the welcome banner side-by-side at 80 columns when dark terminal themes add the
+  light owl panel.
+- Restored the Forge asset count line for empty plans that already have indexed assets.
+
 ## [0.9.3] - 2026-06-12
 
 ### Added

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sylliptor-agent-cli
-Version: 0.9.3
+Version: 0.9.4
 Summary: Local CLI coding agent powered by any API.
 Project-URL: Changelog, https://github.com/AlysisAi/Sylliptor/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://github.com/AlysisAi/Sylliptor/tree/main/docs

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sylliptor-agent-cli"
-version = "0.9.3"
+version = "0.9.4"
 description = "Local CLI coding agent powered by any API."
 readme = "README.md"
 requires-python = ">=3.11"

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.9.3"
+__version__ = "0.9.4"

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/agent/session.py

@@ -922,6 +922,7 @@ class AgentSession:
         routing_mode_override: str | None = None,
         ephemeral_system_messages: list[str] | tuple[str, ...] | None = None,
         ephemeral_user_messages: list[str] | tuple[str, ...] | None = None,
+        cancellation_token: Any | None = None,
     ) -> int:
         return _run_turn(
             self,
@@ -930,6 +931,7 @@ class AgentSession:
             routing_mode_override=routing_mode_override,
             ephemeral_system_messages=ephemeral_system_messages,
             ephemeral_user_messages=ephemeral_user_messages,
+            cancellation_token=cancellation_token,
         )
 
 

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/agent/turn/core.py

@@ -436,7 +436,18 @@ def run_turn(
     routing_mode_override: str | None = None,
     ephemeral_system_messages: list[str] | tuple[str, ...] | None = None,
     ephemeral_user_messages: list[str] | tuple[str, ...] | None = None,
+    cancellation_token: Any | None = None,
 ) -> int:
+    def _throw_if_cancelled() -> None:
+        if cancellation_token is None:
+            return
+        throw_if_cancelled = getattr(cancellation_token, "throw_if_cancelled", None)
+        if callable(throw_if_cancelled):
+            throw_if_cancelled("cancelled_by_user")
+            return
+        if bool(getattr(cancellation_token, "is_cancelled", False)):
+            raise RuntimeError("cancelled_by_user")
+
     def _phase_update(message: str) -> None:
         clean = message.strip()
         if not clean:
@@ -450,6 +461,7 @@ def run_turn(
     image_paths = list(image_paths or [])
     assistant_message_emitted = False
     steps_attempted = 0
+    _throw_if_cancelled()
 
     def _finish_turn(code: int, *, reason: str, final_text: str = "") -> int:
         if self.hook_dispatcher is not None:
@@ -1069,6 +1081,7 @@ def run_turn(
     last_edit_stagnation_payload: dict[str, Any] | None = None
 
     for step in range(1, turn_max_steps + 1):
+        _throw_if_cancelled()
         steps_attempted = step
         stream_used = self.stream
         step_ephemeral_suffix_system_messages: list[str] = []

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/cli_impl/chat/commands.py

@@ -11,7 +11,12 @@ import typer
 from rich.text import Text
 
 from ...plan_validation import PlannerFailedError, raise_for_execution_ready_plan
-from ...surface.styles import STYLE_EMPHASIS
+from ...surface.styles import (
+    STYLE_CHROME,
+    STYLE_EMPHASIS,
+    STYLE_SUCCESS,
+    STYLE_WARN,
+)
 from ...swarm_orchestrator import acquire_swarm_mutation_guard
 from .state import _ChatExecutionRequest, _ChatPlanModeState, _ForgeChatState
 
@@ -1953,7 +1958,20 @@ def _handle_forge_chat_command(
                     f"Execution finished with issues · {failed_tasks} failed · "
                     f"{remaining_tasks} remaining."
                 )
-            _print_forge_meta(console=console, message=headline, style=STYLE_EMPHASIS)
+            done_ok = total_tasks > 0 and failed_tasks == 0 and remaining_tasks == 0 and code == 0
+            console.print(
+                _forge_phase_rule(console=console, label="DONE"),
+                highlight=False,
+            )
+            dot = "●" if _forge_supports_unicode_glyphs(console) else "*"
+            console.print(
+                Text.assemble(
+                    ("│ ", STYLE_CHROME),
+                    (f"{dot} ", STYLE_SUCCESS if done_ok else STYLE_WARN),
+                    (headline, STYLE_EMPHASIS),
+                ),
+                highlight=False,
+            )
             _print_forge_meta(
                 console=console,
                 message=(

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/cli_impl/commands/cli_common.py

@@ -160,6 +160,7 @@ from ...extensions.state import (
 )
 from ...extensions.workspace_trust import is_workspace_trusted
 from ...surface.styles import (
+    STYLE_ACCENT,
     STYLE_CHROME,
     STYLE_CONTENT,
     STYLE_DESELECTED_DESC,
@@ -627,6 +628,81 @@ def _print_forge_error(*, console: Console, message: str) -> None:
     )
 
 
+def _forge_supports_unicode_glyphs(console: Console) -> bool:
+    """Whether the console encoding can render the status/box glyphs we add."""
+    encoding = str(getattr(console, "encoding", "") or "")
+    if not encoding:
+        return True
+    try:
+        "●○─→✓✗".encode(encoding)
+    except (LookupError, UnicodeError):
+        return False
+    return True
+
+
+def _forge_phase_rule(*, console: Console, label: str, style: str = STYLE_EMPHASIS) -> Any:
+    """A quiet ``│ -- LABEL --...`` separator sized to the terminal width."""
+    from rich.text import Text
+
+    clean_label = str(label or "").strip()
+    dash = "─" if _forge_supports_unicode_glyphs(console) else "-"
+    try:
+        width = int(getattr(console, "width", 0) or 0)
+    except (TypeError, ValueError):
+        width = 0
+    width = max(width, _MIN_TERMINAL_COLUMNS)
+    lead = dash * 2
+    if not clean_label:
+        body = max(3, width - 2)
+        return Text.assemble(("│ ", STYLE_CHROME), (dash * body, STYLE_CHROME))
+    used = 2 + len(lead) + 1 + len(clean_label) + 1
+    tail = max(3, width - used)
+    return Text.assemble(
+        ("│ ", STYLE_CHROME),
+        (f"{lead} ", STYLE_CHROME),
+        (clean_label, style),
+        (" ", STYLE_CHROME),
+        (dash * tail, STYLE_CHROME),
+    )
+
+
+def _print_forge_suggestion(*, console: Console, message: str) -> None:
+    """Print a dim ``│ -> ...`` next-step nudge under a Forge command result."""
+    from rich.text import Text
+
+    arrow = "→" if _forge_supports_unicode_glyphs(console) else "->"
+    console.print(
+        Text.assemble(
+            ("│ ", STYLE_CHROME),
+            (f"{arrow} ", STYLE_ACCENT),
+            (str(message or ""), STYLE_DIM),
+        ),
+        highlight=False,
+    )
+
+
+def _forge_plan_has_requirement(plan: dict[str, Any]) -> bool:
+    requirements = plan.get("requirements") if isinstance(plan, dict) else None
+    if not isinstance(requirements, list):
+        return False
+    return any(bool(str(requirement_text(req)).strip()) for req in requirements)
+
+
+def _forge_plan_state(plan: dict[str, Any]) -> str:
+    """Classify a Forge plan into empty/planning/ready/done for UI guidance."""
+    if not isinstance(plan, dict):
+        return "empty"
+    tasks = plan.get("tasks") or []
+    has_tasks = isinstance(tasks, list) and len(tasks) > 0
+    if not has_tasks:
+        return "planning" if _forge_plan_has_requirement(plan) else "empty"
+    done, failed, remaining = _forge_task_status_counts(plan)
+    total = done + failed + remaining
+    if total > 0 and failed == 0 and remaining == 0:
+        return "done"
+    return "ready"
+
+
 def _forge_task_status_counts(plan: dict[str, Any]) -> tuple[int, int, int]:
     from ...swarm_scheduler import canonical_task_status
 

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/cli_impl/commands/forge_helpers.py

@@ -64,8 +64,63 @@ def _forge_help_panel() -> Panel:
     return _chat_commands_panel(ui_mode="forge")
 
 
+def _forge_plan_readiness_line(*, console: Console, plan: dict[str, Any]) -> Any:
+    """A one-line go/no-go readiness chip derived from the current plan state."""
+    from rich.text import Text
+
+    use_unicode = _forge_supports_unicode_glyphs(console)
+    filled = "●" if use_unicode else "*"
+    hollow = "○" if use_unicode else "o"
+    tasks = plan.get("tasks") or []
+    has_tasks = isinstance(tasks, list) and len(tasks) > 0
+    if not has_tasks:
+        if _forge_plan_has_requirement(plan):
+            req_count = sum(
+                1 for req in (plan.get("requirements") or []) if str(requirement_text(req)).strip()
+            )
+            req_word = "requirement" if req_count == 1 else "requirements"
+            text = f"{req_count} {req_word}, 0 tasks — describe the work or /task to add tasks"
+        else:
+            text = "no tasks yet · add /goal then /task to start planning"
+        return Text.assemble(("│ ", STYLE_CHROME), (f"{hollow} ", STYLE_DIM), (text, STYLE_DIM))
+    done, failed, remaining = _forge_task_status_counts(plan)
+    total = done + failed + remaining
+    if failed > 0:
+        task_word = "task" if failed == 1 else "tasks"
+        text = f"needs attention · {failed} {task_word} blocked — see status column"
+        glyph_style = STYLE_WARN
+    elif remaining == 0 and total > 0:
+        task_word = "task" if total == 1 else "tasks"
+        text = f"all tasks done · {done} of {total} {task_word} finished"
+        glyph_style = STYLE_SUCCESS
+    else:
+        task_word = "task" if total == 1 else "tasks"
+        text = f"ready to execute · {total} {task_word} · 0 blocked"
+        glyph_style = STYLE_SUCCESS
+    return Text.assemble(("│ ", STYLE_CHROME), (f"{filled} ", glyph_style), (text, STYLE_DIM))
+
+
+def _forge_next_step_line(*, console: Console, plan: dict[str, Any]) -> Any:
+    """A state-aware ``Next`` hint naming the single best next command."""
+    from rich.text import Text
+
+    _ = console
+    hint = {
+        "empty": "paste your goal, or /goal then /task to start planning",
+        "planning": "/show to review, then /execute plan when ready",
+        "ready": "/execute plan to start the run",
+        "done": "run complete · /done to save, or /back to chat",
+    }.get(_forge_plan_state(plan), "/help for commands")
+    return Text.assemble(
+        ("│ ", STYLE_CHROME),
+        ("Next · ", STYLE_ACCENT),
+        (hint, STYLE_DIM),
+    )
+
+
 def _forge_enter_panel(
     *,
+    console: Console,
     paths: RunPaths,
     plan: dict[str, Any],
     entry_kind: str,
@@ -91,6 +146,8 @@ def _forge_enter_panel(
             text="/show for summary · /execute plan when ready · /help for commands",
             style="dim",
         ),
+        _forge_plan_readiness_line(console=console, plan=plan),
+        _forge_next_step_line(console=console, plan=plan),
     )
 
 
@@ -270,6 +327,7 @@ def _show_forge_plan_summary(*, console: Console, paths: RunPaths, plan: dict[st
         message=f"Run {paths.run_id} · {task_count} tasks · {asset_count} assets",
         style=STYLE_EMPHASIS,
     )
+    console.print(_forge_plan_readiness_line(console=console, plan=plan), highlight=False)
     _print_forge_meta(console=console, message=f"Goal · {goal}", style=STYLE_CONTENT)
     _print_forge_meta(console=console, message=f"Summary · {summary}", style=STYLE_CONTENT)
     requirements = plan.get("requirements") or []
@@ -290,6 +348,18 @@ def _show_forge_plan_summary(*, console: Console, paths: RunPaths, plan: dict[st
                 style="dim",
             )
 
+    if not _forge_has_usable_plan_input(plan):
+        if asset_count:
+            _print_forge_meta(console=console, message=f"Assets · {asset_count}", style="dim")
+        _print_forge_meta(console=console, message="This plan is empty.", style=STYLE_EMPHASIS)
+        _print_forge_meta(
+            console=console,
+            message="Add work two ways: paste a goal/spec, or use /goal then /task.",
+            style=STYLE_CONTENT,
+        )
+        console.print(_forge_next_step_line(console=console, plan=plan), highlight=False)
+        return
+
     table = _forge_task_table()
     table.add_column("id", style="dim", no_wrap=True, ratio=1)
     table.add_column("status", style="dim", no_wrap=True, ratio=1)
@@ -311,6 +381,7 @@ def _show_forge_plan_summary(*, console: Console, paths: RunPaths, plan: dict[st
         table.add_row("-", "-", "(no tasks yet)", "-", "off")
     console.print(table)
     _print_forge_meta(console=console, message=f"Assets · {asset_count}", style="dim")
+    console.print(_forge_next_step_line(console=console, plan=plan), highlight=False)
 
 
 def _show_forge_plan_markdown(
@@ -1012,6 +1083,7 @@ def _enter_forge_mode(
     )
     console.print(
         _forge_enter_panel(
+            console=console,
             paths=paths,
             plan=plan,
             entry_kind=entry_selection.entry_kind,

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/cli_impl/commands/welcome.py

@@ -451,42 +451,52 @@ def printWelcome(
             ]
 
         if owl_frames:
-            right_width = max(
-                safe_line_width - visibleLength(indent) - logo_width - visibleLength(gap),
-                1,
-            )
-            detail_lines = welcome_detail_lines(right_width)
-            required_side_by_side_width = visibleLength(indent) + logo_width + visibleLength(gap)
-            required_side_by_side_width += max(
-                (visibleLength(line) for line in detail_lines),
-                default=0,
-            )
-            if safe_line_width >= required_side_by_side_width:
+            side_by_side_layouts = [(indent, gap)]
+            if indent or visibleLength(gap) > 1:
+                side_by_side_layouts.append(("", " "))
+            for left_indent, middle_gap in side_by_side_layouts:
+                right_width = max(
+                    safe_line_width
+                    - visibleLength(left_indent)
+                    - logo_width
+                    - visibleLength(middle_gap),
+                    1,
+                )
+                detail_lines = welcome_detail_lines(right_width)
+                required_side_by_side_width = (
+                    visibleLength(left_indent) + logo_width + visibleLength(middle_gap)
+                )
+                required_side_by_side_width += max(
+                    (visibleLength(line) for line in detail_lines),
+                    default=0,
+                )
+                if safe_line_width < required_side_by_side_width:
+                    continue
                 right_start = max((len(logo_frame) - len(detail_lines)) // 2, 0)
                 rendered_lines = []
                 total_rows = max(len(logo_frame), right_start + len(detail_lines))
                 for row_index in range(total_rows):
                     row = logo_frame[row_index] if row_index < len(logo_frame) else ""
-                    line = f"{indent}{padLine(row, logo_width)}"
+                    line = f"{left_indent}{padLine(row, logo_width)}"
                     right_index = row_index - right_start
                     if 0 <= right_index < len(detail_lines):
-                        line = f"{line}{gap}{detail_lines[right_index]}"
+                        line = f"{line}{middle_gap}{detail_lines[right_index]}"
                     rendered_lines.append(_clip_visible_line(line.rstrip(), safe_line_width))
                 return rendered_lines
-            else:
-                rendered_lines = []
-                rendered_lines.extend(
-                    _clip_visible_line(f"{indent}{row.rstrip()}".rstrip(), safe_line_width)
-                    for row in logo_frame
-                )
-                rendered_lines.append("")
-                full_detail_width = max(safe_line_width - visibleLength(indent), 1)
-                full_detail_lines = welcome_detail_lines(full_detail_width)
-                rendered_lines.extend(
-                    _clip_visible_line(f"{indent}{line}".rstrip(), safe_line_width)
-                    for line in full_detail_lines
-                )
-                return rendered_lines
+
+            rendered_lines = []
+            rendered_lines.extend(
+                _clip_visible_line(f"{indent}{row.rstrip()}".rstrip(), safe_line_width)
+                for row in logo_frame
+            )
+            rendered_lines.append("")
+            full_detail_width = max(safe_line_width - visibleLength(indent), 1)
+            full_detail_lines = welcome_detail_lines(full_detail_width)
+            rendered_lines.extend(
+                _clip_visible_line(f"{indent}{line}".rstrip(), safe_line_width)
+                for line in full_detail_lines
+            )
+            return rendered_lines
 
         context_line = _welcome_context_line(
             workspace=workspace,

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/cli_impl/forge.py

@@ -337,6 +337,7 @@ def forge_plan(
         console.print(line)
     console.print("Planning loop started. Type /help for commands. Type /done to finish.")
     assistant_enabled = False
+    planning_suggested: set[str] = set()
     planner_state = _ForgePlannerSessionState(
         workspace_context=(
             _workspace_context_payload_for_paths(paths=paths) or workspace_scan.to_dict()
@@ -460,6 +461,12 @@ def forge_plan(
                 plan["summary"] = goal
             save_plan(paths, plan)
             console.print("Project goal updated.")
+            if "goal" not in planning_suggested:
+                planning_suggested.add("goal")
+                console.print(
+                    "[dim]Next: add tasks with /task <title>, or describe the work and "
+                    "let the planner draft them.[/dim]"
+                )
             append_transcript_note(paths, role="system", message="Updated project goal.")
             continue
         if cmd == "/task":
@@ -484,6 +491,11 @@ def forge_plan(
                 continue
             save_plan(paths, plan)
             console.print(f"Added task: {task['id']} - {task['title']}")
+            if "task" not in planning_suggested:
+                planning_suggested.add("task")
+                console.print(
+                    "[dim]Next: add more tasks, or /done to save and validate the plan.[/dim]"
+                )
             append_transcript_note(paths, role="system", message=f"Added task {task['id']}.")
             continue
 

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/surface/rich_surface.py

@@ -285,6 +285,32 @@ def _progress_message_completes_activity(message: str) -> bool:
     return any(clean.startswith(prefix) for prefix in _TERMINAL_PROGRESS_PREFIXES)
 
 
+_SWARM_TRACE_SUCCESS_KEYWORDS = (
+    "merged successfully",
+    "applied successfully",
+    "accepted verified",
+    "review approved",
+    "verification passed",
+    "verified no-op",
+    "completed successfully",
+)
+
+
+def _swarm_trace_severity(phase: str, message: str) -> str:
+    """Classify a swarm trace line into error/warning/success/neutral."""
+    normalized_phase = str(phase or "").strip().lower()
+    normalized_message = str(message or "").strip().lower()
+    if normalized_phase.endswith(".error"):
+        return "error"
+    if normalized_phase.endswith(".warning") or normalized_message.startswith("warning"):
+        return "warning"
+    if "warning:" in normalized_message:
+        return "warning"
+    if any(keyword in normalized_message for keyword in _SWARM_TRACE_SUCCESS_KEYWORDS):
+        return "success"
+    return "neutral"
+
+
 class _ThinkingSpinnerRenderable:
     def __init__(self, surface: RichSurface) -> None:
         self._surface = surface
@@ -631,6 +657,61 @@ class RichSurface:
         if not self._assistant_stream_open and not self._tool_start_info:
             self._start_thinking_spinner(label="Thinking...")
 
+    def _supports_unicode_glyphs(self) -> bool:
+        encoding = str(getattr(self.console, "encoding", "") or "")
+        if not encoding:
+            return True
+        try:
+            "✓✗".encode(encoding)
+        except (LookupError, UnicodeError):
+            return False
+        return True
+
+    def _swarm_severity_glyph(self, severity: str) -> tuple[str, str]:
+        use_unicode = self._supports_unicode_glyphs()
+        if severity == "error":
+            return (("✗" if use_unicode else "x"), _STYLE_FAILURE)
+        if severity == "success":
+            return (("✓" if use_unicode else "v"), _STYLE_SUCCESS)
+        if severity == "warning":
+            return ("!", _STYLE_WARNING)
+        return ("•", _STYLE_CHROME)
+
+    def on_swarm_trace(
+        self,
+        message: str,
+        *,
+        phase: str = "",
+        task_id: str | None = None,
+    ) -> None:
+        """Render a live swarm trace line, colorizing verify/review/merge outcomes."""
+        _ = task_id
+        if self._trace_level == "off":
+            return
+        severity = _swarm_trace_severity(phase, message)
+        if severity == "neutral":
+            self.on_progress_update(message)
+            return
+        self._stop_thinking_spinner()
+        clean = _redact(str(message or "").strip())
+        if not clean:
+            return
+        glyph, glyph_style = self._swarm_severity_glyph(severity)
+        line_key = f"swarm-trace:{severity}\0{clean}"
+        if line_key == self._last_trace_line_key:
+            return
+        self._last_trace_line_key = line_key
+        self._thinking_open = True
+        self.console.print(
+            Text.assemble((f"{glyph} ", glyph_style), (clean, _STYLE_META)),
+            highlight=False,
+        )
+        if _progress_message_completes_activity(message):
+            self._stop_thinking_spinner()
+            return
+        if not self._assistant_stream_open and not self._tool_start_info:
+            self._start_thinking_spinner(label="Reasoning...")
+
     def on_subagent_start(self, event: SubagentStartEvent) -> None:
         if self._trace_level == "off":
             return

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/src/sylliptor_agent_cli/swarm_trace.py

@@ -217,6 +217,13 @@ class SerializedSwarmTraceSink:
                 )
             except Exception:
                 pass
+        trace_handler = getattr(self.surface, "on_swarm_trace", None)
+        if callable(trace_handler):
+            try:
+                trace_handler(message, phase=event.phase, task_id=event.task_id)
+                return
+            except Exception:
+                pass
         handler = getattr(self.surface, "on_progress_update", None)
         if callable(handler):
             try:

{sylliptor_agent_cli-0.9.3 → sylliptor_agent_cli-0.9.4}/tests/test_cli_ux.py

@@ -942,6 +942,34 @@ def test_print_welcome_banner_keeps_compact_owl_left_at_80_columns(monkeypatch)
     assert any("▝▜██▅▅▅▅▅▅▅██▛▘" in line for line in plain_lines)
 
 
+def test_print_welcome_banner_keeps_dark_panel_owl_left_at_80_columns(
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(
+        cli_mod.shutil,
+        "get_terminal_size",
+        lambda fallback=(80, 20): os.terminal_size((80, 20)),
+    )
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    monkeypatch.delenv("OWL_THEME", raising=False)
+    monkeypatch.setenv("COLORFGBG", "15;0")
+
+    banner = cli_mod.printWelcome(
+        workspace=Path.home() / "myproject",
+        model="anthropic/opus-4.7",
+        version="0.8.2",
+    )
+    plain_lines = [cli_mod.stripAnsi(line) for line in banner.splitlines()]
+    plain = "\n".join(plain_lines)
+
+    assert "\x1b[48;5;231m" in banner
+    assert all(len(line) < 80 for line in plain_lines)
+    assert "..." not in plain
+    assert "model opus-4.7   version 0.8.2" in plain
+    assert any("\u2588" in line and "Sylliptor" in line for line in plain_lines)
+    assert any("\u2588" in line and "workspace ~/myproject" in line for line in plain_lines)
+
+
 def test_print_welcome_banner_keeps_long_context_off_terminal_edge_at_80_columns(
     monkeypatch,
 ) -> None: