pi-cc-extensions 0.9.7 → 0.9.9

package/README.en.md

@@ -60,7 +60,7 @@ Renderer snapshots for `on` / `compact` modes: [default](./docs/tool-render-exam
   "expandedInputMaxLines": 5,              // expanded tool Input lines; overflow shows a footer hint
   "expandedOutputMaxLines": 10,            // expanded tool Output lines; overflow shows a footer hint
   "expandedPreviewMaxLines": 40,           // max lines for expanded TaskList bodies (expanded diffs always show all)
-  "inputClip": 100,                        // tool summary path/command clip length
+  "inputClip": 0,                          // tool summary path/command clip length; 0 = fit width
   "showStartupHeader": true,               // startup header (logo + tips) toggle
   "scrollStepLines": 3,                    // fullscreen wheel scroll step
 

package/README.md

@@ -60,7 +60,7 @@ pi install git:github.com/minuque/pi-cc-extensions
   "expandedInputMaxLines": 5,              // 展开工具卡 Input 可见行数，超出在末行显示展开提示
   "expandedOutputMaxLines": 10,            // 展开工具卡 Output 可见行数，超出在末行显示展开提示
   "expandedPreviewMaxLines": 40,           // 展开 TaskList 正文最大行数（展开 diff 始终全量）
-  "inputClip": 100,                        // 工具摘要 path/command 折叠字符数
+  "inputClip": 0,                          // 工具摘要 path/command 折叠字符数；0 = 按可用宽度
   "showStartupHeader": true,               // 启动头（logo + tips）开关
   "scrollStepLines": 3,                    // fullscreen 滚轮步进
 

package/extensions/config/config.ts

@@ -92,8 +92,8 @@ export const EXPANDED_PREVIEW_MAX_LINES_VALUES = ["40", "60", "80", "120", "200"
 export const EXPANDED_INPUT_MAX_LINES_VALUES = ["5", "10", "20", "40", "80"];
 /** 展开工具卡 Output 可见行数预设。 */
 export const EXPANDED_OUTPUT_MAX_LINES_VALUES = ["10", "20", "40", "80", "120"];
-/** 工具摘要里 path/command 等输入的折叠字符数。 */
-export const INPUT_CLIP_VALUES = ["40", "60", "80", "100", "120", "160"];
+/** 工具摘要里 path/command 等输入的折叠字符数；0 = 只按可用宽度截断。 */
+export const INPUT_CLIP_VALUES = ["0", "40", "60", "80", "100", "120", "160"];
 export const THINKING_PREVIEW_LINES_VALUES = ["0", "1", "3", "5", "10"];
 export const THINKING_ANIMATION_INTERVAL_VALUES = ["40", "60", "90", "120", "180"];
 /** fullscreen 滚轮步进行数预设。 */
@@ -124,7 +124,7 @@ export const DEFAULT_CONFIG: Config = {
 	expandedPreviewMaxLines: DEFAULT_TOOL_DISPLAY_CONFIG.expandedPreviewMaxLines,
 	expandedInputMaxLines: 5,
 	expandedOutputMaxLines: 10,
-	inputClip: 100,
+	inputClip: 0,
 	useSummaryTitlesAsThinkingTitle: true,
 	previewLines: 3,
 	animationIntervalMs: 90,
@@ -154,6 +154,12 @@ export function pickPositiveInt(value: unknown, fallback: number, min = 1, max =
 	return Math.min(max, Math.max(min, Math.floor(n)));
 }
 
+/** inputClip：0 表示按宽度自适应，其余夹到 8..500。 */
+export function pickInputClip(value: unknown): number {
+	const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+	return n === 0 ? 0 : pickPositiveInt(value, DEFAULT_CONFIG.inputClip, 8, 500);
+}
+
 export function pickPositiveNumber(value: unknown, fallback: number, min = 1): number {
 	const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
 	return Number.isFinite(n) ? Math.max(min, n) : fallback;
@@ -217,7 +223,7 @@ export function normalizeConfig(input: unknown): Config {
 			1,
 			5_000,
 		),
-		inputClip: pickPositiveInt(source.inputClip, DEFAULT_CONFIG.inputClip, 8, 500),
+		inputClip: pickInputClip(source.inputClip),
 		useSummaryTitlesAsThinkingTitle: source.useSummaryTitlesAsThinkingTitle !== false,
 		previewLines: pickPositiveInt(
 			source.previewLines,

package/extensions/config/panel.ts

@@ -38,6 +38,7 @@ import {
 	EXPANDED_PREVIEW_MAX_LINES_VALUES,
 	formatExcludeRenderers,
 	getCompactThinkingConfig,
+	pickInputClip,
 	pickPositiveInt,
 	pickPositiveNumber,
 	SCROLL_STEP_LINES_VALUES,
@@ -403,7 +404,7 @@ export async function showCcstylePanel(
 			id: "inputClip",
 			label: "Input clip",
 			description:
-				"Max characters for path/command/name in single and grouped tool summaries. Enter to type a custom value.",
+				"Max characters for path/command/name in single and grouped tool summaries; 0 fits available width. Enter to type a custom value.",
 			currentValue: String(config.inputClip),
 			values: [...INPUT_CLIP_VALUES],
 			submenu: (_current: string, closeSubmenu: (selected?: string) => void) =>
@@ -667,7 +668,7 @@ export async function showCcstylePanel(
 			switch (id) {
 				case "inputClip":
 					updateConfig({
-						inputClip: pickPositiveInt(value, DEFAULT_CONFIG.inputClip, 8, 500),
+						inputClip: pickInputClip(value),
 					});
 					inputClipSetting.currentValue = String(config.inputClip);
 					break;

package/extensions/feature/shell/startup-header.ts

@@ -1,9 +1,14 @@
-import { VERSION, type AppKeybinding } from "@earendil-works/pi-coding-agent";
+import { InteractiveMode, VERSION, type AppKeybinding } from "@earendil-works/pi-coding-agent";
 import { getKeybindings } from "@earendil-works/pi-tui";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { config } from "../../config/config.ts";
 import { ansi16ToRgb, ansi256ToRgb } from "../../utils/ansi-color.ts";
 import { stripAnsi } from "../../utils/ansi-text.ts";
+import {
+	EARLY_STARTUP_HEADER_PATCH,
+	EARLY_STARTUP_HEADER_SWAP_KEY,
+	patchRegistry,
+} from "../../utils/patch-keys.ts";
 type Rgb = [number, number, number];
 type StyledPart = {
 	raw: string;
@@ -279,17 +284,88 @@ export function renderHeaderLines(
 	);
 }
 
+/** 官方 setHeader 的组件工厂：theme 由宿主注入。 */
+function headerFactory(): (
+	tui: unknown,
+	theme: any,
+) => {
+	render(width: number): string[];
+	invalidate(): void;
+} {
+	return (_tui: unknown, theme: any) => ({
+		render(width: number): string[] {
+			return renderHeaderLines(width, theme);
+		},
+		invalidate() {},
+	});
+}
+
 /** 按配置安装启动头。禁用时不碰槽位，避免清掉其他扩展的 header。 */
 export function applyStartupHeader(ctx: any): void {
 	if (!ctx?.hasUI || typeof ctx.ui?.setHeader !== "function" || !config.showStartupHeader) {
 		return;
 	}
-	ctx.ui.setHeader((_tui: unknown, theme: any) => ({
-		render(width: number): string[] {
-			return renderHeaderLines(width, theme);
+	ctx.ui.setHeader(headerFactory());
+}
+
+type EarlyHeaderPatch = {
+	active: boolean;
+	original: (...args: any[]) => unknown;
+	installed: (...args: any[]) => unknown;
+};
+
+type HeaderContainerSwap = {
+	original: (child: any) => unknown;
+	installed: (child: any) => unknown;
+};
+
+/**
+ * Pi 在 session_start 之前就把原生启动头画上去了：init() 先建 header 再 requestRender，
+ * 之后才 await 工具检查、加载扩展，所以扩展最早只能到 session_start 换头，启动时会闪一下原生头。
+ * 这里补 init，在原生 header 刚进容器的瞬间换成 ccstyle 的，首次绘制就已经是我们的。
+ * 判定用 child === mode.builtInHeader，不依赖类名；配置关掉时不碰槽位，保留原生头。
+ */
+export function installEarlyStartupHeader(): void {
+	const prototype = (InteractiveMode as any)?.prototype;
+	if (!prototype || typeof prototype.init !== "function") return;
+	const previous = patchRegistry.get<EarlyHeaderPatch>(EARLY_STARTUP_HEADER_PATCH);
+	if (previous) previous.active = false;
+	const original =
+		previous && prototype.init === previous.installed ? previous.original : prototype.init;
+	const patch: EarlyHeaderPatch = {
+		active: true,
+		original,
+		installed: async function (this: any, ...args: any[]) {
+			installHeaderContainerSwap(this, patch);
+			return original.apply(this, args);
 		},
-		invalidate() {},
-	}));
+	};
+	prototype.init = patch.installed;
+	patchRegistry.install(EARLY_STARTUP_HEADER_PATCH, patch);
+}
+
+/** 只包一次 headerContainer.addChild；/reload 后按所有权接管旧包装。 */
+function installHeaderContainerSwap(mode: any, patch: EarlyHeaderPatch): void {
+	const container = mode?.headerContainer;
+	if (!container || typeof container.addChild !== "function") return;
+	const previous = container[EARLY_STARTUP_HEADER_SWAP_KEY] as HeaderContainerSwap | undefined;
+	const original =
+		previous && container.addChild === previous.installed
+			? previous.original
+			: container.addChild.bind(container);
+	const installed = function (child: any) {
+		const result = original(child);
+		if (!patch.active || !config.showStartupHeader || child !== mode.builtInHeader) return result;
+		if (typeof mode.setExtensionHeader !== "function") return result;
+		try {
+			mode.setExtensionHeader(headerFactory());
+		} catch {
+			// 换头失败就退回原生 header，不影响启动
+		}
+		return result;
+	};
+	container.addChild = installed;
+	container[EARLY_STARTUP_HEADER_SWAP_KEY] = { original, installed };
 }
 
 /** 用户从 /ccstyle 关掉本扩展启动头时，恢复官方 header。 */

package/extensions/feature/shell/working-message.ts

@@ -115,18 +115,30 @@ export default function (pi: ExtensionAPI): void {
 		return parts.length ? `Working... (${parts.join(" · ")})` : "";
 	}
 
+	function workingUiAvailable(): boolean {
+		try {
+			return activeCtx?.hasUI === true;
+		} catch {
+			// 会话替换/reload 后捕获的 ctx 失效，getter 抛错；停止驱动 footer。
+			turnActive = false;
+			activeCtx = null;
+			stopRefreshLoop();
+			return false;
+		}
+	}
+
 	function restoreDefaultWorkingMessage(): void {
 		lastMessage = null;
-		if (!activeCtx?.hasUI) return;
+		if (!workingUiAvailable()) return;
 		try {
-			activeCtx.ui?.setWorkingMessage();
+			activeCtx?.ui?.setWorkingMessage();
 		} catch {
 			// Noop when the TUI is unavailable.
 		}
 	}
 
 	function syncWorkingMessage(force = false): void {
-		if (!activeCtx?.hasUI) return;
+		if (!workingUiAvailable()) return;
 		const next = buildWorkingMessage();
 		if (!next) {
 			if (force) restoreDefaultWorkingMessage();
@@ -135,7 +147,7 @@ export default function (pi: ExtensionAPI): void {
 		if (!force && next === lastMessage) return;
 		lastMessage = next;
 		try {
-			activeCtx.ui?.setWorkingMessage(next);
+			activeCtx?.ui?.setWorkingMessage(next);
 		} catch {
 			// Noop when the TUI is unavailable.
 		}
@@ -147,9 +159,12 @@ export default function (pi: ExtensionAPI): void {
 			refreshTimer = null;
 			try {
 				syncWorkingMessage();
-			} finally {
-				scheduleRefreshTick();
+			} catch {
+				// 定时器内的异常会成为 uncaughtException 终止 Pi；装饰性刷新直接停止。
+				turnActive = false;
+				return;
 			}
+			scheduleRefreshTick();
 		}, REFRESH_INTERVAL_MS);
 		refreshTimer.unref?.();
 	}

package/extensions/index.ts

@@ -5,7 +5,7 @@ import { config } from "./config/config.ts";
 import piAliases from "./feature/shell/aliases.ts";
 import { installFlushDockedBash } from "./feature/shell/flush-docked-bash.ts";
 import customFooter from "./feature/shell/footer.ts";
-import piStartupHeader from "./feature/shell/startup-header.ts";
+import piStartupHeader, { installEarlyStartupHeader } from "./feature/shell/startup-header.ts";
 import workingMessage from "./feature/shell/working-message.ts";
 
 // feature
@@ -23,6 +23,7 @@ export default function (pi: ExtensionAPI): void {
 	// shell chrome
 	if (config.enableAliases) piAliases(pi);
 	installFlushDockedBash();
+	installEarlyStartupHeader();
 	piStartupHeader(pi);
 	if (config.enableWorkingMessage) workingMessage(pi);
 	customFooter(pi);

package/extensions/renderer/compact-mode.ts

@@ -8,10 +8,13 @@
  * Agent/Task 族：调用只进摘要计数，tool 卡始终折叠（避免 pending→完成高度闪动）。
  * 底部 Agents/Tasks 面板由 pi-subagents/pi-tasks 独立 widget 负责，不经 tool 卡外置。
  *
- * live 围观态（回合进行中 / 收尾静默期）：正文与摘要行跟折叠态同形，只在摘要行下面多一张
- * 单一槽位卡（`↳` + 最新的一个块：仍在增长的思考预览，或本回合最近的工具，运行中优先）。
+ * live 围观态（回合进行中 / 收尾静默期）：正文跟折叠态同形；摘要行与单一槽位卡
+ * （`↳` + 最新的一个块：仍在增长的思考预览，或本回合最近的工具，运行中优先）挂在
+ * transcript 容器的回合末尾（尾行组件，anchor 与工具卡之后、下一消息之前）。
  * 思考原地增长不轮换，只有新的思考块或工具调用进来才换槽位内容。
- * 收尾时摘要行原地从 Running... 翻成 Ran for、槽位卡消失，正文与摘要行都不换位置。
+ * 摘要行挂末尾是刻意的：运行中它恒在可写视口底缘，收尾时原地从 Running... 翻成
+ * Ran for 真实落进 scrollback；放在 anchor 内部则会被工具/diff 顶出视口后定格。
+ * （anchor 未挂载进容器的独立渲染场景退回组件内旧行为。）
  *
  * 工具计数：read 按非空路径去重、其余按调用计数（首次出现顺序）；edit/write 不进摘要。
  * 时长 = 回合流逝挂钟；进行中 Running...，结束 Ran for。
@@ -60,6 +63,7 @@ import {
 	COMPACT_THINKING_PATCH_KEY,
 	patchRegistry,
 	PROTOTYPE_ORIGINAL_KEY,
+	TOOL_GROUPING_PARENT_KEY,
 } from "../utils/patch-keys.ts";
 
 /** Pi 的 native 组件与扩展可能各持一份 pi-tui，Spacer 不能只靠 instanceof 判。 */
@@ -593,6 +597,22 @@ export function getCompactRunStatusText(): string | undefined {
 	return compactRunStatusGetter?.();
 }
 
+/**
+ * 回合尾行记录：摘要行（live 时连槽位卡）挂成 transcript 容器里回合末尾的
+ * 兄弟组件，而不是 anchor 内部。anchor 内部的可变内容一旦被工具/diff 顶出视口
+ * 就再也写不进 scrollback（regular 主屏只能差分可视区），运行态 Running 会永久
+ * 定格在挤出前最后一帧；尾行恒在可写底缘，收尾的 Ran for 才真实落进历史。
+ * 模块级持有（与 trackedAssistantComponents 同理）：跨 /reload 去重与清理。
+ */
+type MountedRoundTail = {
+	host: any;
+	container: any;
+	parts: any[];
+	round: any;
+};
+const tailByAnchor = new WeakMap<object, MountedRoundTail>();
+const mountedTails = new Set<MountedRoundTail>();
+
 export function setHoveredCompactAssistant(component: any): boolean {
 	if (hoveredAssistantComponent === component) return false;
 	hoveredAssistantComponent = component;
@@ -998,16 +1018,6 @@ function compactLiveSlot(card: any, pad = 0): any {
 	};
 }
 
-function compactAssistantLine(
-	component: any,
-	summary: string | (() => string),
-	query?: CompactThinkingQuery,
-): void {
-	// 空静态串跳过；getter 留给 render 判断（Running 可能稍后才有时长）。
-	if (typeof summary === "string" && !summary) return;
-	component.contentContainer.addChild(compactAssistantLineComponent(component, summary, query));
-}
-
 function appendStopStatus(component: any, status: string | undefined): void {
 	if (!status || !component?.contentContainer?.addChild) return;
 	component.contentContainer.addChild(
@@ -1117,6 +1127,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		/** 回合挂钟起点，保证 Running 时长连续递增。 */
 		startedAt: number;
 		endedAt?: number;
+		/** 回合尾行（摘要 + live 槽位），挂在 transcript 容器的回合末尾。 */
+		tail?: MountedRoundTail;
 	};
 	let activeRound: CompactRound | undefined;
 	let roundByComponent = new WeakMap<object, CompactRound>();
@@ -1155,6 +1167,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 				stopRoundTick();
 				return;
 			}
+			settleStrandedRounds();
 			try {
 				// 非 force：保留 fullscreen 布局缓存和差分绘制。
 				uiRef?.requestRender?.();
@@ -1287,6 +1300,236 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		return ids;
 	};
 
+	/**
+	 * anchor 所在的 transcript 容器（pi chatContainer）。
+	 * 优先走分组补丁在 addChild 时挂的父指针；没有则沿 tui 组件树找直属父容器。
+	 */
+	const tailContainerOf = (anchor: any): any => {
+		const keyed = anchor?.[TOOL_GROUPING_PARENT_KEY];
+		if (keyed && Array.isArray(keyed.children) && keyed.children.includes(anchor)) {
+			return keyed;
+		}
+		let found: any;
+		walkComponentTree(getToolMouseTui(), (value: any) => {
+			if (found) return false;
+			if (Array.isArray(value?.children) && value.children.includes(anchor)) {
+				found = value;
+				return false;
+			}
+			return undefined;
+		});
+		return found;
+	};
+
+	/** 组件在树里的直属父容器。TUI 切换/reparent 后缓存的 container 会过期。 */
+	const containerOfHost = (host: any): any => {
+		let found: any;
+		walkComponentTree(getToolMouseTui(), (value: any) => {
+			if (found) return false;
+			if (Array.isArray(value?.children) && value.children.includes(host)) {
+				found = value;
+				return false;
+			}
+			return undefined;
+		});
+		return found;
+	};
+
+	/** 尾行实际所在容器；缓存的 container 过期时按树找回来。 */
+	const tailHostContainer = (tail: MountedRoundTail): any =>
+		containerOfHost(tail.host) ??
+		(tail.container?.children?.includes?.(tail.host) === true ? tail.container : undefined);
+
+	/** 摘尾行：按实际所在容器摘，避免缓存过期时摘了个空、行留在树上。 */
+	const removeTailHost = (tail: MountedRoundTail): void => {
+		tailHostContainer(tail)?.removeChild?.(tail.host);
+	};
+
+	const ensureTailHost = (round: CompactRound): MountedRoundTail => {
+		if (round.tail) return round.tail;
+		// 同一 anchor 上残留的旧回合尾行（reset/重组后建新回合）先摘除，避免双摘要。
+		const stale = tailByAnchor.get(round.anchor);
+		if (stale) {
+			removeTailHost(stale);
+			mountedTails.delete(stale);
+			tailByAnchor.delete(round.anchor);
+		}
+		const tail: MountedRoundTail = { host: undefined, container: undefined, parts: [], round };
+		const host: any = {
+			outputPad: Number(round.anchor?.outputPad) || 0,
+			render: (width: number) => tail.parts.flatMap((part: any) => part?.render?.(width) ?? []),
+			invalidate: () => {
+				for (const part of tail.parts) part?.invalidate?.();
+			},
+		};
+		Object.defineProperty(host, "expanded", {
+			configurable: true,
+			get: () => tail.round?.anchor?.expanded === true,
+			set: (value: boolean) => {
+				const anchor = tail.round?.anchor;
+				if (anchor) anchor.expanded = value;
+			},
+		});
+		// 点击/悬停归属与 anchor 同一展开入口；toggle 每次 renderRound 重建，按值转发。
+		// 经 tail.round 动态解引用：重建过户时 anchor 可能换成别的组件。
+		ensureAssistantSetExpanded(host);
+		host[ASSISTANT_TOGGLE_ROUND_KEY] = (expanded: boolean) =>
+			tail.round?.anchor?.[ASSISTANT_TOGGLE_ROUND_KEY]?.(expanded);
+		tail.host = host;
+		tailByAnchor.set(round.anchor, tail);
+		mountedTails.add(tail);
+		round.tail = tail;
+		return tail;
+	};
+
+	/**
+	 * 尾行归位。运行中（含收尾静默期）尾行恒为容器最末一行：计数行钉在
+	 * transcript 底缘，运行中到达的提示行/custom 条目只能落在它上方，计数
+	 * 不会被顶离底部截成两行。回合收尾后摘要行回落到回合最后一个成员之后，
+	 * 外来行统一换到摘要行之下，通知行永远落在回合边界外。
+	 */
+	const syncTailPosition = (round: CompactRound): void => {
+		const tail = round.tail;
+		if (!tail?.host) return;
+		const container =
+			tail.container?.children?.includes?.(round.anchor) === true
+				? tail.container
+				: tailContainerOf(round.anchor);
+		if (!container || !Array.isArray(container.children)) return;
+		tail.container = container;
+		const children = container.children as any[];
+		const current = children.indexOf(tail.host);
+		if (current >= 0) children.splice(current, 1);
+		const ids = roundToolCallIds(round);
+		const matchesTool = (value: any): boolean =>
+			typeof value?.toolCallId === "string" && ids.has(value.toolCallId);
+		const isMember = (value: any): boolean =>
+			round.messages.has(value) ||
+			matchesTool(value) ||
+			(Array.isArray(value?.children) && value.children.some(matchesTool));
+		let first = -1;
+		let last = -1;
+		for (let i = 0; i < children.length; i++) {
+			if (!isMember(children[i])) continue;
+			if (first < 0) first = i;
+			last = i;
+		}
+		const lastMember = last >= 0 ? children[last] : undefined;
+		const intruders: any[] = [];
+		for (let i = last - 1; i > first; i--) {
+			if (!isMember(children[i])) intruders.unshift(children.splice(i, 1)[0]);
+		}
+		if (lastMember) last = children.indexOf(lastMember);
+		const insertAt = last < 0 ? children.length : last + 1;
+		if (roundLive(round)) {
+			// 活回合：外来行压到最后成员之后，尾行占容器最末。
+			children.splice(insertAt, 0, ...intruders);
+			children.push(tail.host);
+		} else {
+			children.splice(insertAt, 0, tail.host, ...intruders);
+		}
+		tail.host[TOOL_GROUPING_PARENT_KEY] = container;
+	};
+
+	const unmountRoundTail = (round: CompactRound): void => {
+		const tail = round.tail;
+		if (!tail) return;
+		round.tail = undefined;
+		removeTailHost(tail);
+		mountedTails.delete(tail);
+		if (tailByAnchor.get(round.anchor) === tail) tailByAnchor.delete(round.anchor);
+	};
+
+	/**
+	 * pi 把新工具卡 append 在容器末尾（尾行之后）：updateDisplay 时把所属回合的
+	 * 尾行压回末尾。只有 live/收尾静默期的回合还会长工具。
+	 */
+	const syncTailForTool = (toolCallId: string): void => {
+		if (!toolCallId) return;
+		for (const round of [activeRound, ...pendingFoldRounds]) {
+			if (round?.tail && roundToolCallIds(round).has(toolCallId)) {
+				syncTailPosition(round);
+				return;
+			}
+		}
+	};
+
+	/**
+	 * refresh 重建时继承旧回合：resetRounds 只清索引不摘 compact 尾行，
+	 * 残留尾行带着旧 round。同一组件重放同一消息（lastMessage 回放）
+	 * 才算重建——保留挂钟起点、已脱离的工具历史与尾行组件本身；
+	 * 旧回合已收尾的直接落成折叠态（不回摆 Running、不重演静默期），
+	 * 仍活动的只接回挂钟，Running 时长继续走。
+	 */
+	const adoptPriorRound = (round: CompactRound, message: any): void => {
+		let prior: CompactRound | undefined;
+		for (const tail of mountedTails) {
+			const stale = tail.round as CompactRound | undefined;
+			if (
+				stale &&
+				// 先认组件：重放时消息对象未必是同一个（会话重读/重建），
+				// 只认消息身份会漏掉本该接回的回合，摘要行就此掉队。
+				(stale.anchor === round.anchor ||
+					stale.messages.has(round.anchor) ||
+					stale.detachedMessages.includes(message))
+			) {
+				prior = stale;
+				break;
+			}
+		}
+		if (!prior) return;
+		round.startedAt = prior.startedAt;
+		if (prior.detachedMessages.length) round.detachedMessages.push(...prior.detachedMessages);
+		if (!prior.active) {
+			round.active = false;
+			round.endedAt = prior.endedAt ?? round.startedAt;
+		}
+		const tail = prior.tail;
+		if (tail) {
+			prior.tail = undefined;
+			if (tailByAnchor.get(prior.anchor) === tail) tailByAnchor.delete(prior.anchor);
+			tail.round = round;
+			tailByAnchor.set(round.anchor, tail);
+			round.tail = tail;
+		}
+	};
+
+	/** 新建活回合：literal + 激活 + refresh 重建时的旧回合收编。 */
+	const createRound = (anchor: any, message: any): CompactRound => {
+		const round: CompactRound = {
+			anchor,
+			messages: new Map(),
+			detachedMessages: [],
+			active: true,
+			suppressedToolIds: new Set(),
+			liveSlotToolIds: new Set(),
+			startedAt: Date.now(),
+		};
+		activateRound(round);
+		adoptPriorRound(round, message);
+		return round;
+	};
+
+	/**
+	 * 尾行挂载入口：makeParts 按渲染态产出内容（折叠态 [摘要行]，live 态
+	 * [摘要行, 槽位卡]），identity 决定行内 hover/点击归属组件（尾行模式下是
+	 * host，hit-test 直达它）。anchor 未挂进任何容器时（独立渲染）退回
+	 * contentContainer——与旧行为一致。
+	 */
+	const mountRoundTail = (round: CompactRound, makeParts: (identity: any) => any[]): void => {
+		if (!tailContainerOf(round.anchor)) {
+			// anchor 不在任何容器里（独立渲染/未挂载）：退回 anchor 内部，与旧行为一致。
+			unmountRoundTail(round);
+			for (const part of makeParts(round.anchor)) {
+				round.anchor?.contentContainer?.addChild?.(part);
+			}
+			return;
+		}
+		const tail = ensureTailHost(round);
+		tail.parts = makeParts(tail.host);
+		syncTailPosition(round);
+	};
+
 	/**
 	 * 末块仍是 thinking = 思考还在长；后面跟了正文或工具调用就算结束。
 	 * 围观态只预览这一种，已完成的思考直接回收进摘要行，不在屏幕上留 Thought 行。
@@ -1371,21 +1614,26 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 
 		const anchor = round.anchor;
 		const pad = Number(anchor.outputPad) || 0;
-		// 摘要行位置与折叠态一致（正文之后），收尾只有时态变化和槽位卡消失。
-		compactAssistantLine(anchor, getSummary, deps.query);
-		if (cardItems.length > 0) {
-			anchor.contentContainer.addChild(
-				compactLiveSlot(
-					compactRoundCard(
-						cardItems,
-						(tool, innerWidth) => patch.toolOriginalRender.call(tool, innerWidth),
-						false,
-						true,
+		// 摘要行与槽位卡挂回合尾行（transcript 容器内回合末尾，而非 anchor 内部）：
+		// 运行中恒在可写视口底缘，收尾的 Ran for 原地落进 scrollback，不再留下
+		// 被挤出视口后定格的 Running 帧。
+		mountRoundTail(round, (identity) => {
+			const parts: any[] = [compactAssistantLineComponent(identity, getSummary, deps.query)];
+			if (cardItems.length > 0) {
+				parts.push(
+					compactLiveSlot(
+						compactRoundCard(
+							cardItems,
+							(tool, innerWidth) => patch.toolOriginalRender.call(tool, innerWidth),
+							false,
+							true,
+						),
+						pad,
 					),
-					pad,
-				),
-			);
-		}
+				);
+			}
+			return parts;
+		});
 		appendStopStatus(anchor, stopStatus);
 	};
 
@@ -1431,6 +1679,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		}
 
 		if (round.anchor.expanded === true) {
+			// 展开卡自带全部内容，尾行摘下（收起时在折叠分支重新挂载）。
+			unmountRoundTail(round);
 			const toolsById = new Map<string, any>();
 			for (const tool of trackedToolComponents) {
 				if (typeof tool?.toolCallId === "string") toolsById.set(tool.toolCallId, tool);
@@ -1556,7 +1806,13 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			if (component === round.anchor) {
 				renderAssistantWithoutThinking(component, message);
 				// 空摘要不挂行（getter 在 Running 启动瞬间也可能短暂为空）
-				if (summary || round.active) compactAssistantLine(component, getSummary, deps.query);
+				if (summary || round.active) {
+					mountRoundTail(round, (identity) => [
+						compactAssistantLineComponent(identity, getSummary, deps.query),
+					]);
+				} else {
+					unmountRoundTail(round);
+				}
 				// 折叠时工具行被隐藏：abort/error/length 必须挂在摘要外层。
 				appendStopStatus(component, stopStatus);
 			} else {
@@ -1584,10 +1840,41 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		expandedRoundToolIds.clear();
 		explicitRoundToolIds.clear();
 		liveSlotToolIds.clear();
+		// 尾行是 transcript 兄弟组件：compact 下保留为静态行（与原 anchor 内摘要
+		// 一致；同 anchor 重建回合时 ensureTailHost 去重摘除），非 compact 摘掉，
+		// 别把紧凑摘要带进 default 渲染。
+		for (const tail of [...mountedTails]) {
+			const container = tailHostContainer(tail);
+			if (!container) {
+				mountedTails.delete(tail);
+				continue;
+			}
+			tail.container = container;
+			if (config.mode === "compact") continue;
+			container.removeChild(tail.host);
+			mountedTails.delete(tail);
+			if (tail.round?.tail === tail) tail.round.tail = undefined;
+			if (tail.round?.anchor && tailByAnchor.get(tail.round.anchor) === tail) {
+				tailByAnchor.delete(tail.round.anchor);
+			}
+		}
 		deps.query?.setCompactSummaryActive?.(false);
 		stopRoundTick();
 	};
 
+	/**
+	 * 兜底：resetRounds 会丢掉回合索引但保留已挂的尾行，重放没能接回的回合会一直
+	 * active——尾行永远显示 Running...（时长还在涨）却不再计入新工具。既不是活动
+	 * 回合也不在收尾静默期的活回合就地收尾，不让它永远挂在屏幕上。
+	 */
+	const settleStrandedRounds = (): void => {
+		for (const tail of [...mountedTails]) {
+			const round = tail.round as CompactRound | undefined;
+			if (!round?.active || round === activeRound || pendingFoldRounds.has(round)) continue;
+			endRound(round, true);
+		}
+	};
+
 	patch.assistantInstalled = function (this: any, message: any, isStreaming?: boolean) {
 		const self = this as any;
 		// 同 compact-thinking：isStreaming 丢失 → mermaid 流式误渲染来回闪。
@@ -1616,29 +1903,11 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 			if (hasText && (!round || round.anchor !== this)) {
 				if (round) round.messages.delete(this);
 				if (activeRound) finishRound(activeRound);
-				round = {
-					anchor: this,
-					messages: new Map(),
-					detachedMessages: [],
-					active: true,
-					suppressedToolIds: new Set(),
-					liveSlotToolIds: new Set(),
-					startedAt: Date.now(),
-				};
+				round = createRound(this, message);
 				roundByComponent.set(this, round);
-				activateRound(round);
 			} else if (!round) {
-				round = activeRound ?? {
-					anchor: this,
-					messages: new Map(),
-					detachedMessages: [],
-					active: true,
-					suppressedToolIds: new Set(),
-					liveSlotToolIds: new Set(),
-					startedAt: Date.now(),
-				};
+				round = activeRound ?? createRound(this, message);
 				roundByComponent.set(this, round);
-				if (!activeRound) activateRound(round);
 			}
 			round.messages.set(this, message);
 			renderRound(round);
@@ -1671,17 +1940,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		if (hasThinking) {
 			let round = roundByComponent.get(this);
 			if (!round) {
-				round = activeRound ?? {
-					anchor: this,
-					messages: new Map(),
-					detachedMessages: [],
-					active: true,
-					suppressedToolIds: new Set(),
-					liveSlotToolIds: new Set(),
-					startedAt: Date.now(),
-				};
+				round = activeRound ?? createRound(this, message);
 				roundByComponent.set(this, round);
-				if (!activeRound) activateRound(round);
 			}
 			round.messages.set(this, message);
 			renderRound(round);
@@ -1733,6 +1993,7 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		const result = patch.toolOriginalUpdateDisplay.call(this);
 		if (!patch.active) return result;
 		trackedToolComponents.add(this);
+		if (config.mode === "compact") syncTailForTool(id);
 		return result;
 	};
 

package/extensions/renderer/default-mode.ts

@@ -100,6 +100,8 @@ type ToolExpandedBackgroundPatch = {
 	dispose: () => void;
 };
 
+/** rich diff 的两个入口（本处与 compact 的 paintCompactEditWrite）都靠 renderRichToolResult
+ * 返回 undefined 让位，这里只判断模式与工具名，避免多一个可能与让位不一致的 gate。 */
 export function shouldRenderRichDiff(
 	mode: CompactStyleMode,
 	toolName: string,

package/extensions/renderer/index.ts

@@ -12,7 +12,7 @@ import {
 	installToolExpandedBackground,
 	type DefaultModeHooks,
 } from "./default-mode.ts";
-import { isLazyProxyTui } from "../utils/fullscreen-detect.ts";
+import { installMainScreenDoRenderPatch, isLazyProxyTui } from "../utils/fullscreen-detect.ts";
 import { showCcstylePanel } from "../config/panel.ts";
 import {
 	config,
@@ -116,6 +116,8 @@ export default function (
 		// 渲染层（工具样式/分组）是原型与组件级 patch，fullscreen 官方布局
 		// 同样渲染这些组件，因此两种模式都安装。
 		if (installation) return installation;
+		// regular 主屏的差分渲染补丁：视口上方变化不再触发清回滚的 fullRender。
+		installMainScreenDoRenderPatch();
 		const defaultMode = installDefaultMode(writeExecutionMetadata);
 		const toolGrouping = installToolGrouping(() => config.mode === "on");
 		const compactMode = installCompactMode({
@@ -206,10 +208,18 @@ export default function (
 	});
 
 	pi.on("session_start", async (event, ctx) => {
-		// 延迟到 session_start 注册 write override：加载阶段 getAllTools 不可用且其他扩展
-		// 尚未注册工具，无法检测外部 write 所有者（如 pi-spark），直接注册会与对方撞名。
-		// session_start 时所有扩展已加载完毕，installWriteOverride 内部会检测并让位。
-		installWriteOverride(pi, writeExecutionMetadata);
+		// 延后一拍再确认 write 归属：其他扩展同样在各自的 session_start 里注册工具，
+		// 本 handler 执行时可能还看不到对方，此时注册会与对方撞名（注册表先到先得），
+		// 对方的 write 会被静默丢弃。等所有 session_start 跑完，检测结果才是权威的。
+		setTimeout(() => {
+			installWriteOverride(pi, writeExecutionMetadata, (owner) => {
+				// 冲突可见：对方接管 write 后本插件不再提供富 diff。
+				ctx.ui?.notify?.(
+					`ccstyle: write 工具已被 ${owner.path || owner.source} 占用，富 diff 已让位`,
+					"warning",
+				);
+			});
+		}, 0);
 		const hooks = ensureTuiInstallation(ctx);
 		// 鼠标交互独立于渲染层：fullscreen 渲染层让位（hooks undefined）但
 		// 工具点击/回到底部适配仍需安装；保持在渲染层安装之后以维持原顺序。

package/extensions/renderer/tool/diff/index.ts

@@ -6,6 +6,7 @@ import {
 	type DisplayConfigInput,
 } from "./diff-renderer.ts";
 import { DEFAULT_TOOL_DISPLAY_CONFIG } from "../../../config/config.ts";
+import { patchRegistry, WRITE_OWNERSHIP_SLOT } from "../../../utils/patch-keys.ts";
 import { executeWriteWithMetadata, WriteExecutionMetadataStore } from "./write-execution.ts";
 
 function resultText(result: any): string {
@@ -59,6 +60,8 @@ export function renderRichToolResult(
 		);
 	}
 	if (toolName !== "write") return undefined;
+	// 让位点：write 归其他扩展时不提供富 diff，交回普通结果行。
+	if (!ownsWriteTool()) return undefined;
 
 	const metadata = writeMetadata.get(context?.toolCallId);
 	if (!metadata) {
@@ -83,23 +86,57 @@ export function renderRichToolResult(
 	);
 }
 
-function hasExternalWriteOwner(pi: ExtensionAPI): boolean {
+/** write 被其他扩展占用时的来源，用于提示冲突。 */
+export type ExternalWriteOwner = { source: string; path: string };
+
+type WriteOwnershipState = {
+	/** write 是否由本插件执行；undefined 表示尚未确认，按拥有处理以保持既有行为。 */
+	owned?: boolean;
+};
+
+function writeOwnership(): WriteOwnershipState {
+	return patchRegistry.ensure<WriteOwnershipState>(WRITE_OWNERSHIP_SLOT, () => ({}));
+}
+
+/**
+ * write 是否由本插件执行。只有注册过 write override 才有执行元数据，
+ * 否则渲染层要放行给普通结果行，避免每张卡降级成 "diff unavailable"。
+ */
+export function ownsWriteTool(): boolean {
+	return writeOwnership().owned !== false;
+}
+
+/** 当前占用 write 的其他扩展；builtin 或未注册时返回 undefined。 */
+function findExternalWriteOwner(pi: ExtensionAPI): ExternalWriteOwner | undefined {
 	try {
-		const tools = pi.getAllTools();
-		const write = tools.find((tool: any) => tool?.name === "write") as any;
-		const source = write?.sourceInfo?.source;
-		return Boolean(write && typeof source === "string" && source !== "builtin");
+		const tools = pi.getAllTools() as any[];
+		const write = tools?.find((tool: any) => tool?.name === "write") as any;
+		const sourceInfo = write?.sourceInfo;
+		const source = sourceInfo?.source;
+		if (!write || typeof source !== "string" || source === "builtin") return undefined;
+		return { source, path: typeof sourceInfo?.path === "string" ? sourceInfo.path : "" };
 	} catch {
-		// getAllTools is unavailable before the extension runtime is bound.
-		return false;
+		// getAllTools 在扩展运行时绑定前不可用。
+		return undefined;
 	}
 }
 
 export function installWriteOverride(
 	pi: ExtensionAPI,
 	store = new WriteExecutionMetadataStore(),
+	/** write 已被其他扩展占用时回调一次，调用方据此提示冲突。 */
+	onExternalOwner?: (owner: ExternalWriteOwner) => void,
 ): WriteExecutionMetadataStore {
-	if (typeof (pi as any).registerTool !== "function" || hasExternalWriteOwner(pi)) return store;
+	if (typeof (pi as any).registerTool !== "function") return store;
+	const state = writeOwnership();
+	const external = findExternalWriteOwner(pi);
+	if (external) {
+		// 让位：执行与 diff 都归对方，渲染层据 owned=false 走普通结果行。
+		state.owned = false;
+		onExternalOwner?.(external);
+		return store;
+	}
+	state.owned = true;
 	const nativeWrite = createWriteToolDefinition(process.cwd()) as any;
 	pi.registerTool({
 		...nativeWrite,

package/extensions/renderer/tool/grouping.ts

@@ -19,6 +19,7 @@ import {
 	toolCallSummary,
 	type ToolCallSummary,
 } from "./names.ts";
+import { toolViewportWidth } from "./result.ts";
 import {
 	patchRegistry,
 	TOOL_GROUPING_GENERATION_KEY as GENERATION_KEY,
@@ -378,7 +379,7 @@ export class ToolGroupComponent extends Container {
 			"",
 			truncateToWidth(
 				` ${fg(overallColor, "●")} ${label}: ${countText}${nameList} ${hint}`,
-				width,
+				toolViewportWidth(width),
 				"…",
 			),
 		];
@@ -411,11 +412,13 @@ export class ToolGroupComponent extends Container {
 				const summary = toolSummary(tool);
 				const prefix = ` ${fg("dim", branch)} ${fg(color, statusIcon(toolStatus))} `;
 				const detail = fg("dim", summary.detail);
-				const mainWidth = Math.max(0, width - visibleWidth(prefix) - visibleWidth(detail));
+				// 与单工具卡标题同宽，宽屏右侧留白一致
+				const rowWidth = toolViewportWidth(width);
+				const mainWidth = Math.max(0, rowWidth - visibleWidth(prefix) - visibleWidth(detail));
 				lines.push(
 					truncateToWidth(
 						`${prefix}${renderToolSummary(summary, mainWidth, fg)}${detail}`,
-						width,
+						rowWidth,
 						"",
 					),
 				);

package/extensions/renderer/tool/names.ts

@@ -5,8 +5,13 @@ import { config } from "../../config/config.ts";
 import { oneLine } from "../../utils/format.ts";
 import { headTruncateToWidth } from "./result.ts";
 
+/** inputClip=0 时不设字符上限，交给渲染时的实际宽度截断。 */
+function clipLimit(): number {
+	return config.inputClip > 0 ? config.inputClip : Number.POSITIVE_INFINITY;
+}
+
 function clip(value: unknown): string {
-	return oneLine(value, config.inputClip);
+	return oneLine(value, clipLimit());
 }
 
 /** 载荷（入参 JSON / 脚本代码）至少留出这么多宽度才显示，否则整段省略（避免只剩一个孤零零的 " {…"）。 */
@@ -62,8 +67,8 @@ export type ToolCallSummary = {
 };
 
 function pathApi(value: string) {
-	if (win32.isAbsolute(value)) return win32;
 	if (posix.isAbsolute(value)) return posix;
+	if (win32.isAbsolute(value)) return win32;
 	return undefined;
 }
 
@@ -125,7 +130,7 @@ export function truncatePathToWidth(path: string, width: number): string {
 
 /** 路径展示的统一入口：相对化后按配置和当前可用宽度截断。 */
 export function formatDisplayPath(value: unknown, cwd: string | undefined, width: number): string {
-	return truncatePathToWidth(displayPath(value, cwd), Math.min(width, config.inputClip));
+	return truncatePathToWidth(displayPath(value, cwd), Math.min(width, clipLimit()));
 }
 
 /** 按最终终端宽度渲染摘要；路径摘要不会再被整行头部截断。 */
@@ -134,7 +139,7 @@ export function fitToolCallSummary(summary: ToolCallSummary, width: number): str
 	const prefix = summary.path.prefix;
 	const pathWidth = Math.max(0, width - visibleWidth(prefix) - 1);
 	if (pathWidth <= 0) return headToWidth(prefix, width, "…");
-	return `${prefix} ${truncatePathToWidth(summary.path.value, Math.min(pathWidth, config.inputClip))}`;
+	return `${prefix} ${truncatePathToWidth(summary.path.value, Math.min(pathWidth, clipLimit()))}`;
 }
 
 function pathSummary(
@@ -145,7 +150,7 @@ function pathSummary(
 ): ToolCallSummary {
 	const path = displayPath(value, cwd);
 	return {
-		main: `${prefix} ${truncatePathToWidth(path, config.inputClip)}`,
+		main: `${prefix} ${truncatePathToWidth(path, clipLimit())}`,
 		detail,
 		path: { prefix, value: path },
 	};

package/extensions/renderer/tool/result.ts

@@ -7,9 +7,15 @@ import { getToolMouseTui } from "../mouse/scroll.ts";
 import { sanitizeToolResultText } from "../../utils/tool-result-sanitize.ts";
 
 const TOOL_VIEWPORT_WIDTH_RATIO = 0.8;
+/** 宽屏右侧留白上限：比例留白超过这么多列时改用固定留白。 */
+const TOOL_VIEWPORT_MAX_GUTTER = 24;
 
 export function toolViewportWidth(width: number): number {
-	return Math.max(1, Math.floor(width * TOOL_VIEWPORT_WIDTH_RATIO));
+	return Math.max(
+		1,
+		Math.floor(width * TOOL_VIEWPORT_WIDTH_RATIO),
+		Math.floor(width) - TOOL_VIEWPORT_MAX_GUTTER,
+	);
 }
 
 /** 与默认工具结果相同的一级缩进包装。子组件只扣始终加上的 1 列；↳ 行多出的 2 列由 truncateToWidth 吃掉。 */

package/extensions/utils/fullscreen-detect.ts

@@ -1,3 +1,6 @@
+import { TuiMainScreen } from "@earendil-works/pi-tui";
+import { MAIN_SCREEN_DO_RENDER_PATCH, patchRegistry } from "./patch-keys.ts";
+
 /**
  * 官方 0.84+ 的 tui 引用是惰性 Proxy（createInteractiveTuiReference）：
  * 函数属性每次 get 都返回新包装，执行时才解析到当前实现。
@@ -9,3 +12,51 @@ export function isLazyProxyTui(tui: any): boolean {
 	const probe = tui.requestRender;
 	return typeof probe === "function" && probe !== tui.requestRender;
 }
+
+type MainScreenDoRenderPatch = {
+	active: boolean;
+	original: (lines: string[]) => string[];
+	installed: (lines: string[]) => string[];
+};
+
+/**
+ * regular（TuiMainScreen）模式的 doRender 走差分绘制：一旦第一个变化行落在
+ * previousViewportTop 之上（终端写不进 scrollback 的区域），只能
+ * fullRender(true)——\x1b[2J\x1b[H\x1b[3J 清屏并清掉整段 scrollback。
+ * compact 直播式回合的摘要行动画与流式正文渲染在回合工具卡/diff 面板上方；
+ * diff 面板一落地把下方内容撑过屏高，之后每帧重绘都命中该分支：scrollback
+ * 被反复清空，滚动条回弹、视口钉住，直到输出结束才恢复。
+ *
+ * 视口上方的行本就无法重写，只剩「清回滚重打」与「scrollback 保留旧文本」
+ * 两条路。这里选后者：applyLineResets 是差分比较前最后一个拿到整帧的环节，
+ * 把 previousLines 的视口上方前缀直接对齐新帧，差分只看到可写区域，照常增量
+ * 绘制。代价仅是 scrollback 里那几行停留在最后一次实际写入的内容。
+ */
+export function installMainScreenDoRenderPatch(): void {
+	const prototype = TuiMainScreen.prototype as any;
+	if (typeof prototype?.applyLineResets !== "function") return;
+	const previous = patchRegistry.get<MainScreenDoRenderPatch>(MAIN_SCREEN_DO_RENDER_PATCH);
+	if (previous) previous.active = false;
+	const original =
+		previous && prototype.applyLineResets === previous.installed
+			? previous.original
+			: prototype.applyLineResets;
+	const patch: MainScreenDoRenderPatch = {
+		active: true,
+		original,
+		installed(this: any, lines: string[]) {
+			const result = original.call(this, lines);
+			if (!patch.active) return result;
+			const prev = this.previousLines;
+			if (!Array.isArray(prev)) return result;
+			const top = Math.min(
+				Math.max(0, Math.floor(Number(this.previousViewportTop) || 0)),
+				result.length,
+			);
+			for (let i = 0; i < top; i++) prev[i] = result[i];
+			return result;
+		},
+	};
+	prototype.applyLineResets = patch.installed;
+	patchRegistry.install(MAIN_SCREEN_DO_RENDER_PATCH, patch);
+}

package/extensions/utils/patch-keys.ts

@@ -29,6 +29,8 @@ export const COMPONENT_TOOL_RENDER_MODE = Symbol.for("pi.ccstyle.component-tool-
 export const TOOL_EXPANDED_BACKGROUND_PATCH = Symbol.for(
 	"pi.ccstyle.tool-expanded-background-patch",
 );
+// write 归属：注册期确认一次，渲染期据此决定是否提供 rich diff。
+export const WRITE_OWNERSHIP_SLOT = Symbol.for("pi.ccstyle.write-ownership");
 
 // ── 消息组件补丁 ──
 export const MESSAGE_DISPLAY_PATCH = Symbol.for("pi.ccstyle.message-display-patch");
@@ -38,12 +40,17 @@ export const TOOL_GROUPING_PATCH_KEY = Symbol.for("pi.ccstyle.tool-grouping-patc
 export const TOOL_GROUPING_PARENT_KEY = Symbol.for("pi.ccstyle.tool-grouping-parent");
 export const TOOL_GROUPING_GENERATION_KEY = Symbol.for("pi.ccstyle.tool-grouping-generation");
 
+// ── regular 主屏渲染补丁 ──
+export const MAIN_SCREEN_DO_RENDER_PATCH = Symbol.for("pi.ccstyle.main-screen-do-render-patch");
+
 // ── 鼠标交互 ──
 export const TOOL_MOUSE_OWNER_KEY = Symbol.for("pi.ccstyle.tool-mouse-owner");
 export const TOOL_MOUSE_TUI_SLOT = Symbol.for("pi.ccstyle.tool-mouse-tui");
 export const SCROLL_BUTTON_STATE_SLOT = Symbol.for("pi.ccstyle.scroll-button-state");
 export const OFFICIAL_SCROLL_TO_END_KEY = Symbol.for("pi.ccstyle.official-scroll-to-end");
 export const FLUSH_DOCKED_BASH_PATCH = Symbol.for("pi.ccstyle.flush-docked-bash-patch");
+export const EARLY_STARTUP_HEADER_PATCH = Symbol.for("pi.ccstyle.early-startup-header-patch");
+export const EARLY_STARTUP_HEADER_SWAP_KEY = Symbol.for("pi.ccstyle.early-startup-header-swap");
 export const TOOL_HOVER_STATE_KEY = Symbol.for("pi.ccstyle.tool-hover-state");
 
 // ── rich diff 组件标记 ──

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-extensions",
-	"version": "0.9.7",
+	"version": "0.9.9",
 	"license": "MIT",
 	"description": "Claude Code-style TUI output with some personal touches and handy utilities.",
 	"type": "module",
@@ -56,15 +56,18 @@
 	},
 	"bundledDependencies": [],
 	"peerDependencies": {
-		"@earendil-works/pi-ai": "^0.84.0",
-		"@earendil-works/pi-coding-agent": "^0.84.0",
-		"@earendil-works/pi-tui": "^0.84.0"
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
 	},
 	"engines": {
 		"node": ">=22.19.0"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.5",
+		"@earendil-works/pi-ai": "0.99.1",
+		"@earendil-works/pi-coding-agent": "0.99.1",
+		"@earendil-works/pi-tui": "0.99.1",
 		"@types/node": "^26.1.1",
 		"typescript": "^5.9.3"
 	}