@caph42/pi-ccline 0.2.0 → 0.2.2

package/README.md

@@ -20,6 +20,7 @@ pi session state → buildCclineInput() → JSON → ccline (spawn, COLUMNS=curr
 | Context percentage / token count | `ctx.getContextUsage()` → current context (the aggregate estimate); **no lifetime session tokens are sent** |
 | Prompt-cache hit share | assistant messages' `usage.cacheRead` over `input + cacheRead + cacheWrite`, summed over the branch → `prompt_cache.hit_ratio`; sent from the second request on |
 | Output speed (`tok/s`) | measured from `message_start` → first `message_update` → `message_end`, written to ccline's `bridge/<session>.json` for its `timing.tps` metric |
+| Running tools | `tool_execution_start` / `tool_execution_end` → the same bridge file's `tools` array, for ccline's `activity.tools` metric |
 | Cost, session duration | assistant messages' `usage.cost.total` summed; duration = now − earliest entry on the branch |
 | Session id / name | `ctx.sessionManager` |
 | git branch and anything else ccline probes itself | ccline reads the disk itself |
@@ -76,7 +77,8 @@ After startup the footer is whatever ccline renders. Your terminal needs Nerd Fo
   "refreshThrottleMs": 1000,
   "liveRefreshMs": 1000,
   "showProvider": true,
-  "env": {}
+  "env": {},
+  "statusBadges": {}
 }
 ```
 
@@ -89,6 +91,7 @@ After startup the footer is whatever ccline renders. Your terminal needs Nerd Fo
 | `liveRefreshMs` | `1000` | Interval of the timer that refreshes while the agent runs (so `duration` ticks every second); `0` disables the timer and leaves only event-driven refreshes. When non-zero, anything below 250 is raised to 250 |
 | `showProvider` | `true` | Whether to append the provider to the model segment, e.g. `Sonnet 4.5 (anthropic)`; `false` shows just the model name. If the terminal is narrow enough for ccline to truncate the model segment, the provider may not be visible |
 | `env` | `{}` | Extra environment variables for ccline; same-named variables override the values inherited from pi (except `COLUMNS`, which the extension writes from the current width) |
+| `statusBadges` | `{}` | Icons and colors for the status row other extensions set through `ctx.ui.setStatus`, shaped `{"<status key>": {"icon": "<glyph>", "color": "<theme token>"}}`. Built in: `pi-herdr-pstack` (its `poteto-mode` status) → the Nerd Font rocket `U+F135` in `accent`. Fields merge over the built-in entry, so `{"pi-herdr-pstack": {"icon": ""}}` drops the icon and keeps the color; `""` for both removes the badge. Status keys are matched verbatim against `setStatus` keys. A status whose text already carries ANSI colors is left untouched, and an unknown theme token falls back to uncolored text |
 
 Binary resolution order: `config.binary` → `~/.claude/ccline/ccline` → `ccline` on `PATH`.
 
@@ -101,11 +104,12 @@ Binary resolution order: `config.binary` → `~/.claude/ccline/ccline` → `ccli
 - Binary not found: the footer shows a one-line install hint.
 - Widths are always computed with `visibleWidth` / `truncateToWidth`, never with `.length`.
 - **Other extensions' `ctx.ui.setStatus` stays visible**: `render(width)` reads `footerData.getExtensionStatuses()`, sorts by key, joins them with spaces into one line, truncates with a dim `…` when too wide, and appends it below the ccline frame, matching pi's built-in footer. It reads the live map and `setStatus` itself triggers a repaint, so status changes are not limited by the 1Hz throttle.
+- **A status key can carry a badge**: `setStatus` hands over text, and whether it is styled depends on the extension that sends it (pi's own footer adds nothing). This footer therefore decorates only statuses that arrive unstyled — a Nerd Font icon and a theme color, per status key (`DEFAULT_STATUS_BADGES` in `config.ts` holds the built-in entry for pi-herdr-pstack's `poteto-mode`). The icon is counted with the rest of the row before truncating, a status whose text already contains ANSI is skipped to avoid mixing two palettes, and the color goes through one `theme.fg()` call per badge that degrades to plain text when the token is not in the theme.
 - Because there is only one footer slot globally, other extensions' custom footers (e.g. pi-cursor-provider's fast badge) get displaced once this extension is installed; their status lines still show. Conversely, when they take over, the ccline frame disappears and `/pi-ccline on` takes it back.
 - **The provider can only be folded into the model segment.** ccline 2.0.1's input schema has no provider field and the `model` segment renders only `display_name`, so the provider is appended after the model name as `name (provider)`; it isn't appended twice when the name already carries the same suffix. `showProvider: false` turns it off. **At narrow widths the provider may be invisible**: ccline wraps/truncates by `COLUMNS` itself, and in practice at width 40 the model segment is left with just `GPT-5.6` — that's upstream layout behaviour, and this extension only guarantees the provider is written into `display_name`.
 - The input JSON **omits the `version` field**: ccline 2.0.1 validates it as a Claude Code version and rejects pi's version outright.
 - **Cache hit share:** `prompt_cache` is sent only from the second assistant message on. That is ccline's own display gate (`requests > 1`), whose rationale is that a single request usually only writes the cache — an initial request can still hit a prefix cached by an earlier session, so the gate is display behaviour, not a claim about request #1. Sending `hit_ratio` before that gate would also make ccline fall back to its "cold" wording, which pi cannot assert. `current_usage` deliberately still carries only `input_tokens`: pi's context estimate already includes the cached tokens, and ccline sums the `current_usage` fields when `total_input_tokens` is absent, so adding the cache counts there would double-count them in the context bar.
-- **Output speed goes through ccline's bridge, not stdin.** ccline's `timing.tps` / `timing.ttft` metrics read `bridge/<session>.json` under its data dir (`$CCLINE_HOME` or `~/.claude/ccline`), the file its companion mod writes inside Claude Code. The statusline payload has no per-request timing, so this extension measures it from `message_start` / `message_update` / `message_end` and writes the same documented `v: 1` shape, atomically, once per finished answer. ttft is stream start → first content block; pi emits `message_start` when the provider starts responding, so that number excludes the connect wait. tps divides the answer's output tokens by the time from the first content block to `message_end`, so the wait for the first token is not counted as generation. Durations use a monotonic clock (`performance.now()`); only the bridge's freshness stamp is wall-clock. The file is removed on `session_shutdown`, and ccline ignores bridges older than 6h.
+- **Output speed and running tools go through ccline's bridge, not stdin.** ccline's `timing.tps` / `timing.ttft` and `activity.tools` metrics read `bridge/<session>.json` under its data dir (`$CCLINE_HOME` or `~/.claude/ccline`), the file its companion mod writes inside Claude Code. The statusline payload has no per-request timing and no running-tool list, so this extension measures the first and tracks the second, and writes the same documented `v: 1` shape, atomically. Because both live in one file, every write carries everything known: the last finished answer's timing plus the tools running now, so a tool starting or ending never blanks `tok/s` and a new answer never leaves a finished tool behind. ttft is stream start → first content block; pi emits `message_start` when the provider starts responding, so that number excludes the connect wait. tps divides the answer's output tokens by the time from the first content block to `message_end`, so the wait for the first token is not counted as generation. Durations use a monotonic clock (`performance.now()`); only the bridge's freshness stamp is wall-clock. `tools` skips calls carrying `parentToolCallId` (codemode scripts and tools calling tools), so the segment lists what the user actually issued. The file is removed on `session_shutdown`, and ccline ignores bridges older than 6h.
 - No runtime dependencies: only `node:child_process` / `node:fs` / `node:os` / `node:path` plus the pi peer package `@earendil-works/pi-tui`.
 - Non-TUI modes (`-p`, json, rpc) install no footer and spawn nothing.
 - The extension's own config lives at `~/.pi/agent/pi-ccline/config.json`; pi's `settings.json` is never touched.
