@caph42/pi-ccline 0.2.0 → 0.2.1

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 |
@@ -105,7 +106,7 @@ Binary resolution order: `config.binary` → `~/.claude/ccline/ccline` → `ccli
 - **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 +137,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 +158,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 自己读磁盘 |
@@ -105,7 +106,7 @@ pi install .
 - **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 +137,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 +158,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/footer.test.ts

@@ -421,6 +421,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

@@ -6,7 +6,7 @@ import { loadConfig, saveConfig, type PiCclineConfig } 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;
 
 /**
@@ -65,6 +73,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;
 
@@ -175,6 +187,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 +213,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;
 	}
@@ -313,6 +369,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 +421,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 +436,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/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.1",
 	"description": "Pi extension that renders the footer by delegating to the CCometixLine (ccline) statusline binary",
 	"keywords": [
 		"pi-package",