fix(core): keep encrypted reasoning on summary-less responses

Address CodeRabbit review findings on the branch:

- core: a non-streaming OpenAI Responses reasoning item can return
  encrypted_content with an empty summary; the conversion loop dropped it
  entirely, diverging from the streaming output_item.done path and making
  the reasoning boundary non-replayable. Emit an encrypted ThinkPart in
  that case, mirroring the streaming behavior, with focused coverage.
- tui: render "1 agent" (singular) instead of "1 agents" in the grouped
  agents summary, and make the uniform-status check explicitly boolean.

The two other flagged reasoning findings (summary-index preservation and
cross-output merge collisions) were verified against the code and tests
and are non-issues: real deltas always carry valid indices, and encrypted
boundaries already block adjacent cross-output merges.

Author: elkaix

CHANGELOG.md

@@ -16,6 +16,7 @@ GitHub Releases page; `0.8.0` is the new starting line.
 ## Unreleased
 
 - Fixed reasoning summaries exposing Markdown delimiters and duplicate terminal rows after refocus, and redesigned agent progress (single `Agent` calls and parallel `RunAgents` fan-outs) as a compact, payload-free agent activity tree.
+- Retain a non-streaming OpenAI Responses reasoning item's encrypted content when it carries no summary, matching the streaming path so the reasoning boundary stays replayable.
 - Reduce the shell prompt session to a compatibility façade over deep `prompting/` modules (config, keybindings, completion menus, narrow shell-facing methods), with Unicode cell-width coverage and documented module ownership in the architecture guide.
 - Render image/audio/video and unknown content parts as payload-free labels in the live view, roll nested subagent activity (up to 16 levels) under the correct root tool card, and stop provider-remapped tool results from starting replay user turns.
 - **Behavior change:** `!` shell commands now run through the detected configured shell (`<shell> -c`, PowerShell `-command` on Windows) instead of the implicit `/bin/sh`/`cmd.exe`, with separate 1 MiB stdout/stderr caps and cancellation cleanup; existing `cmd.exe`-syntax commands on Windows may need updating.

packages/pythinker-core/src/pythinker_core/contrib/chat_provider/openai_responses.py

@@ -548,12 +548,23 @@ async def _convert_non_stream_response(
                 )
             elif item.type == "reasoning":
                 encrypted_content = getattr(item, "encrypted_content", None)
+                emitted_summary = False
                 for summary_index, summary in enumerate(getattr(item, "summary", ())):
+                    emitted_summary = True
                     yield ThinkPart(
                         think=summary.text,
                         encrypted=encrypted_content,
                         summary_index=summary_index,
                     )
+                if not emitted_summary and encrypted_content is not None:
+                    # Mirror the streaming `output_item.done` path: a reasoning item
+                    # can carry encrypted_content with no summary parts, and dropping
+                    # it here would make the reasoning boundary non-replayable.
+                    yield ThinkPart(
+                        think="",
+                        encrypted=encrypted_content,
+                        summary_index=None,
+                    )
 
     async def _convert_stream_response(
         self, response: AsyncStream[ResponseStreamEvent]

packages/pythinker-core/tests/test_stream_tool_call_metadata.py

@@ -658,6 +658,29 @@ async def test_openai_responses_completed_reasoning_summaries_keep_order_and_enc
     ]
 
 
+async def test_openai_responses_completed_reasoning_without_summary_keeps_encryption() -> None:
+    # A non-streaming reasoning item can return encrypted_content with an empty
+    # summary; it must still emit an encrypted ThinkPart so the boundary is
+    # replayable, matching the streaming `output_item.done` behavior.
+    response = _response(
+        output=[
+            ResponseReasoningItem.model_validate(
+                {
+                    "type": "reasoning",
+                    "id": "reasoning_1",
+                    "summary": [],
+                    "encrypted_content": "enc_orphan",
+                }
+            )
+        ]
+    )
+    stream = OpenAIResponsesStreamedMessage(response)
+
+    parts = [part for part in await _collect_parts(stream) if isinstance(part, ThinkPart)]
+
+    assert parts == [ThinkPart(think="", encrypted="enc_orphan", summary_index=None)]
+
+
 async def test_openai_responses_empty_streamed_call_id_is_deterministic(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

src/pythinker_code/ui/shell/tool_renderers/agent.py

@@ -449,11 +449,12 @@ def _run_agents_status_style(status: str) -> RichStyle:
 
 
 def _render_grouped_agents_summary(count: int, statuses: list[str]) -> Text:
-    uniform = statuses and all(status == statuses[0] for status in statuses)
+    uniform = bool(statuses) and all(status == statuses[0] for status in statuses)
     label = statuses[0] if uniform else "mixed"
     text = Text()
     text.append(str(count), style=RichStyle(bold=True))
-    text.append(f" agents {label}", style=tui_rich_style("dim"))
+    word = "agent" if count == 1 else "agents"
+    text.append(f" {word} {label}", style=tui_rich_style("dim"))
     return text