@@ -136,6 +140,7 @@ node --experimental-strip-types scripts/render-once.ts --home "$(mktemp -d)" --b
 - **ccline writes `~/.claude/ccline/state/`** (session state, model cache, update.lock). That's upstream behaviour and cannot be disabled here. The extension additionally writes `~/.claude/ccline/bridge/<session>.json` for the `timing.tps` segment, and deletes it when the session shuts down.
 - **The cache segment shows only the hit share.** Warmth, TTL countdown, miss counts and miss causes need data pi does not have (the provider's cache expiry and rebuild reasons), so those fields are omitted — with a config `format` of `{hit}% hit` the segment reduces to that one number, and before the second request it disappears entirely rather than claiming "cold".
 - **`tok/s` describes the last finished answer, not a running average.** It is measured per request and only updates when an answer ends (a non-streaming provider, or a streamed answer of a few tokens, produces no sample and leaves the previous value on screen until the next one arrives). `duration` and `tok/s` are unrelated numbers: duration is session wall-clock, tps is streaming speed.
+- **The tools segment shows only what is running right now.** ccline names the two oldest calls and folds the rest into `+N`, with the elapsed time of the oldest; there is no history, no per-tool duration and no output. Calls made through `parentToolCallId` (codemode scripts, tools invoking tools) are not listed, and a call originating inside a subagent appears only if pi hands that event to the main extension, which today it does not.
 - **External binary required.** Without `ccline` the footer is a single install hint; upgrading `ccline` needs no extension restart, but the binary path stays cached until the next resolution (`/pi-ccline on` or a new session recomputes it).
 - **Upstream compatibility only covers tested versions.** Every field in ccline 2.0.1's `input.rs` is `Option` with lenient deserialization, so a field changing shape within the same major version usually just makes that segment disappear; but required fields have changed across majors before (1.1.x → 2.0.x), so re-run `scripts/render-once.ts` after upgrading ccline.
 - **Nerd Font v3+ required.** Missing icon fonts render as boxes; Windows is untested.
@@ -156,7 +161,7 @@ extensions/pi-ccline/
   binary.ts   path resolution/caching, spawn with timeout and abort, --version probing
   render.ts   output normalization: line splitting, truncation by visible width, stale marker
   refresh.ts  single-flight + throttle + latest-wins scheduler, and the timer that drives `duration`
-  turn.ts     per-request timing from the stream, plus the ccline bridge file for `timing.tps`
+  turn.ts     per-request timing from the stream and the running-tool list, plus the ccline bridge file
   config.ts   config read/write
   *.test.ts   node --test
 scripts/render-once.ts   run the real ccline once against a fixture

package/README_zh.md

@@ -20,6 +20,7 @@ pi 会话状态 → buildCclineInput() → JSON → ccline（spawn，COLUMNS=当
 | 上下文百分比 / token 数 | `ctx.getContextUsage()` → 当前上下文（聚合估计值）；**不发会话累计 token** |
 | 缓存命中率 | assistant 消息的 `usage.cacheRead` 除以 `input + cacheRead + cacheWrite`，在分支上累加 → `prompt_cache.hit_ratio`；从第二次请求起才发送 |
 | 输出速度（`tok/s`） | 由 `message_start` → 首个 `message_update` → `message_end` 实测，写入 ccline 的 `bridge/<session>.json` 供 `timing.tps` 读取 |
+| 运行中的工具 | `tool_execution_start` / `tool_execution_end` → 同一个 bridge 文件的 `tools` 数组，供 `activity.tools` 读取 |
 | 成本、会话时长 | assistant 消息 `usage.cost.total` 累加；时长 = 当前时间 − 分支最早 entry |
 | 会话 id / 名称 | `ctx.sessionManager` |
 | git 分支等 ccline 自行探测的信息 | ccline 自己读磁盘 |
@@ -76,7 +77,8 @@ pi install .
   "refreshThrottleMs": 1000,
   "liveRefreshMs": 1000,
   "showProvider": true,
-  "env": {}
+  "env": {},
+  "statusBadges": {}
 }
 ```
 
@@ -89,6 +91,7 @@ pi install .
 | `liveRefreshMs` | `1000` | agent 运行期间的定时刷新间隔（让 `耗时` 逐秒走）；`0` 关闭定时器，只保留事件刷新。非 0 时低于 250 会被抬到 250 |
 | `showProvider` | `true` | 是否在模型段追加 provider，如 `Sonnet 4.5 (anthropic)`；`false` 只显示模型名。终端窄到模型段被 ccline 截断时 provider 可能不可见 |
 | `env` | `{}` | 追加给 ccline 的环境变量；同名变量覆盖 pi 继承的值（`COLUMNS` 除外，它由扩展按当前宽度写入） |
+| `statusBadges` | `{}` | 给其他扩展 `ctx.ui.setStatus` 那一行加图标和颜色，形状 `{"<status key>": {"icon": "<字形>", "color": "<主题 token>"}}`。内置一条：`pi-herdr-pstack`（它的 `poteto-mode` 状态）→ Nerd Font 火箭 `U+F135` + `accent`。字段按项合并到内置条目上，所以 `{"pi-herdr-pstack": {"icon": ""}}` 只去掉图标、保留颜色；两个字段都写 `""` 即去掉徽标。status key 与 `setStatus` 的 key 逐字匹配；文本本身已带 ANSI 颜色的状态原样保留；主题里不存在的 token 回退成不上色 |
 
 二进制解析顺序：`config.binary` → `~/.claude/ccline/ccline` → `PATH` 中的 `ccline`。
 
@@ -101,11 +104,12 @@ pi install .
 - 找不到二进制：footer 显示一行安装提示。
 - 行宽一律用 `visibleWidth` / `truncateToWidth` 计算，不用 `.length`。
 - **其他扩展的 `ctx.ui.setStatus` 照样可见**：`render(width)` 读 `footerData.getExtensionStatuses()`，按 key 排序、用空格拼成一行、超宽时用 dim `…` 截断，追加在 ccline 帧下方——行为对齐 pi 内置 footer。读的是实时 map，`setStatus` 自己会触发重绘，所以状态变化不受 1Hz 节流限制。
+- **status 可以带徽标**：`setStatus` 交过来的是文本，有没有上色取决于发它的扩展（pi 自带 footer 不再加任何样式）。所以本扩展只装饰「没有自己上色」的状态：按 status key 加 Nerd Font 图标和主题色（内置条目在 `config.ts` 的 `DEFAULT_STATUS_BADGES`，目前是 pi-herdr-pstack 的 `poteto-mode`）。图标计入整行的可见宽度再截断；文本自带 ANSI 的状态跳过装饰，避免两套配色混在一起；颜色每帧走一次 `theme.fg()`，token 不在主题里就退成纯文本。
 - 因为 footer 槽位全局只有一个，本扩展装上后其他扩展的自定义 footer（例如 pi-cursor-provider 的 fast 徽标）会被顶掉；它们的 status 行仍会显示。反过来它们抢占时 ccline 帧会消失，需要 `/pi-ccline on` 取回。
 - **provider 只能拼进模型段。** ccline 2.0.1 的输入 schema 没有 provider 字段，`model` 段只渲染 `display_name`，所以 provider 以 `名称 (provider)` 的形式追加在模型名后；名字里已经带同样的后缀时不重复追加。`showProvider: false` 可关掉。**窄宽度下 provider 可能看不到**：ccline 按 `COLUMNS` 自己折行/截断，实测宽度 40 时模型段只剩 `GPT-5.6`，这是上游布局行为，本扩展只保证把 provider 写进 `display_name`。
 - 输入 JSON **省略 `version` 字段**：ccline 2.0.1 会把它当 Claude Code 版本校验，传 pi 的版本会被直接拒绝。
 - **缓存命中率：** `prompt_cache` 从第二条 assistant 消息起才发。这是 ccline 自己的显示门槛（`requests > 1`），它的理由是一次请求通常只是在写缓存——但首个请求确实可能命中之前会话已缓存的 prefix，所以这是显示行为，不是对「第一次请求」的事实断言。若在门槛前就发 `hit_ratio`，ccline 还会回退到 `cold` 文案，而那是 pi 无法断言的。`current_usage` 仍然只填 `input_tokens`：pi 的上下文估计值本就包含缓存 token，而缺少 `total_input_tokens` 时 ccline 会把 `current_usage` 各项相加，把 cache 数填进去会让它们被重复计入上下文进度条。
-- **输出速度走 ccline 的 bridge，不走 stdin。** ccline 的 `timing.tps` / `timing.ttft` 读的是其数据目录（`$CCLINE_HOME` 或 `~/.claude/ccline`）下的 `bridge/<session>.json`，也就是它家在 Claude Code 里的伴生 mod 写的文件。statusline 载荷里没有单次请求耗时，所以本扩展用 `message_start` / `message_update` / `message_end` 自己计时，并按同样的 `v: 1` 结构原子写入，每个答完的请求写一次。ttft = 流开始 → 首个内容块；pi 是在 provider 开始响应后才发 `message_start`，所以这个数不含建立连接的等待。tps = 该回答的 output token 除以「首个内容块 → `message_end`」的时长，所以等首字的耗时不算进生成速度。计时用单调时钟（`performance.now()`），只有 bridge 的新鲜度标记用墙钟。`session_shutdown` 时删除该文件；ccline 也会忽略超过 6 小时的 bridge。
+- **输出速度与运行中的工具走 ccline 的 bridge，不走 stdin。** ccline 的 `timing.tps` / `timing.ttft` 与 `activity.tools` 读的是其数据目录（`$CCLINE_HOME` 或 `~/.claude/ccline`）下的 `bridge/<session>.json`，也就是它家在 Claude Code 里的伴生 mod 写的文件。statusline 载荷里既没有单次请求耗时，也没有运行中工具列表，所以本扩展自己实测、自己跟踪，并按同样的 `v: 1` 结构原子写入。因为两者共用一个文件，每次写入都带全量：最后答完那次请求的计时 + 当前运行中的工具，所以工具起止不会把 `tok/s` 清掉，新回答也不会把已结束的工具留在那里。ttft = 流开始 → 首个内容块；pi 是在 provider 开始响应后才发 `message_start`，所以这个数不含建立连接的等待。tps = 该回答的 output token 除以「首个内容块 → `message_end`」的时长，所以等首字的耗时不算进生成速度。计时用单调时钟（`performance.now()`），只有 bridge 的新鲜度标记用墙钟。`tools` 会跳过带 `parentToolCallId` 的调用（codemode 脚本、工具内部再调工具），所以这段只列用户真正发起的调用。`session_shutdown` 时删除该文件；ccline 也会忽略超过 6 小时的 bridge。
 - 没有运行时依赖，只用 `node:child_process` / `node:fs` / `node:os` / `node:path` 和 pi 提供的 peer 包 `@earendil-works/pi-tui`。
 - 非 TUI 模式（`-p`、json、rpc）不安装 footer、不 spawn。
 - 扩展自己的配置写在 `~/.pi/agent/pi-ccline/config.json`，不碰 pi 的 `settings.json`。
@@ -136,6 +140,7 @@ node --experimental-strip-types scripts/render-once.ts --home "$(mktemp -d)" --b
 - **ccline 会写 `~/.claude/ccline/state/`**（会话状态、模型缓存、update.lock）。这是上游行为，扩展无法关闭。另外本扩展会写 `~/.claude/ccline/bridge/<session>.json` 供 `timing.tps` 段使用，会话关闭时删掉。
 - **缓存段只显示命中率。** 冷热状态、TTL 倒计时、miss 次数与原因需要 pi 没有的数据（provider 的缓存过期时间、重建原因），这些字段一律不发；配置里用 `format = "{hit}% hit"` 就只剩这一个数字，而第二次请求之前整段直接消失，而不是谎称 `cold`。
 - **`tok/s` 描述的是最后一次答完的请求，不是滚动平均。** 它按请求实测，只在回答结束时更新（非流式 provider、或只有几个 token 的回答不会产生样本，上一轮的数值会继续显示到下一次更新）。`duration` 和 `tok/s` 没有关系：前者是会话墙钟时长，后者是流式速度。
+- **工具段只显示「此刻在跑」的调用。** ccline 只点名最老的两个、其余的折成 `+N`，elapsed 取最老那个的耗时；没有历史、没有单工具耗时、没有输出。带 `parentToolCallId` 的调用（codemode 脚本、工具内部再调工具）不列；子 agent 内部的调用只有 pi 把它交给主扩展时才会出现，目前不会。
 - **依赖外部二进制。** 没有 `ccline` 时 footer 只有一行安装提示；升级 `ccline` 后无需重启扩展，但二进制路径会被缓存到下一次解析（`/pi-ccline on` 或新会话会重算）。
 - **上游兼容性只覆盖已测版本。** ccline 2.0.1 的 `input.rs` 每个字段都是 `Option` + lenient 反序列化，同一大版本内字段换形状一般只会让对应段消失；但大版本之间已经发生过必填字段变化（1.1.x → 2.0.x），升级 ccline 后请用 `scripts/render-once.ts` 复跑一次。
 - **需要 Nerd Font v3+。** 图标字体缺失时会显示成方块；Windows 未测试。
@@ -156,7 +161,7 @@ extensions/pi-ccline/
   binary.ts   路径解析/缓存、带超时与中止的 spawn、--version 探测
   render.ts   输出归一化：分行、按可见宽度截断、stale 标记
   refresh.ts  单飞 + 节流 + latest-wins 调度器，以及驱动 `耗时` 的定时器
-  turn.ts     从流事件实测单次请求耗时，并写 ccline 的 bridge 文件供 `timing.tps`
+  turn.ts     从流事件实测单次请求耗时、跟踪运行中的工具，并写 ccline 的 bridge 文件
   config.ts   配置读写
   *.test.ts   node --test
 scripts/render-once.ts   用 fixture 跑一次真实 ccline

package/extensions/pi-ccline/config.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
 
-import { DEFAULT_CONFIG, MIN_LIVE_REFRESH_MS, MIN_THROTTLE_MS, configPath, loadConfig, normalizeConfig, saveConfig } from "./config.ts";
+import { DEFAULT_CONFIG, DEFAULT_STATUS_BADGES, MIN_LIVE_REFRESH_MS, MIN_THROTTLE_MS, configPath, loadConfig, normalizeConfig, resolveStatusBadges, saveConfig } from "./config.ts";
 
 function tempDir(): string {
 	return mkdtempSync(join(tmpdir(), "pi-ccline-config-"));
@@ -53,9 +53,58 @@ test("keeps valid overrides", () => {
 		liveRefreshMs: DEFAULT_CONFIG.liveRefreshMs,
 		showProvider: DEFAULT_CONFIG.showProvider,
 		env: {},
+		statusBadges: {},
 	});
 });
 
+test("ships a built-in poteto-mode badge and lets the config override it field by field", () => {
+	assert.deepEqual(DEFAULT_CONFIG.statusBadges, {});
+	assert.deepEqual(resolveStatusBadges(undefined), DEFAULT_STATUS_BADGES);
+
+	// Clearing only the icon keeps the built-in color.
+	const noIcon = normalizeConfig({ statusBadges: { "pi-herdr-pstack": { icon: "" } } });
+	assert.deepEqual(resolveStatusBadges(noIcon.statusBadges), { "pi-herdr-pstack": { icon: "", color: "accent" } });
+
+	// A color-only override reuses the built-in icon.
+	const recolored = normalizeConfig({ statusBadges: { "pi-herdr-pstack": { color: "warning" } } });
+	assert.deepEqual(resolveStatusBadges(recolored.statusBadges), { "pi-herdr-pstack": { icon: DEFAULT_STATUS_BADGES["pi-herdr-pstack"]?.icon, color: "warning" } });
+});
+
+test("badges can be added for other status keys, and unusable entries are dropped", () => {
+	const config = normalizeConfig({
+		statusBadges: {
+			"ssh-remote": { color: "success" },
+			" ssh-remote ": { color: "error" },
+			["x".repeat(65)]: { icon: "y" },
+			mcp: { icon: "\n\t" },
+			broken: 5,
+			"": { icon: "x" },
+		},
+	});
+	// Keys are matched verbatim against `setStatus` keys, so a padded or oversized
+	// key is dropped rather than rewritten into something that can only miss.
+	assert.deepEqual(config.statusBadges, { "ssh-remote": { color: "success" } });
+});
+
+test("prototype-named keys stay own data properties", () => {
+	// Only JSON can carry an own `__proto__` key; an object literal would set the prototype.
+	const raw = JSON.parse('{"statusBadges":{"constructor":{"icon":"C"},"__proto__":{"color":"error"}}}');
+	const config = normalizeConfig(raw);
+	const resolved = resolveStatusBadges(config.statusBadges);
+	assert.equal(Object.hasOwn(resolved, "constructor"), true);
+	assert.equal(Object.hasOwn(resolved, "__proto__"), true);
+	assert.equal(Object.getPrototypeOf(resolved), Object.prototype);
+	assert.deepEqual(resolved.constructor, { icon: "C", color: "" });
+	assert.deepEqual(resolved["__proto__"], { icon: "", color: "error" });
+});
+
+test("a badge icon is cleaned and capped instead of breaking the status row", () => {
+	const [icon = ""] = Object.values(normalizeConfig({ statusBadges: { k: { icon: "  \u001b[31mabcde  " } } }).statusBadges);
+	assert.deepEqual(icon, { icon: "abcd" });
+	assert.deepEqual(normalizeConfig({ statusBadges: [] }).statusBadges, {});
+	assert.deepEqual(normalizeConfig({ statusBadges: "none" }).statusBadges, {});
+});
+
 test("showProvider defaults on and ignores non-boolean values", () => {
 	assert.equal(DEFAULT_CONFIG.showProvider, true);
 	assert.equal(normalizeConfig({}).showProvider, true);

package/extensions/pi-ccline/config.ts

@@ -20,6 +20,12 @@ export interface PiCclineConfig {
 	showProvider: boolean;
 	/** Extra environment variables passed to the binary. */
 	env: Record<string, string>;
+	/**
+	 * Per status-key badges for other extensions' `ctx.ui.setStatus` rows, merged
+	 * over `DEFAULT_STATUS_BADGES` at render time. Only the fields a user set are
+	 * stored, so a newer built-in default still applies when a field is absent.
+	 */
+	statusBadges: Record<string, StatusBadgeOverride>;
 }
 
 export const DEFAULT_CONFIG: PiCclineConfig = {
@@ -30,8 +36,84 @@ export const DEFAULT_CONFIG: PiCclineConfig = {
 	liveRefreshMs: 1000,
 	showProvider: true,
 	env: {},
+	statusBadges: {},
 };
 
+/** A resolved badge: a Nerd Font glyph in front of the text and a theme color. */
+export interface StatusBadge {
+	/** Glyph shown before the status text; empty for none. */
+	icon: string;
+	/** pi theme foreground token (`accent`, `success`, …); empty or unknown for no color. */
+	color: string;
+}
+
+/** What a user may write per key: either field may be omitted and inherited. */
+export type StatusBadgeOverride = Partial<StatusBadge>;
+
+/**
+ * Built-in badges for statuses set by packages this footer knows about. The
+ * supplying extension sends text (and may style it itself); this footer adds an
+ * icon and a color when it left the text plain. Keys are pi's status keys,
+ * matched verbatim, never the package name.
+ */
+export const DEFAULT_STATUS_BADGES: Record<string, StatusBadge> = {
+	// pi-herdr-pstack keeps this key while the sticky poteto methodology is on.
+	"pi-herdr-pstack": { icon: "\uf135", color: "accent" },
+};
+
+/** An icon longer than this is a typo or a whole path, not a glyph. */
+const MAX_BADGE_ICON_CODEPOINTS = 4;
+const MAX_BADGE_KEY_LENGTH = 64;
+
+/** A badge is text: drop CSI/OSC escapes, then any remaining control character. */
+const ESCAPE_SEQUENCE = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b[@-Z\\-_]/g;
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/g;
+
+function cleanBadgeText(value: string): string {
+	return value.replace(ESCAPE_SEQUENCE, "").replace(CONTROL_CHARACTERS, "").trim();
+}
+
+function normalizeBadges(raw: unknown): Record<string, StatusBadgeOverride> {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+	const badges: [string, StatusBadgeOverride][] = [];
+	for (const [key, rawBadge] of Object.entries(raw as Record<string, unknown>)) {
+		// Status keys are matched verbatim against `setStatus` keys: a padded or
+		// oversized key can only ever miss, so it is dropped instead of rewritten.
+		if (!key || key !== key.trim() || key.length > MAX_BADGE_KEY_LENGTH) continue;
+		if (!rawBadge || typeof rawBadge !== "object" || Array.isArray(rawBadge)) continue;
+		const entry = rawBadge as Record<string, unknown>;
+		const badge: StatusBadgeOverride = {};
+		if (typeof entry.icon === "string") {
+			badge.icon = Array.from(cleanBadgeText(entry.icon)).slice(0, MAX_BADGE_ICON_CODEPOINTS).join("");
+		}
+		if (typeof entry.color === "string") badge.color = cleanBadgeText(entry.color);
+		if (badge.icon === undefined && badge.color === undefined) continue;
+		// An entry that ends up empty is how a built-in badge is cleared; for an
+		// unknown key it would only add noise.
+		const emptied = !badge.icon && !badge.color;
+		if (emptied && !Object.hasOwn(DEFAULT_STATUS_BADGES, key)) continue;
+		badges.push([key, badge]);
+	}
+	// fromEntries keeps keys like `__proto__` as own data properties instead of
+	// letting the assignment rewrite the prototype.
+	return Object.fromEntries(badges);
+}
+
+/** Built-in badges with the user's per-field overrides applied. */
+export function resolveStatusBadges(
+	overrides: Readonly<Record<string, StatusBadgeOverride>> | null | undefined,
+): Record<string, StatusBadge> {
+	const resolved = new Map<string, StatusBadge>();
+	for (const [key, badge] of Object.entries(DEFAULT_STATUS_BADGES)) resolved.set(key, { ...badge });
+	for (const [key, override] of Object.entries(overrides ?? {})) {
+		const merged: StatusBadge = { ...(resolved.get(key) ?? { icon: "", color: "" }) };
+		if (override.icon !== undefined) merged.icon = override.icon;
+		if (override.color !== undefined) merged.color = override.color;
+		resolved.set(key, merged);
+	}
+	return Object.fromEntries(resolved);
+}
+
 export const MIN_TIMEOUT_MS = 200;
 export const MAX_TIMEOUT_MS = 60_000;
 /** The footer re-renders often; a faster refresh rate would spawn too many processes. */
@@ -69,6 +151,7 @@ function clampLiveRefresh(value: unknown, fallback: number): number {
 }
 
 const binary = typeof source.binary === "string" && source.binary.trim() ? source.binary.trim() : null;
+const statusBadges = normalizeBadges(source.statusBadges);
 
 	return {
 		enabled: typeof source.enabled === "boolean" ? source.enabled : DEFAULT_CONFIG.enabled,
@@ -78,6 +161,7 @@ const binary = typeof source.binary === "string" && source.binary.trim() ? sourc
 		liveRefreshMs: clampLiveRefresh(source.liveRefreshMs, DEFAULT_CONFIG.liveRefreshMs),
 		showProvider: typeof source.showProvider === "boolean" ? source.showProvider : DEFAULT_CONFIG.showProvider,
 		env,
+		statusBadges,
 	};
 }
 

package/extensions/pi-ccline/footer.test.ts

@@ -7,7 +7,7 @@ import { afterEach, test } from "node:test";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { clearBinaryCache } from "./binary.ts";
-import { DEFAULT_CONFIG, type PiCclineConfig } from "./config.ts";
+import { DEFAULT_CONFIG, DEFAULT_STATUS_BADGES, type PiCclineConfig } from "./config.ts";
 import { CclineFooter, default as piCcline } from "./index.ts";
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -198,6 +198,33 @@ test("shows extension statuses even before ccline has produced a frame", () => {
 	harness.footer.dispose();
 });
 
+test("the built-in poteto-mode badge decorates the pi-herdr-pstack status", () => {
+	// The fake theme wraps everything in dim, so the marker proves the badge color
+	// path ran through theme.fg rather than being pasted on unconditionally.
+	const statuses = new Map([
+		["pi-herdr-pstack", "poteto-mode"],
+		["other-plugin", "Other status"],
+	]);
+	const harness = attach({ binary: fakeBinary("cat > /dev/null; printf 'FAKE-CCLINE\\n'") }, undefined, statuses);
+	const [statusRow] = harness.render(80).slice(1);
+	assert.equal(statusRow?.replace(/\u001b\[[0-9;]*m/g, ""), `Other status ${DEFAULT_STATUS_BADGES["pi-herdr-pstack"]?.icon} poteto-mode`);
+	assert.match(statusRow ?? "", /\u001b\[2m/, "the badge is colored through the theme");
+	harness.footer.dispose();
+});
+
+test("a configured badge override reaches the rendered row", () => {
+	const statuses = new Map([["pi-herdr-pstack", "poteto-mode"]]);
+	const harness = attach(
+		{ binary: fakeBinary("cat > /dev/null; printf 'FAKE-CCLINE\\n'"), statusBadges: { "pi-herdr-pstack": { icon: "" } } },
+		undefined,
+		statuses,
+	);
+	const row = harness.render(80)[1] ?? "";
+	assert.equal(row.replace(/\u001b\[[0-9;]*m/g, ""), "poteto-mode");
+	assert.match(row, /\u001b\[2m/, "clearing the icon keeps the configured color");
+	harness.footer.dispose();
+});
+
 test("live ticking advances time-based segments and stops with the agent run", async () => {
 	const counter = join(tempDir("pi-ccline-live-"), "count");
 	const binary = fakeBinary(
@@ -421,6 +448,54 @@ test("writes ccline's timing bridge from the streamed answer", async () => {
 	}
 });
 
+test("publishes running tools in the same bridge as the timing", async () => {
+	const cclineHome = tempDir("pi-ccline-bridge-tools-");
+	const previousHome = process.env.CCLINE_HOME;
+	process.env.CCLINE_HOME = cclineHome;
+	try {
+		const binary = fakeBinary("cat > /dev/null; printf 'FAKE-CCLINE\\n'");
+		const { pi, dispatch } = fakePi();
+		piCcline(pi as never, { loadConfig: () => ({ ...DEFAULT_CONFIG, binary }) });
+		const { ctx } = fakeSession({ idle: true, binary });
+		await dispatch("session_start", ctx);
+
+		// One finished answer, so the bridge already carries a turn.
+		const assistant = { role: "assistant", model: "m", usage: { output: 400 } };
+		await dispatch("message_start", ctx, { message: assistant });
+		await sleep(120);
+		await dispatch("message_update", ctx, { message: assistant });
+		await sleep(220);
+		await dispatch("message_end", ctx, { message: assistant });
+
+		const read = () => JSON.parse(readFileSync(join(cclineHome, "bridge", "sess-1.json"), "utf8"));
+		await dispatch("tool_execution_start", ctx, { toolCallId: "t1", toolName: "Bash" });
+		const running = read();
+		assert.deepEqual(running.tools.map((tool: { name: string }) => tool.name), ["Bash"]);
+		assert.ok(running.tools[0].since > 0);
+		assert.ok(running.turn.tps > 0, "a tools update must not blank the timing segment");
+
+		// A nested call from another tool is not a tool the user issued.
+		await dispatch("tool_execution_start", ctx, { toolCallId: "t2", toolName: "Read", parentToolCallId: "t1" });
+		assert.equal(read().tools.length, 1);
+
+		await dispatch("tool_execution_end", ctx, { toolCallId: "t1" });
+		const finished = read();
+		assert.equal("tools" in finished, false, "a finished tool leaves no row behind");
+		assert.ok(finished.turn.tps > 0);
+
+		// An aborted run may never send the end event; the run boundary clears it.
+		await dispatch("tool_execution_start", ctx, { toolCallId: "t3", toolName: "Grep" });
+		assert.equal(read().tools.length, 1);
+		await dispatch("agent_end", ctx);
+		assert.equal("tools" in read(), false, "no tool survives the run that owned it");
+
+		await dispatch("session_shutdown", ctx);
+	} finally {
+		if (previousHome === undefined) delete process.env.CCLINE_HOME;
+		else process.env.CCLINE_HOME = previousHome;
+	}
+});
+
 test("ignores message events that are not the assistant's answer", async () => {
 	const cclineHome = tempDir("pi-ccline-bridge-role-");
 	const previousHome = process.env.CCLINE_HOME;

package/extensions/pi-ccline/index.ts

@@ -2,11 +2,11 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 import { clearBinaryCache, probeVersion, resolveBinary, spawnCcline, type ResolvedBinary } from "./binary.ts";
-import { loadConfig, saveConfig, type PiCclineConfig } from "./config.ts";
+import { loadConfig, resolveStatusBadges, saveConfig, type PiCclineConfig, type StatusBadge } from "./config.ts";
 import { buildCclineInput, collectSnapshot } from "./input.ts";
 import { RefreshScheduler, RefreshTicker } from "./refresh.ts";
 import { extensionStatusLine, loadingNotice, missingBinaryNotice, normalizeFrame, noticeFrame, withStaleMarker } from "./render.ts";
-import { removeTurnBridge, TurnMeter, writeTurnBridge } from "./turn.ts";
+import { removeTurnBridge, TurnMeter, writeBridge, type BridgeTool, type TurnTiming } from "./turn.ts";
 
 /** Structural subsets so the footer does not depend on pi-tui internals. */
 type TuiLike = { requestRender(force?: boolean): void };
@@ -22,6 +22,14 @@ type MessageEventLike = {
 	message?: { role?: string | undefined; model?: string | undefined; usage?: { output?: number | undefined } | undefined } | undefined;
 };
 
+/** The slice of a pi tool event this extension reads. */
+type ToolEventLike = {
+	toolCallId?: string | undefined;
+	toolName?: string | undefined;
+	/** Set when another tool (a codemode script, an agent) made the call. */
+	parentToolCallId?: string | undefined;
+};
+
 const DEFAULT_WIDTH = 120;
 
 /**
@@ -49,6 +57,8 @@ function firstLine(text: string): string {
 export class CclineFooter {
 	private readonly ctx: ExtensionContext;
 	private readonly config: PiCclineConfig;
+	/** Built-in badges with the user's overrides already merged, resolved once. */
+	private readonly badges: Record<string, StatusBadge>;
 	private readonly scheduler: RefreshScheduler;
 	/** Only runs while the agent is active so an idle session spawns nothing. */
 	private readonly ticker: RefreshTicker;
@@ -65,6 +75,10 @@ export class CclineFooter {
 	private branchUnsubscribe: (() => void) | null = null;
 	/** Session whose ccline bridge this footer wrote, removed again on dispose. */
 	private bridgeSessionId: string | null = null;
+	/** The last finished answer, re-sent with every tools update (one file). */
+	private lastTiming: TurnTiming | null = null;
+	/** Tool calls running now, keyed by pi's tool call id. */
+	private readonly runningTools = new Map<string, BridgeTool>();
 	private readonly meter = new TurnMeter();
 	private disposed = false;
 
@@ -79,6 +93,7 @@ export class CclineFooter {
 	constructor(ctx: ExtensionContext, config: PiCclineConfig) {
 		this.ctx = ctx;
 		this.config = config;
+		this.badges = resolveStatusBadges(config.statusBadges);
 		this.scheduler = new RefreshScheduler({
 			throttleMs: config.refreshThrottleMs,
 			task: () => this.refresh(),
@@ -175,6 +190,21 @@ export class CclineFooter {
 		this.meter.firstDelta(performance.now());
 	}
 
+	/**
+	 * Rewrite the bridge with everything it has to carry: the last answer's
+	 * timing and the tools running now (ccline reads both from one file, so a
+	 * writer that sent only one of them would blank the other segment).
+	 */
+	private flushBridge(): void {
+		const sessionId = this.sessionId();
+		if (!sessionId) return;
+		const tools = [...this.runningTools.values()];
+		if (!this.lastTiming && tools.length === 0) return;
+		if (!writeBridge({ sessionId, timing: this.lastTiming ?? undefined, tools, nowMs: Date.now() })) return;
+		if (this.bridgeSessionId && this.bridgeSessionId !== sessionId) removeTurnBridge(this.bridgeSessionId);
+		this.bridgeSessionId = sessionId;
+	}
+
 	/**
 	 * The answer finished: hand ccline its timing through the bridge file it
 	 * reads for `timing.tps`. No speed, no file.
@@ -186,16 +216,45 @@ export class CclineFooter {
 		// stamp is wall-clock, and the two are never mixed.
 		const timing = this.meter.finish(message.usage?.output, performance.now());
 		if (!timing) return;
-		const sessionId = this.sessionId();
-		if (!sessionId) return;
-		if (!writeTurnBridge({ sessionId, timing, nowMs: Date.now() })) return;
-		if (this.bridgeSessionId && this.bridgeSessionId !== sessionId) removeTurnBridge(this.bridgeSessionId);
-		this.bridgeSessionId = sessionId;
+		this.lastTiming = timing;
 		this.stats.lastTps = timing.tps;
+		this.flushBridge();
 		// The new speed only shows up in the next frame; let the throttle coalesce it.
 		this.requestRefresh();
 	}
 
+	/**
+	 * A tool started: `activity.tools` shows it until `onToolEnd`. Nested calls
+	 * (codemode, tools calling tools) are skipped — a script would otherwise
+	 * flood the segment with names the user never issued.
+	 */
+	onToolStart(event: ToolEventLike): void {
+		const id = event.toolCallId;
+		const name = event.toolName;
+		if (!id || !name || event.parentToolCallId) return;
+		this.runningTools.set(id, { name, since: Date.now() });
+		this.flushBridge();
+		this.requestRefresh();
+	}
+
+	onToolEnd(event: ToolEventLike): void {
+		const id = event.toolCallId;
+		if (!id || !this.runningTools.delete(id)) return;
+		this.flushBridge();
+		this.requestRefresh();
+	}
+
+	/**
+	 * An aborted run can end without a matching `tool_execution_end`, and no
+	 * tool can outlive the run, so drop the rest rather than show a tool that
+	 * keeps counting up forever.
+	 */
+	clearRunningTools(): void {
+		if (this.runningTools.size === 0) return;
+		this.runningTools.clear();
+		this.flushBridge();
+	}
+
 	get hasFrame(): boolean {
 		return this.frame !== null;
 	}
@@ -227,7 +286,11 @@ export class CclineFooter {
 				return null;
 			}
 		})();
-		const status = extensionStatusLine(statuses, safeWidth, this.theme ? this.theme.fg("dim", "…") : "…");
+		const status = extensionStatusLine(statuses, safeWidth, this.theme ? this.theme.fg("dim", "…") : "…", {
+			badges: this.badges,
+			// render.ts catches a throwing token, so a stale theme entry costs only its color.
+			colorize: this.theme ? (color, text) => this.theme?.fg(color, text) ?? text : null,
+		});
 		return status ? [...lines, status] : lines;
 	}
 
@@ -313,6 +376,7 @@ export class CclineFooter {
 		this.branchUnsubscribe = null;
 		this.footerData = null;
 		this.requestRenderFn = null;
+		this.runningTools.clear();
 		if (this.bridgeSessionId) removeTurnBridge(this.bridgeSessionId);
 		this.bridgeSessionId = null;
 	}
@@ -364,8 +428,13 @@ export default function piCcline(pi: ExtensionAPI, deps: PiCclineDeps = {}) {
 	pi.on("agent_end", () => {
 		requestRefresh();
 		footer?.stopLive();
+		// No tool can survive the run, even when an abort skipped its end event.
+		footer?.clearRunningTools();
+	});
+	pi.on("agent_settled", () => {
+		footer?.stopLive();
+		footer?.clearRunningTools();
 	});
-	pi.on("agent_settled", () => footer?.stopLive());
 	pi.on("model_select", () => requestRefresh());
 	pi.on("thinking_level_select", () => requestRefresh());
 	pi.on("session_info_changed", () => requestRefresh());
@@ -374,6 +443,9 @@ export default function piCcline(pi: ExtensionAPI, deps: PiCclineDeps = {}) {
 	pi.on("message_start", (event) => footer?.onMessageStart(event as MessageEventLike));
 	pi.on("message_update", (event) => footer?.onMessageUpdate(event as MessageEventLike));
 	pi.on("message_end", (event) => footer?.onMessageEnd(event as MessageEventLike));
+	// Same bridge: `activity.tools` lists what is still running.
+	pi.on("tool_execution_start", (event) => footer?.onToolStart(event as ToolEventLike));
+	pi.on("tool_execution_end", (event) => footer?.onToolEnd(event as ToolEventLike));
 	pi.on("session_shutdown", () => teardown());
 
 	pi.registerCommand("pi-ccline", {

package/extensions/pi-ccline/render.test.ts

@@ -89,3 +89,60 @@ test("a long status row is truncated by visible width with the dim ellipsis", ()
 	assert.ok(visibleWidth(row) <= 10, `visible width was ${visibleWidth(row ?? "")}`);
 	assert.ok((row ?? "").replace(/\u001b\[[0-9;]*m/g, "").endsWith("..."));
 });
+
+test("a badge adds its icon and color to the matching status key only", () => {
+	const statuses = new Map([
+		["mcp", "connected"],
+		["pi-herdr-pstack", "poteto-mode"],
+	]);
+	const line = extensionStatusLine(statuses, 80, "…", {
+		badges: { "pi-herdr-pstack": { icon: "R", color: "accent" } },
+		colorize: (color, text) => `[${color}]${text}`,
+	});
+	assert.equal(line, "connected [accent]R poteto-mode");
+});
+
+test("a status that colors itself keeps its own styling", () => {
+	const statuses = new Map([["pi-herdr-pstack", `${RED}poteto-mode${RESET}`]]);
+	const line = extensionStatusLine(statuses, 80, "…", {
+		badges: { "pi-herdr-pstack": { icon: "R", color: "accent" } },
+		colorize: (color, text) => `[${color}]${text}`,
+	});
+	assert.equal(line, `${RED}poteto-mode${RESET}`);
+});
+
+test("an unknown theme token falls back to the plain badge label", () => {
+	const line = extensionStatusLine(new Map([["k", "v"]]), 80, "…", {
+		badges: { k: { icon: "R", color: "nope" } },
+		colorize: () => {
+			throw new Error("Unknown theme color: nope");
+		},
+	});
+	assert.equal(line, "R v");
+});
+
+test("an icon with no color still shows, and an empty icon adds no gap", () => {
+	const badges = { a: { icon: "R" }, b: { icon: "", color: "accent" } };
+	const line = extensionStatusLine(new Map([["a", "one"], ["b", "two"]]), 80, "…", {
+		badges,
+		colorize: (color, text) => `[${color}]${text}`,
+	});
+	assert.equal(line, "R one [accent]two");
+});
+
+test("only own badge entries are applied, never inherited object members", () => {
+	const line = extensionStatusLine(new Map([["toString", "v"]]), 80, "…", {
+		badges: {},
+		colorize: (color, text) => `[${color}]${text}`,
+	});
+	assert.equal(line, "v");
+});
+
+test("the badge counts toward the truncated width", () => {
+	const row = extensionStatusLine(new Map([["k", "日".repeat(10)]]), 10, "...", {
+		badges: { k: { icon: "R", color: "accent" } },
+		colorize: (color, text) => `\u001b[35m${text}\u001b[39m`,
+	});
+	assert.ok(row !== null);
+	assert.ok(visibleWidth(row) <= 10, `visible width was ${visibleWidth(row ?? "")}`);
+});

package/extensions/pi-ccline/render.ts

@@ -35,6 +35,40 @@ export function sanitizeStatusText(text: string): string {
 	return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
 }
 
+/** The badge fields this module needs; config.ts owns the validated shape. */
+export type StatusBadgeLike = { icon?: string | undefined; color?: string | undefined };
+
+export interface StatusLineOptions {
+	/** Badges per status key; a key without an entry stays plain text. */
+	badges?: Readonly<Record<string, StatusBadgeLike>> | null | undefined;
+	/** Theme colorizer for the badge color token; missing or throwing means plain text. */
+	colorize?: ((color: string, text: string) => string) | null | undefined;
+}
+
+/**
+ * A status arrives from another extension as text, and that extension may or
+ * may not have colored it. A badge adds an icon and a color — but only to a
+ * status that did not style itself, so an extension that already uses
+ * `theme.fg` keeps its own palette instead of ending up half-colored.
+ */
+function withBadge(key: string, text: string, options: StatusLineOptions): string {
+	const badges = options.badges;
+	// Own properties only: a status key like `toString` must not resolve to the
+	// object's inherited members.
+	const badge = badges && Object.hasOwn(badges, key) ? badges[key] : undefined;
+	if (!badge) return text;
+	if (text.includes("\u001b[")) return text;
+	const label = badge.icon ? `${badge.icon} ${text}` : text;
+	const colorize = options.colorize;
+	if (!badge.color || !colorize) return label;
+	try {
+		return colorize(badge.color, label);
+	} catch {
+		// An unknown theme token must not cost the row its text.
+		return label;
+	}
+}
+
 /**
  * pi's built-in footer puts every extension status on one extra row, sorted by
  * key and joined by a space. Mirror that so `ctx.ui.setStatus` keeps working
@@ -44,12 +78,14 @@ export function extensionStatusLine(
 	statuses: Iterable<[string, string]> | null | undefined,
 	width: number,
 	ellipsis = "…",
+	options: StatusLineOptions = {},
 ): string | null {
 	if (!statuses) return null;
 	const text = [...statuses]
 		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([, value]) => sanitizeStatusText(value))
-		.filter((value) => value.length > 0)
+		.map(([key, value]) => ({ key, text: sanitizeStatusText(value) }))
+		.filter((status) => status.text.length > 0)
+		.map((status) => withBadge(status.key, status.text, options))
 		.join(" ");
 	if (!text) return null;
 	const safeWidth = Math.max(1, Math.floor(width));

package/extensions/pi-ccline/turn.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, test } from "node:test";
 
-import { bridgeDir, bridgeFileName, removeTurnBridge, TurnMeter, writeTurnBridge } from "./turn.ts";
+import { bridgeDir, bridgeFileName, removeTurnBridge, TurnMeter, writeBridge } from "./turn.ts";
 
 const createdDirs: string[] = [];
 afterEach(() => {
@@ -77,9 +77,10 @@ test("a finished sample does not leak into the next request", () => {
 test("writes the bridge shape ccline reads", () => {
 	const dir = tempDir();
 	assert.equal(
-		writeTurnBridge({
+		writeBridge({
 			sessionId: "sess-1",
 			timing: { model: "m", ttftMs: 820, tps: 74.234, durationMs: 41_000, outputTokens: 1_400 },
+			tools: [{ name: "Bash", since: 1_790_808_755_000 }],
 			nowMs: 1_790_808_780_000,
 			dir,
 		}),
@@ -90,12 +91,37 @@ test("writes the bridge shape ccline reads", () => {
 		session: "sess-1",
 		updated_at: 1_790_808_780_000,
 		turn: { model: "m", ttft_ms: 820, tps: 74.234, duration_ms: 41_000, output_tokens: 1_400 },
+		tools: [{ name: "Bash", since: 1_790_808_755_000 }],
 	});
 });
 
+test("keeps the turn when tools come and go, and vice versa", () => {
+	const dir = tempDir();
+	const timing = { tps: 60, durationMs: 2_000, outputTokens: 120 };
+
+	// A tools-only write must not blank timing.tps, and a timing-only write must
+	// not leave a stale tool behind: both live in the same file.
+	writeBridge({ sessionId: "s4", timing, nowMs: 1, dir });
+	writeBridge({ sessionId: "s4", timing, tools: [{ name: "Read", since: 5 }], nowMs: 2, dir });
+	const withTool = JSON.parse(readFileSync(join(dir, "s4.json"), "utf8"));
+	assert.equal(withTool.turn.tps, 60);
+	assert.deepEqual(withTool.tools, [{ name: "Read", since: 5 }]);
+
+	writeBridge({ sessionId: "s4", timing, tools: [], nowMs: 3, dir });
+	const afterTool = JSON.parse(readFileSync(join(dir, "s4.json"), "utf8"));
+	assert.deepEqual(Object.keys(afterTool).sort(), ["session", "turn", "updated_at", "v"]);
+});
+
+test("writes nothing when there is neither timing nor a running tool", () => {
+	const dir = tempDir();
+	assert.equal(writeBridge({ sessionId: "s5", nowMs: 1, dir }), false);
+	assert.equal(writeBridge({ sessionId: "s5", tools: [], nowMs: 1, dir }), false);
+	assert.deepEqual(readdirSync(dir), []);
+});
+
 test("omits timing fields it did not measure", () => {
 	const dir = tempDir();
-	writeTurnBridge({ sessionId: "s2", timing: { tps: 12, durationMs: 1_000, outputTokens: 12 }, nowMs: 1, dir });
+	writeBridge({ sessionId: "s2", timing: { tps: 12, durationMs: 1_000, outputTokens: 12 }, nowMs: 1, dir });
 	const bridge = JSON.parse(readFileSync(join(dir, "s2.json"), "utf8"));
 	assert.deepEqual(Object.keys(bridge.turn).sort(), ["duration_ms", "output_tokens", "tps"]);
 });
@@ -105,7 +131,7 @@ test("refuses session ids that are not plain file names", () => {
 	assert.equal(bridgeFileName("../escape"), null);
 	assert.equal(bridgeFileName("a/b"), null);
 	assert.equal(bridgeFileName(""), null);
-	assert.equal(writeTurnBridge({ sessionId: "../escape", timing: { tps: 1, durationMs: 1, outputTokens: 1 }, nowMs: 1, dir }), false);
+	assert.equal(writeBridge({ sessionId: "../escape", timing: { tps: 1, durationMs: 1, outputTokens: 1 }, nowMs: 1, dir }), false);
 	assert.deepEqual(readdirSync(dir), [], "nothing escaped or landed in the bridge dir");
 });
 
@@ -114,13 +140,13 @@ test("a failed write leaves no temp file behind", () => {
 	// A directory in the target's place makes the rename fail after the temp
 	// file was already written.
 	mkdirSync(join(dir, "blocked.json"));
-	assert.equal(writeTurnBridge({ sessionId: "blocked", timing: { tps: 1, durationMs: 1, outputTokens: 1 }, nowMs: 1, dir }), false);
+	assert.equal(writeBridge({ sessionId: "blocked", timing: { tps: 1, durationMs: 1, outputTokens: 1 }, nowMs: 1, dir }), false);
 	assert.deepEqual(readdirSync(dir), ["blocked.json"]);
 });
 
 test("removes a session bridge and tolerates a missing one", () => {
 	const dir = tempDir();
-	writeTurnBridge({ sessionId: "s3", timing: { tps: 1, durationMs: 1, outputTokens: 1 }, nowMs: 1, dir });
+	writeBridge({ sessionId: "s3", timing: { tps: 1, durationMs: 1, outputTokens: 1 }, nowMs: 1, dir });
 	assert.equal(existsSync(join(dir, "s3.json")), true);
 	removeTurnBridge("s3", dir);
 	assert.equal(existsSync(join(dir, "s3.json")), false);

package/extensions/pi-ccline/turn.ts

@@ -43,35 +43,58 @@ export function bridgeFileName(sessionId: string): string | null {
 	return /^[A-Za-z0-9._-]+$/.test(sessionId) ? `${sessionId}.json` : null;
 }
 
-export interface TurnBridgeOptions {
+/** A tool call that is still running, as ccline's `activity.tools` reads it. */
+export interface BridgeTool {
+	name: string;
+	/** Unix epoch milliseconds it started; ccline derives the elapsed time. */
+	since: number;
+}
+
+export interface BridgeOptions {
 	sessionId: string;
-	timing: TurnTiming;
+	/** The last finished answer, kept while tools come and go (same file). */
+	timing?: TurnTiming | undefined;
+	/** Tool calls running right now, oldest first is not required: ccline sorts. */
+	tools?: readonly BridgeTool[] | undefined;
 	/** Unix epoch milliseconds of the write; ccline drops bridges older than 6h. */
 	nowMs: number;
 	dir?: string;
 }
 
-/** Write the bridge for one session. Returns false instead of throwing. */
-export function writeTurnBridge(options: TurnBridgeOptions): boolean {
+/**
+ * Write the bridge for one session. `turn` and `tools` share one file, so every
+ * writer passes both: dropping `turn` would make `timing.tps` disappear.
+ * Returns false instead of throwing.
+ */
+export function writeBridge(options: BridgeOptions): boolean {
 	const name = bridgeFileName(options.sessionId);
 	if (!name) return false;
+	const tools = options.tools ?? [];
+	if (!options.timing && tools.length === 0) return false;
 	const dir = options.dir ?? bridgeDir();
 	const path = join(dir, name);
-	const { model, ttftMs, tps, durationMs, outputTokens } = options.timing;
-	const turn: Record<string, unknown> = {
-		tps,
-		duration_ms: Math.round(durationMs),
-		output_tokens: Math.round(outputTokens),
-	};
-	if (model) turn.model = model;
-	if (ttftMs !== undefined) turn.ttft_ms = Math.round(ttftMs);
-	const payload = {
+	const payload: Record<string, unknown> = {
 		v: 1,
 		session: options.sessionId,
 		updated_at: Math.round(options.nowMs),
-		turn,
 	};
 
+	const timing = options.timing;
+	if (timing) {
+		const { model, ttftMs, tps, durationMs, outputTokens } = timing;
+		const turn: Record<string, unknown> = {
+			tps,
+			duration_ms: Math.round(durationMs),
+			output_tokens: Math.round(outputTokens),
+		};
+		if (model) turn.model = model;
+		if (ttftMs !== undefined) turn.ttft_ms = Math.round(ttftMs);
+		payload.turn = turn;
+	}
+	if (tools.length > 0) {
+		payload.tools = tools.map((tool) => ({ name: tool.name, since: Math.round(tool.since) }));
+	}
+
 	try {
 		mkdirSync(dir, { recursive: true });
 		// ccline tolerates a half-written bridge by retrying once, but an atomic

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@caph42/pi-ccline",
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"description": "Pi extension that renders the footer by delegating to the CCometixLine (ccline) statusline binary",
 	"keywords": [
 		"pi-package",