paimon 0.2.2__tar.gz → 0.2.3__tar.gz

paimon-0.2.3/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: paimon
+Version: 0.2.3
+Summary: A minimal code agent built on pydantic-ai + textual
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic-ai-slim[anthropic,openai]>=2.17.0
+Requires-Dist: textual>=8.2.7
+Requires-Dist: textual-serve>=1.1.3
+Dynamic: license-file
+
+# Paimon
+
+![Paimon](https://automaton-media.com/wp-content/uploads/2020/10/20201019-140524-header.jpg)
+
+English | [简体中文](README.zh-CN.md)
+
+Paimon is a coding agent that lives in your terminal. It reads and edits files in the current directory and runs commands. It also runs headless and imports as a library, so a stronger agent or a program of your own can drive it.
+
+## Install
+
+```bash
+uv tool install paimon   # or: pip install paimon
+```
+
+## Getting started
+
+```bash
+paimon
+```
+
+Or run it without installing anything:
+
+```bash
+uvx paimon
+```
+
+The first launch asks for a provider, model, API base and key. Then just type what you want done. Write `@path/to/file` in a prompt to hand a file to the agent.
+
+While it runs: `Shift+Tab` switches how much the agent may do on its own (**read** asks before writing files or running commands, **edit** lets edits inside the working directory through, **yolo** never asks and is the default), `Esc` interrupts the current turn, `Ctrl+P` opens the command palette, `Ctrl+C` quits.
+
+`Ctrl+T` opens another session in a pane of its own, `Ctrl+W` closes one, `Ctrl+PageUp` and `Ctrl+PageDown` move between them, and `Ctrl+G` jumps to a pane waiting for permission. Paimon can open panes itself: ask for two independent things and it starts a second agent in its own tab. It can also leave a command running in a tab of its own, a dev server or a watcher, instead of holding up a turn.
+
+## Using Paimon as a subagent
+
+Frontier models are good at planning and reviewing; the steps in between are often mechanical. Point Paimon at a cheaper model and let Claude Code or Codex write the plan and check the result. A profile keeps that model's account separate:
+
+```bash
+paimon login --profile glm --model zai:glm-4.7 --api-key-env ZAI_API_KEY
+paimon --profile glm -p "apply the plan in PLAN.md" --mode edit --output-format result
+```
+
+The bundled skill teaches the calling agent this workflow:
+
+```bash
+paimon install-skill                  # into Claude Code (~/.claude/skills/paimon)
+paimon install-skill --target codex   # into Codex; --dest DIR for anywhere else
+npx skills add aisk/paimon            # the same skill, via skills.sh
+```
+
+## Using Paimon as a library
+
+The agent loop is importable, so a Python program can drive it without going through the CLI. `Agent.open()` starts or resumes a session and `agent.run()` yields typed events, one per text chunk, tool call and turn end, which the caller renders or filters however it likes:
+
+```python
+import asyncio
+
+from paimon.agent import Agent, TextDelta
+
+async def main():
+    agent = Agent.open(mode="edit")
+    async for event in agent.run("summarize the tests in this directory"):
+        if isinstance(event, TextDelta):
+            print(event.text, end="", flush=True)
+
+asyncio.run(main())
+```
+
+`Agent.open()` also takes a working directory, an async `confirm` callback for permission prompts, and a `toolset` to hand the model fewer tools or tools of your own. An agent holds its session until it goes away; to give it back at a definite moment, call `close()` or use the agent as a context manager. It writes the same session files as the CLI, so a run started in code can be resumed later with `paimon -r`.
+
+## Sessions
+
+Every conversation is saved, and long ones are summarized in place near the context limit. Paimon prints the command that brings a session back when you leave:
+
+```bash
+paimon -r            # choose a session started in this directory
+paimon -r a1b2c3     # resume one by id
+paimon -c            # resume the most recent one
+paimon sessions      # list them (--json for machines)
+paimon log a1b2c3    # what a session did, one line per event
+```
+
+## Other ways to run it
+
+```bash
+paimon --mode read                  # start in a more cautious permission mode (yolo is the default)
+paimon --strict                     # ask before every command, even read-only ones
+paimon --web                        # the same UI in a browser (--port, default 8000)
+paimon -p "what does cli.py do?"    # one answer on stdout, no UI
+cat log.txt | paimon -p "summarize this"
+paimon --model zai:glm-4.7          # this model for this run only
+paimon --profile work               # a separately configured account
+```
+
+`-p` never stops to ask, so with the default `yolo` mode it can already write files and run commands. Add `--output-format result` for a single JSON object with the outcome, which is what a calling program should read. `paimon --help` lists the rest.
+
+## Configuration
+
+Each profile keeps its model settings in `~/.config/paimon/<name>/config.json`, written by the first launch or by `paimon login`. Sessions live in `~/.local/share/paimon/sessions/`. File changes render nicer if [delta](https://github.com/dandavison/delta) is installed.
+
+Read and edit modes run a small set of clearly read-only commands (`ls`, `cat`, `git status`, …) without asking; `--strict` turns that off. **This is a guardrail against agent mistakes, not a security boundary.** For real isolation, run Paimon inside a container or VM.

paimon-0.2.3/README.md

@@ -0,0 +1,100 @@
+# Paimon
+
+![Paimon](https://automaton-media.com/wp-content/uploads/2020/10/20201019-140524-header.jpg)
+
+English | [简体中文](README.zh-CN.md)
+
+Paimon is a coding agent that lives in your terminal. It reads and edits files in the current directory and runs commands. It also runs headless and imports as a library, so a stronger agent or a program of your own can drive it.
+
+## Install
+
+```bash
+uv tool install paimon   # or: pip install paimon
+```
+
+## Getting started
+
+```bash
+paimon
+```
+
+Or run it without installing anything:
+
+```bash
+uvx paimon
+```
+
+The first launch asks for a provider, model, API base and key. Then just type what you want done. Write `@path/to/file` in a prompt to hand a file to the agent.
+
+While it runs: `Shift+Tab` switches how much the agent may do on its own (**read** asks before writing files or running commands, **edit** lets edits inside the working directory through, **yolo** never asks and is the default), `Esc` interrupts the current turn, `Ctrl+P` opens the command palette, `Ctrl+C` quits.
+
+`Ctrl+T` opens another session in a pane of its own, `Ctrl+W` closes one, `Ctrl+PageUp` and `Ctrl+PageDown` move between them, and `Ctrl+G` jumps to a pane waiting for permission. Paimon can open panes itself: ask for two independent things and it starts a second agent in its own tab. It can also leave a command running in a tab of its own, a dev server or a watcher, instead of holding up a turn.
+
+## Using Paimon as a subagent
+
+Frontier models are good at planning and reviewing; the steps in between are often mechanical. Point Paimon at a cheaper model and let Claude Code or Codex write the plan and check the result. A profile keeps that model's account separate:
+
+```bash
+paimon login --profile glm --model zai:glm-4.7 --api-key-env ZAI_API_KEY
+paimon --profile glm -p "apply the plan in PLAN.md" --mode edit --output-format result
+```
+
+The bundled skill teaches the calling agent this workflow:
+
+```bash
+paimon install-skill                  # into Claude Code (~/.claude/skills/paimon)
+paimon install-skill --target codex   # into Codex; --dest DIR for anywhere else
+npx skills add aisk/paimon            # the same skill, via skills.sh
+```
+
+## Using Paimon as a library
+
+The agent loop is importable, so a Python program can drive it without going through the CLI. `Agent.open()` starts or resumes a session and `agent.run()` yields typed events, one per text chunk, tool call and turn end, which the caller renders or filters however it likes:
+
+```python
+import asyncio
+
+from paimon.agent import Agent, TextDelta
+
+async def main():
+    agent = Agent.open(mode="edit")
+    async for event in agent.run("summarize the tests in this directory"):
+        if isinstance(event, TextDelta):
+            print(event.text, end="", flush=True)
+
+asyncio.run(main())
+```
+
+`Agent.open()` also takes a working directory, an async `confirm` callback for permission prompts, and a `toolset` to hand the model fewer tools or tools of your own. An agent holds its session until it goes away; to give it back at a definite moment, call `close()` or use the agent as a context manager. It writes the same session files as the CLI, so a run started in code can be resumed later with `paimon -r`.
+
+## Sessions
+
+Every conversation is saved, and long ones are summarized in place near the context limit. Paimon prints the command that brings a session back when you leave:
+
+```bash
+paimon -r            # choose a session started in this directory
+paimon -r a1b2c3     # resume one by id
+paimon -c            # resume the most recent one
+paimon sessions      # list them (--json for machines)
+paimon log a1b2c3    # what a session did, one line per event
+```
+
+## Other ways to run it
+
+```bash
+paimon --mode read                  # start in a more cautious permission mode (yolo is the default)
+paimon --strict                     # ask before every command, even read-only ones
+paimon --web                        # the same UI in a browser (--port, default 8000)
+paimon -p "what does cli.py do?"    # one answer on stdout, no UI
+cat log.txt | paimon -p "summarize this"
+paimon --model zai:glm-4.7          # this model for this run only
+paimon --profile work               # a separately configured account
+```
+
+`-p` never stops to ask, so with the default `yolo` mode it can already write files and run commands. Add `--output-format result` for a single JSON object with the outcome, which is what a calling program should read. `paimon --help` lists the rest.
+
+## Configuration
+
+Each profile keeps its model settings in `~/.config/paimon/<name>/config.json`, written by the first launch or by `paimon login`. Sessions live in `~/.local/share/paimon/sessions/`. File changes render nicer if [delta](https://github.com/dandavison/delta) is installed.
+
+Read and edit modes run a small set of clearly read-only commands (`ls`, `cat`, `git status`, …) without asking; `--strict` turns that off. **This is a guardrail against agent mistakes, not a security boundary.** For real isolation, run Paimon inside a container or VM.

paimon-0.2.3/README.zh-CN.md

@@ -0,0 +1,100 @@
+# Paimon
+
+![Paimon](https://automaton-media.com/wp-content/uploads/2020/10/20201019-140524-header.jpg)
+
+[English](README.md) | 简体中文
+
+Paimon 是一个终端里的 coding agent。它读写当前目录下的文件，执行命令。它也支持无头运行，还可以作为库导入，由更强的 agent 或者你自己的程序来驱动。
+
+## 安装
+
+```bash
+uv tool install paimon   # 或者：pip install paimon
+```
+
+## 快速开始
+
+```bash
+paimon
+```
+
+或者不安装直接运行：
+
+```bash
+uvx paimon
+```
+
+首次启动会询问 provider、模型、API base 和 key。之后输入要完成的任务即可。在提示中写 `@path/to/file` 可以把文件提供给 agent。
+
+运行时：`Shift+Tab` 切换 agent 的自主程度（**read** 写文件或执行命令前先询问，**edit** 放行工作目录内的编辑，**yolo** 从不询问，也是默认值），`Esc` 打断当前回合，`Ctrl+P` 打开命令面板，`Ctrl+C` 退出。
+
+`Ctrl+T` 在新 pane 里打开另一个会话，`Ctrl+W` 关闭当前 pane，`Ctrl+PageUp` 和 `Ctrl+PageDown` 在 pane 之间切换，`Ctrl+G` 跳到正在等待授权的 pane。Paimon 自己也能开 pane：让它同时做两件互不相干的事，它会在新 tab 里起第二个 agent。它也能把一条命令留在单独的 tab 里跑，比如开发服务器或者文件监视，不占着当前回合。
+
+## 当作 subagent 使用
+
+前沿模型擅长制定计划和验收结果，中间的执行步骤往往比较机械。让 Paimon 使用成本较低的模型执行，由 Claude Code 或 Codex 制定计划并检查结果。用一个 profile 单独保存该模型的账号：
+
+```bash
+paimon login --profile glm --model zai:glm-4.7 --api-key-env ZAI_API_KEY
+paimon --profile glm -p "apply the plan in PLAN.md" --mode edit --output-format result
+```
+
+自带的 skill 会向调用方 agent 说明这套流程：
+
+```bash
+paimon install-skill                  # 安装到 Claude Code（~/.claude/skills/paimon）
+paimon install-skill --target codex   # 安装到 Codex；--dest DIR 安装到任意目录
+npx skills add aisk/paimon            # 通过 skills.sh 安装同一个 skill
+```
+
+## 当作库使用
+
+agent 循环本身是可以导入的，Python 程序不必经过 CLI 就能驱动它。`Agent.open()` 新建或恢复一个会话，`agent.run()` 产出类型化的事件，每段文本、每次工具调用、每个回合结束各一个，调用方自己决定怎么渲染或过滤：
+
+```python
+import asyncio
+
+from paimon.agent import Agent, TextDelta
+
+async def main():
+    agent = Agent.open(mode="edit")
+    async for event in agent.run("summarize the tests in this directory"):
+        if isinstance(event, TextDelta):
+            print(event.text, end="", flush=True)
+
+asyncio.run(main())
+```
+
+`Agent.open()` 还接受工作目录、用于权限确认的异步 `confirm` 回调，以及 `toolset`，可以只给模型一部分工具，或者换成你自己的工具。agent 被回收时会交还会话，想在确定的时刻交还就调 `close()`，或者把它当上下文管理器用。它写的会话文件和 CLI 一样，所以代码里跑出来的会话之后可以用 `paimon -r` 恢复。
+
+## 会话
+
+每次对话都会保存，很长的对话在接近上下文上限时会被原地总结。退出时 Paimon 会打印恢复该会话的命令：
+
+```bash
+paimon -r            # 从当前目录的会话中选择
+paimon -r a1b2c3     # 按 id 恢复
+paimon -c            # 恢复最近一个会话
+paimon sessions      # 列出会话（--json 输出机器可读格式）
+paimon log a1b2c3    # 查看会话做了什么，每个事件一行
+```
+
+## 其他运行方式
+
+```bash
+paimon --mode read                  # 以更谨慎的权限模式启动（默认为 yolo）
+paimon --strict                     # 每条命令都先询问，包括只读命令
+paimon --web                        # 在浏览器中使用同一套 UI（--port，默认 8000）
+paimon -p "what does cli.py do?"    # 直接在 stdout 输出回答，不启动 UI
+cat log.txt | paimon -p "summarize this"
+paimon --model zai:glm-4.7          # 仅本次运行使用该模型
+paimon --profile work               # 单独配置的另一个账号
+```
+
+`-p` 不会停下来询问，配合默认的 `yolo` 模式，它已经可以修改文件和执行命令。加 `--output-format result` 会输出一个包含结果的 JSON 对象，调用方程序读这个就够了。其余选项见 `paimon --help`。
+
+## 配置
+
+每个 profile 的模型设置保存在 `~/.config/paimon/<name>/config.json`，由首次启动或 `paimon login` 写入。会话存放在 `~/.local/share/paimon/sessions/`。安装 [delta](https://github.com/dandavison/delta) 后文件改动的展示效果更好。
+
+read 和 edit 模式会不经询问执行一小组明确只读的命令（`ls`、`cat`、`git status` 等），`--strict` 可以关掉。**这是防止 agent 失误的护栏，不是安全边界。** 需要真正的隔离时，请在容器或虚拟机中运行 Paimon。

{paimon-0.2.2 → paimon-0.2.3}/paimon/__init__.py

@@ -1 +1,5 @@
 """Paimon, a minimal code agent built on pydantic-ai + textual."""
+
+from .errors import PaimonError
+
+__all__ = ["PaimonError"]

{paimon-0.2.2 → paimon-0.2.3}/paimon/agent.py

@@ -30,9 +30,9 @@ from pydantic_ai.messages import (
 )
 from pydantic_ai.models import Model, ModelRequestParameters
 
-from . import compaction, retry, tools
+from . import aside, compaction, retry, tools
 from .config import Config
-from .llm import build_model, user_agent
+from .llm import NoModelError, build_model, user_agent
 from .mentions import expand_mentions
 from .prompt import build_system_prompt
 from .session import (
@@ -93,10 +93,18 @@ class SessionHandoff:
 
 @dataclass
 class RequestStats:
-    """Output speed of one finished model request, from provider-reported usage."""
+    """Output speed and cache usage of one finished model request, from
+    provider-reported usage. ``input_tokens`` includes the cached portion
+    (pydantic-ai normalizes providers that report them separately), so the
+    cache hit rate is ``cache_read_tokens / input_tokens``. Providers that
+    do not report caching leave both cache fields at zero.
+    """
 
     output_tokens: int
     seconds: float
+    input_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
 
 
 @dataclass
@@ -238,6 +246,11 @@ def _strip_foreign_thinking(history: list[ModelMessage], model: Model) -> list[M
 # Re-exported so UI code can keep importing it from here.
 ConfirmFn = tools.ConfirmFn
 
+# Takes the messages a user queued while a turn was already running, clearing
+# the queue as it goes. The loop calls it before every model request, so what
+# it returns reaches the model at the next step rather than the next turn.
+PendingFn = Callable[[], list[str]]
+
 
 class Agent:
     """One conversation against one session.
@@ -245,6 +258,13 @@ class Agent:
     Built through :meth:`open`, which is where the session file is created or
     resumed and its lock taken; the constructor itself only wires up state a
     caller already holds, so it can neither fail nor leave a lock behind.
+
+    An agent holds its session until :meth:`close`, which ``with`` calls on the
+    way out::
+
+        with Agent.open(cwd=path) as agent:
+            async for event in agent.run("..."):
+                ...
     """
 
     def __init__(self, session: Session, system_prompt: str, *, cwd: Optional[Path] = None,
@@ -265,6 +285,9 @@ class Agent:
         # None everywhere else (headless, tests), where the agent tools refuse
         # rather than pretend.
         self.supervisor = None
+        # Set by the UI too: the hook the loop pulls queued user messages from.
+        # None where nobody can type while a turn runs (headless, tests).
+        self.pending: Optional[PendingFn] = None
         # Per-agent tool state, kept off the tool functions so one agent's
         # shell overflow files stay invisible to the next one.
         self.tool_context = tools.ToolContext()
@@ -325,6 +348,28 @@ class Agent:
             session.unlock()
             raise
 
+    def close(self) -> None:
+        """Release the session, so another agent may open it. Idempotent."""
+        self.session.unlock()
+
+    def __enter__(self) -> "Agent":
+        return self
+
+    def __exit__(self, *exc_info) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        # Backstop for a caller that used neither ``with`` nor close(): the
+        # claim is refcounted in this process, so a forgotten agent would keep
+        # its session unopenable for as long as the process lives. Runs at
+        # interpreter shutdown too, where anything may already be torn down.
+        try:
+            session = getattr(self, "session", None)
+            if session is not None:
+                session.unlock()
+        except Exception:
+            pass
+
     @property
     def model_name(self) -> Optional[str]:
         """The model this agent talks to: its own override, else the config's."""
@@ -334,7 +379,7 @@ class Agent:
         """The configured model, rebuilt when login changes the config."""
         name = self.model_name
         if not name:
-            raise RuntimeError("No model configured; log in first")
+            raise NoModelError("No model configured; log in first")
         key = (name, self.config.api_base, self.config.api_key)
         if self._cached_model is None or self._cached_model[0] != key:
             self._cached_model = (key, build_model(*key))
@@ -408,6 +453,29 @@ class Agent:
         """Compact on demand; None when the history is too short to be worth it."""
         return await self._maybe_compact(force=True)
 
+    async def ask_aside(self, question: str, *,
+                        instructions: str = aside.DEFAULT_INSTRUCTIONS,
+                        max_tokens: int = aside.DEFAULT_MAX_TOKENS) -> AsyncIterator[str]:
+        """Ask a question over this agent's context, yielding the answer as text.
+
+        Read-only: neither the question nor the answer enters ``self.history``
+        or the session log, and no compaction is triggered. That is what lets
+        it be asked while a turn is already waiting on the model: it takes a
+        snapshot and opens a request of its own rather than joining the one in
+        flight. A cancelled aside leaves nothing behind either.
+
+        The history it sends is whatever exists when the first delta is asked
+        for, so a turn running alongside it may add messages the answer never
+        saw.
+        """
+        model = self._model()
+        context = _strip_foreign_thinking(aside.usable_history(self.history), model)
+        async for delta in aside.stream(model, self.system_prompt, context, question,
+                                        instructions=instructions,
+                                        tool_definitions=self._tool_definitions,
+                                        max_tokens=max_tokens):
+            yield delta
+
     # ---- Tools the agent loop runs itself ----------------------------------
     # These mutate agent-held state or end the turn, so they cannot go through
     # the stateless tools.run_tool. Each handler fills ``slot`` with the tool
@@ -531,6 +599,16 @@ class Agent:
         compaction_failures = 0
 
         while True:
+            # Messages the user queued while this turn was already running.
+            # Appended as their own request so the model sees them at the next
+            # step, without touching the stream that just ended or the tool
+            # results already recorded. Before compaction, so they count
+            # towards the context check and survive a history replacement.
+            for queued in (self.pending() if self.pending is not None else []):
+                self._append_message(ModelRequest(
+                    parts=[UserPromptPart(content=expand_mentions(queued, self.cwd))]))
+                yield UserInput(queued)
+
             if not compaction_off:
                 try:
                     compacted = await self._maybe_compact()
@@ -591,9 +669,12 @@ class Agent:
                         response = stream.get()
                         if first_event_at is not None:
                             elapsed = time.monotonic() - first_event_at
-                            output_tokens = response.usage.output_tokens
-                            if output_tokens and elapsed > 0:
-                                stats = RequestStats(output_tokens, elapsed)
+                            usage = response.usage
+                            if usage.output_tokens and elapsed > 0:
+                                stats = RequestStats(usage.output_tokens, elapsed,
+                                                     usage.input_tokens,
+                                                     usage.cache_read_tokens,
+                                                     usage.cache_write_tokens)
                     break
                 except asyncio.CancelledError:
                     # Interrupted mid-stream: keep partial text but drop incomplete

{paimon-0.2.2 → paimon-0.2.3}/paimon/app.py

@@ -15,6 +15,7 @@ from textual.widgets import ContentSwitcher, Static
 from . import compaction, tools
 from .agent import Agent
 from .config import DEFAULT_PROFILE, Config, list_profiles
+from .errors import PaimonError
 from .login import LoginScreen, PickerScreen, PromptScreen
 from .pane import Pane, SessionPane
 from .session import SessionError
@@ -66,6 +67,11 @@ class PaimonApp(App):
                 "Show or hide the model's reasoning stream (it is generated either way)",
                 self.action_toggle_reasoning,
             ),
+            SystemCommand(
+                "Toggle idle recap",
+                "Offer a short recap after a turn once you go quiet (it costs an extra request)",
+                self.action_toggle_recap,
+            ),
             SystemCommand(
                 "Compact context",
                 "Summarize the earlier conversation now instead of waiting for the context to fill",
@@ -319,10 +325,28 @@ class PaimonApp(App):
                 self._switch_to(pane)
                 return
 
+    def save_config(self, **fields) -> None:
+        """Persist config fields without blocking or crashing the UI.
+
+        save() waits on the cross-process lock (up to 10s when another
+        instance is stuck) and fsyncs twice, and it raises ConfigError on a
+        corrupt file, so it runs on a worker thread and a failure lands as a
+        notice instead of an exception tearing down the app.
+        """
+        def _write() -> None:
+            try:
+                self.config.save(**fields)
+            except PaimonError as exc:
+                self.call_from_thread(
+                    self.pane.notice,
+                    Content.from_markup("[$text-error b]Config not saved:[/] $body",
+                                        body=str(exc)))
+        self.run_worker(_write, thread=True, group="config-save")
+
     def _watch_theme(self, theme_name: str) -> None:
         super()._watch_theme(theme_name)
         if self._persist_theme_changes:
-            self.config.save(theme=theme_name)
+            self.save_config(theme=theme_name)
 
     def compose(self) -> ComposeResult:
         yield self._tabs
@@ -389,10 +413,27 @@ class PaimonApp(App):
             self.pane.interrupt()
 
     def action_toggle_reasoning(self) -> None:
-        self.config.save(show_reasoning=not self.config.show_reasoning)
+        # Flipped on the instance up front: the write happens on a worker
+        # thread, and the UI must reflect the toggle immediately.
+        self.config.show_reasoning = not self.config.show_reasoning
+        self.save_config(show_reasoning=self.config.show_reasoning)
         state = "streamed live" if self.config.show_reasoning else "folded"
         self.pane.notice(Content.from_markup(f"[$text-muted]Thinking: {state}[/]"))
 
+    def action_toggle_recap(self) -> None:
+        """Turn the after-idle recap off (or back on), for every pane.
+
+        Config is process-wide, so one switch covers all panes; turning it off
+        also drops recaps already armed, which check the flag only when armed.
+        """
+        self.config.recap_enabled = not self.config.recap_enabled
+        self.save_config(recap_enabled=self.config.recap_enabled)
+        if not self.config.recap_enabled:
+            for pane in self.sessions:
+                pane._cancel_recap()
+        state = "on" if self.config.recap_enabled else "off"
+        self.pane.notice(Content.from_markup(f"[$text-muted]Idle recap: {state}[/]"))
+
     # ---- login --------------------------------------------------------------
 
     def _config_is_busy(self) -> bool:
@@ -456,7 +497,7 @@ class PaimonApp(App):
             return
         try:
             switched = Config.load(name)
-        except ValueError as exc:
+        except (ValueError, PaimonError) as exc:
             self.pane.notice(Content.from_markup("[$text-error b]Cannot switch:[/] $body", body=str(exc)))
             self.pane._focus_input()
             return
@@ -525,6 +566,8 @@ class PaimonApp(App):
                              "(auto-compaction off: unknown context window)")
         if pane._tps is not None:
             parts.append(f"{pane._tps:.0f} tokens per second")
+        if pane._cache_hit is not None:
+            parts.append(f"cache hit {pane._cache_hit:.0%}")
         return parts
 
     @work(exclusive=True, group="statusbar")

{paimon-0.2.2 → paimon-0.2.3}/paimon/app.tcss

@@ -1,7 +1,10 @@
 /* Styles for PaimonApp. Loaded via PaimonApp.CSS_PATH. */
 
 Screen { background: $background; }
-#panes { height: 1fr; }
+/* 100% rather than the default 1fr: fr widths resolve against the container
+   minus the widest sibling margins, and the status bar's own 0 2 margin would
+   otherwise shave four dead columns off the right edge of every pane. */
+#panes { height: 1fr; width: 100%; }
 SessionPane { height: 1fr; margin: 1 2 0 2; }
 
 /* ---- pane tabs ---- */
@@ -46,7 +49,16 @@ Screen.-tabs-bottom #statusbar { margin: 0 2 0 2; }
 .assistant { padding: 0 1; }
 .reasoning { color: $text-disabled; text-style: italic; text-opacity: 60%; }
 .tool-result { color: $text-disabled; }
+.edit-call { height: auto; }
+.edit-call-diff { margin-top: 1; }
 .todos { padding: 0 1; border-left: solid $primary 45%; }
+/* Unprompted, so it is the quietest block that still has a rule of its own.
+   The Markdown widget's own default padding and $foreground would both win
+   over "quiet", so both are restated here. */
+.recap { padding: 0 1; border-left: solid $accent 60%; color: $text-muted; }
+/* A heading that slips past the recap instructions still belongs to the muted
+   block, and the breathing room the log gives blocks is enough for it. */
+.recap MarkdownHeader { color: $text-muted; margin: 0 0 1 0; text-style: b; }
 .tool-result.denied { color: $text; background: $error 20%; padding: 0 1; }
 .user-message {
     width: 100%;