@owlburtoe/pi-cc-tools 1.0.0 → 1.0.1

package/README.md

@@ -1,13 +1,4 @@
-# pi-cc-tools
-
-## Install
-
-```bash
-pi install npm:@owlburtoe/pi-cc-tools
-```
-
-Run `/reload` or restart Pi after installation.
-
+# pi-claude-style-tools
 
 Claude Code inspired tool rendering for Pi — Shiki-powered diffs, status dots, branch connectors, file icons, and configurable output modes.
 
@@ -20,6 +11,7 @@ Claude Code inspired tool rendering for Pi — Shiki-powered diffs, status dots,
 - **Diff stat bar** with colored add/remove summary and hunk metadata
 - **Progressive collapsed diff hints** that shorten on narrow terminals
 - **Thinking labels** during streaming and final messages, with context sanitization
+- **Claude-style transcript grammar controls** for assistant/thinking prefixes, message spacing, hidden thinking labels, and active working tips
 - **MCP-aware rendering** with hidden, summary, and preview modes
 - **Configurable output modes** for read, search, bash, and MCP results
 - **Transparent tool backgrounds** in `transparent` or `border` mode
@@ -45,7 +37,14 @@ Set in `.pi/settings.json` or `~/.pi/settings.json`:
   "diffTheme": "github-dark",
   "spinnerColor": "borderAccent",
   "spinnerVerbs": ["Reviewing", "Polishing"],
-  "spinnerVerbMode": "append"
+  "spinnerVerbMode": "append",
+  "messageStyle": "claude",
+  "assistantPrefix": "●",
+  "thinkingPrefix": "✻",
+  "messageSpacing": "comfortable",
+  "workingTipEnabled": true,
+  "workingTipText": "Run /install-github-app to tag @claude right from your GitHub issues and PRs",
+  "hiddenThinkingLabel": "Pondering..."
 }
 ```
 
@@ -100,6 +99,25 @@ The spinner glyph and verb text (e.g. `✻ Cooking…`) share `borderAccent` by
 
 Color selections are persisted as `spinnerColor` / `spinnerStatusColor` in `~/.pi/settings.json` and applied on the next spinner tick. Older `spinnerVerbColor` settings still work as a backward-compatible alias. Custom verbs are persisted as `spinnerVerbs` and `spinnerVerbMode`; they are picked at the next turn start. `/cc-spinner verbs ...` writes user settings in `~/.pi/settings.json`; project-level custom verbs can be set manually in `.pi/settings.json`. When both project and user spinner settings exist, the spinner reader applies project settings first and user settings second.
 
+#### Tune assistant/thinking transcript chrome with `/cc-message`
+
+```text
+/cc-message                              # show current message chrome settings
+/cc-message style claude                 # screenshot-style transcript rhythm
+/cc-message style classic                # older package spacing/prefix behavior
+/cc-message spacing comfortable          # keep one blank line between paragraphs
+/cc-message spacing compact              # remove blank lines inside assistant/thinking blocks
+/cc-message assistant-prefix ●           # set assistant paragraph prefix
+/cc-message thinking-prefix ✻            # set visible thinking prefix
+/cc-message hidden-thinking-label Pondering...
+/cc-message tip on                       # show active working tip line
+/cc-message tip off                      # hide active working tip line
+/cc-message tip text Run /help for tips   # set active working tip text
+/cc-message reset                        # restore message chrome defaults
+```
+
+`messageStyle: "claude"` trims leading/trailing blank render lines, collapses paragraph gaps, and aligns wrapped assistant/thinking lines under the message body, matching Claude Code's sparse transcript grammar. `messageStyle: "classic"` keeps the previous package behavior. The active working tip is rendered as a subordinate `└─ Tip:` line under the spinner when supported by the Pi loader.
+
 ### Tool background modes
 
 | Value | Behavior |

package/config/config.example.json

@@ -14,5 +14,12 @@
   "diffColors": {},
   "spinnerColor": "borderAccent",
   "spinnerVerbs": ["Reviewing", "Polishing"],
-  "spinnerVerbMode": "append"
+  "spinnerVerbMode": "append",
+  "messageStyle": "claude",
+  "assistantPrefix": "●",
+  "thinkingPrefix": "✻",
+  "messageSpacing": "comfortable",
+  "workingTipEnabled": true,
+  "workingTipText": "Run /install-github-app to tag @claude right from your GitHub issues and PRs",
+  "hiddenThinkingLabel": "Pondering..."
 }

package/extensions/index.ts

@@ -9,7 +9,7 @@ import type {
 	GrepToolDetails,
 	ReadToolDetails,
 	Theme,
-} from "@earendil-works/pi-coding-agent";
+} from "@mariozechner/pi-coding-agent";
 import {
 	AssistantMessageComponent,
 	CustomMessageComponent,
@@ -22,7 +22,7 @@ import {
 	createLsTool,
 	createReadTool,
 	createWriteTool,
-} from "@earendil-works/pi-coding-agent";
+} from "@mariozechner/pi-coding-agent";
 import {
 	Box,
 	Container,
@@ -36,11 +36,21 @@ import {
 	truncateToWidth,
 	visibleWidth,
 	wrapTextWithAnsi,
-} from "@earendil-works/pi-tui";
+} from "@mariozechner/pi-tui";
 
 import * as Diff from "diff";
 import type { BundledLanguage, BundledTheme } from "shiki";
 
+import {
+	DEFAULT_HIDDEN_THINKING_LABEL,
+	formatTranscriptLines,
+	resolveMessageChromeSettings,
+	sanitizeMessagePrefix,
+	type MessageChromeSettings,
+	type MessageSpacing,
+	type MessageStyle,
+} from "./message-chrome.ts";
+
 const RESET = "\x1b[0m";
 const TRANSPARENT_BG = "\x1b[49m";
 const TRANSPARENT_RESET = `${RESET}${TRANSPARENT_BG}`;
@@ -105,6 +115,20 @@ interface SettingsFile {
 	spinnerVerbs?: string[];
 	/** Whether custom spinnerVerbs append to or replace the default verb list. */
 	spinnerVerbMode?: SpinnerVerbMode;
+	/** Assistant/thinking transcript chrome style. "claude" trims spacing like Claude Code; "classic" keeps the older package rhythm. */
+	messageStyle?: MessageStyle;
+	/** Prefix glyph/text for assistant paragraphs. Defaults to Claude Code-style "●". */
+	assistantPrefix?: string;
+	/** Prefix glyph/text for visible thinking paragraphs. Defaults to "✻". */
+	thinkingPrefix?: string;
+	/** Blank-line normalization in assistant/thinking transcript blocks. */
+	messageSpacing?: MessageSpacing;
+	/** Whether the active working spinner may show a subordinate Claude-style tip line. */
+	workingTipEnabled?: boolean;
+	/** Custom subordinate tip line text for the active working spinner. */
+	workingTipText?: string;
+	/** Label shown when thinking blocks are hidden by the Pi UI. */
+	hiddenThinkingLabel?: string;
 }
 
 let _settingsCache: { value: SettingsFile; timestamp: number } | null = null;
@@ -144,7 +168,13 @@ function bustSpinnerSettingsCache(): void {
 	(globalThis as any)[SPINNER_BUST_KEY] = current + 1;
 }
 
+let _mergedSettingsCache: { value: SettingsFile; timestamp: number } | null = null;
+
 function readMergedSettings(): SettingsFile {
+	const now = Date.now();
+	if (_mergedSettingsCache && now - _mergedSettingsCache.timestamp < SETTINGS_CACHE_TTL_MS) {
+		return _mergedSettingsCache.value;
+	}
 	const paths = [`${process.cwd()}/.pi/settings.json`, `${process.env.HOME ?? ""}/.pi/settings.json`];
 	const merged: SettingsFile = {};
 	for (const path of paths) {
@@ -156,9 +186,20 @@ function readMergedSettings(): SettingsFile {
 			// ignore invalid settings files
 		}
 	}
+	_mergedSettingsCache = { value: merged, timestamp: now };
 	return merged;
 }
 
+function getMessageChromeSettings(): MessageChromeSettings {
+	return resolveMessageChromeSettings(readMergedSettings());
+}
+
+function applyHiddenThinkingLabel(ctx: any): void {
+	if (!ctx?.hasUI || typeof ctx.ui?.setHiddenThinkingLabel !== "function") return;
+	const label = getMessageChromeSettings().hiddenThinkingLabel;
+	ctx.ui.setHiddenThinkingLabel(label || DEFAULT_HIDDEN_THINKING_LABEL);
+}
+
 const MAX_CUSTOM_SPINNER_VERBS = 200;
 const MAX_SPINNER_VERB_LENGTH = 48;
 const ANSI_ESCAPE_SEQUENCE_RE = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
@@ -196,6 +237,7 @@ function getSpinnerVerbMode(settings: SettingsFile): SpinnerVerbMode {
 
 function writeSettingsKey(key: string, value: unknown): void {
 	_settingsCache = null; // invalidate cache on write
+	_mergedSettingsCache = null;
 	const home = process.env.HOME ?? "";
 	if (!home) return;
 	const dir = `${home}/.pi`;
@@ -474,9 +516,43 @@ function appendWorkedDurationLine(message: any, durationMs: number): void {
 	lastText.text = `${text.trimEnd()}\n\n${inlineWorkedDurationText(durationMs)}`;
 }
 
+function messageChromeCacheKey(settings: MessageChromeSettings, kind: "assistant" | "thinking"): string {
+	return [
+		settings.messageStyle,
+		settings.messageSpacing,
+		kind === "assistant" ? settings.assistantPrefix : settings.thinkingPrefix,
+	].join(":");
+}
+
+function renderClassicPrefixedLines(lines: string[], prefix: string, normalizeChecks = true): string[] {
+	let prefixPlaced = false;
+	return lines.map((line: string) => {
+		const displayLine = normalizeChecks ? normalizeLeadingCheckGlyph(line) : line;
+		if (!prefixPlaced && stripAnsi(displayLine).trim()) {
+			prefixPlaced = true;
+			return ` ${prefix} ${displayLine}`;
+		}
+		return `   ${displayLine}`;
+	});
+}
+
+function colorFirstTranscriptPrefix(lines: string[], prefixGlyph: string, coloredPrefixGlyph: string): string[] {
+	const plainPrefix = ` ${prefixGlyph} `;
+	const coloredPrefix = ` ${coloredPrefixGlyph} `;
+	let replaced = false;
+	return lines.map((line) => {
+		if (!replaced && line.startsWith(plainPrefix)) {
+			replaced = true;
+			return `${coloredPrefix}${line.slice(plainPrefix.length)}`;
+		}
+		return line;
+	});
+}
+
 class DottedParagraph {
 	private md: InstanceType<typeof Markdown>;
 	private cachedWidth?: number;
+	private cachedChromeKey?: string;
 	private cachedLines?: string[];
 
 	constructor(text: string, markdownTheme: ConstructorParameters<typeof Markdown>[3]) {
@@ -485,31 +561,35 @@ class DottedParagraph {
 
 	invalidate(): void {
 		this.cachedWidth = undefined;
+		this.cachedChromeKey = undefined;
 		this.cachedLines = undefined;
 		this.md.invalidate();
 	}
 
 	render(width: number): string[] {
-		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
-		// " ● " = 1 margin + dot + space = 3 visible chars
-		const PREFIX_W = 3;
-		if (width <= PREFIX_W) {
+		const settings = getMessageChromeSettings();
+		const chromeKey = messageChromeCacheKey(settings, "assistant");
+		if (this.cachedLines && this.cachedWidth === width && this.cachedChromeKey === chromeKey) return this.cachedLines;
+		const prefixGlyph = settings.messageStyle === "classic" ? "●" : settings.assistantPrefix;
+		const prefixWidth = Math.max(1, visibleWidth(` ${prefixGlyph} `));
+		if (width <= prefixWidth) {
 			this.cachedWidth = width;
-			this.cachedLines = [" ● "];
+			this.cachedChromeKey = chromeKey;
+			this.cachedLines = [` ${prefixGlyph} `];
 			return this.cachedLines;
 		}
-		const lines = sanitizeRenderedTextBlockLines(this.md.render(width - PREFIX_W));
+		const lines = sanitizeRenderedTextBlockLines(this.md.render(width - prefixWidth));
 		const looksLikeTaskStatus = lines.some((line) => /\b(?:transcript:|No output\.|Wrapped up)/.test(stripAnsi(line)));
-		const displayLines = looksLikeTaskStatus ? lines.map(normalizeLeadingCheckGlyph) : lines;
-		let dotPlaced = false;
-		const rendered = displayLines.map((line: string) => {
-			if (!dotPlaced && stripAnsi(line).trim()) {
-				dotPlaced = true;
-				return ` ● ${line}`;
-			}
-			return `   ${line}`;
-		});
+		const rendered = settings.messageStyle === "classic"
+			? renderClassicPrefixedLines(lines, "●", looksLikeTaskStatus)
+			: formatTranscriptLines(lines, {
+				prefix: settings.assistantPrefix,
+				spacing: settings.messageSpacing,
+				normalizeChecks: looksLikeTaskStatus,
+				visibleWidth,
+			});
 		this.cachedWidth = width;
+		this.cachedChromeKey = chromeKey;
 		this.cachedLines = rendered;
 		return rendered;
 	}
@@ -518,6 +598,7 @@ class DottedParagraph {
 class ThinkingParagraph {
 	private md: InstanceType<typeof Markdown>;
 	private cachedWidth?: number;
+	private cachedChromeKey?: string;
 	private cachedLines?: string[];
 
 	constructor(
@@ -559,30 +640,39 @@ class ThinkingParagraph {
 
 	invalidate(): void {
 		this.cachedWidth = undefined;
+		this.cachedChromeKey = undefined;
 		this.cachedLines = undefined;
 		this.md.invalidate();
 	}
 
 	render(width: number): string[] {
-		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
-		// " ✻ " = 1 margin + symbol + space = 3 visible chars
-		const PREFIX_W = 3;
-		const prefix = `${WORKED_LINE_FG}✻${RESET}`;
-		if (width <= PREFIX_W) {
+		const settings = getMessageChromeSettings();
+		const chromeKey = messageChromeCacheKey(settings, "thinking");
+		if (this.cachedLines && this.cachedWidth === width && this.cachedChromeKey === chromeKey) return this.cachedLines;
+		const prefixGlyph = settings.messageStyle === "classic" ? "✻" : settings.thinkingPrefix;
+		const coloredPrefixGlyph = `${WORKED_LINE_FG}${prefixGlyph}${RESET}`;
+		const prefixWidth = Math.max(1, visibleWidth(` ${prefixGlyph} `));
+		if (width <= prefixWidth) {
 			this.cachedWidth = width;
-			this.cachedLines = [` ${prefix} `];
+			this.cachedChromeKey = chromeKey;
+			this.cachedLines = [` ${coloredPrefixGlyph} `];
 			return this.cachedLines;
 		}
-		const lines = sanitizeRenderedTextBlockLines(this.md.render(width - PREFIX_W));
-		let symbolPlaced = false;
-		const rendered = lines.map((line: string) => {
-			if (!symbolPlaced && stripAnsi(line).trim()) {
-				symbolPlaced = true;
-				return ` ${prefix} ${line}`;
-			}
-			return `   ${line}`;
-		});
+		const lines = sanitizeRenderedTextBlockLines(this.md.render(width - prefixWidth));
+		const rendered = settings.messageStyle === "classic"
+			? renderClassicPrefixedLines(lines, coloredPrefixGlyph, false)
+			: colorFirstTranscriptPrefix(
+				formatTranscriptLines(lines, {
+					prefix: prefixGlyph,
+					spacing: settings.messageSpacing,
+					normalizeChecks: false,
+					visibleWidth,
+				}),
+				prefixGlyph,
+				coloredPrefixGlyph,
+			);
 		this.cachedWidth = width;
+		this.cachedChromeKey = chromeKey;
 		this.cachedLines = rendered;
 		return rendered;
 	}
@@ -2641,13 +2731,14 @@ function stripThinkingPresentationArtifacts(text: string): string {
 }
 
 function prefixThinkingLine(text: string, _theme: Theme | undefined): string {
-	if (!ANSI_PRESENT_RE.test(text) && text.startsWith("Thinking: ") && !/^Thinking:\s*thinking:\s*/i.test(text)) {
+	const settings = getMessageChromeSettings();
+	if (settings.messageStyle === "classic" && !ANSI_PRESENT_RE.test(text) && text.startsWith("Thinking: ") && !/^Thinking:\s*thinking:\s*/i.test(text)) {
 		return text;
 	}
 	const normalized = stripThinkingPresentationArtifacts(text).trim();
 	if (!normalized) return text;
 	// Plain text — no ANSI colors, no theme. The ThinkingParagraph handles styling.
-	return `Thinking: ${normalized}`;
+	return settings.messageStyle === "classic" ? `Thinking: ${normalized}` : normalized;
 }
 
 function registerThinkingLabels(pi: ExtensionAPI): void {
@@ -3920,16 +4011,167 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	const MESSAGE_COMMANDS = ["style", "spacing", "assistant-prefix", "thinking-prefix", "tip", "hidden-thinking-label", "reset", "status"] as const;
+	pi.registerCommand("cc-message", {
+		description: "Configure Claude-style assistant/thinking transcript chrome",
+		getArgumentCompletions(prefix: string) {
+			const parts = prefix.split(/\s+/);
+			if (parts.length <= 1) {
+				const first = (parts[0] ?? "").toLowerCase();
+				return MESSAGE_COMMANDS
+					.filter((c) => c.startsWith(first))
+					.map((c) => ({
+						value: c,
+						label: c,
+						description:
+							c === "style" ? "Set transcript style: claude or classic"
+							: c === "spacing" ? "Set blank-line rhythm: compact or comfortable"
+							: c === "assistant-prefix" ? "Set assistant paragraph prefix glyph/text"
+							: c === "thinking-prefix" ? "Set visible thinking prefix glyph/text"
+							: c === "tip" ? "Enable, disable, or customize active working tip line"
+							: c === "hidden-thinking-label" ? "Set label shown when thinking is hidden"
+							: c === "reset" ? "Reset message chrome settings"
+							: "Show current message chrome settings",
+					}));
+			}
+			if (parts[0] === "style") {
+				const valuePrefix = (parts[1] ?? "").toLowerCase();
+				return ["claude", "classic"]
+					.filter((v) => v.startsWith(valuePrefix))
+					.map((v) => ({ value: `style ${v}`, label: v, description: v === "claude" ? "Screenshot-style transcript rhythm" : "Older package spacing/prefix behavior" }));
+			}
+			if (parts[0] === "spacing") {
+				const valuePrefix = (parts[1] ?? "").toLowerCase();
+				return ["comfortable", "compact"]
+					.filter((v) => v.startsWith(valuePrefix))
+					.map((v) => ({ value: `spacing ${v}`, label: v, description: v === "comfortable" ? "Preserve one blank line between paragraphs" : "Remove blank lines inside assistant/thinking blocks" }));
+			}
+			if (parts[0] === "tip") {
+				const valuePrefix = (parts[1] ?? "").toLowerCase();
+				return ["on", "off", "text", "reset"]
+					.filter((v) => v.startsWith(valuePrefix))
+					.map((v) => ({ value: `tip ${v}`, label: v, description: v === "text" ? "Set custom active working tip text" : `${v} working tip line` }));
+			}
+			return [];
+		},
+		async handler(args: string, ctx: any) {
+			const rawArgs = args.trim();
+			const parts = rawArgs.split(/\s+/).filter((p: string) => p.length > 0);
+			const sub = (parts[0] ?? "status").toLowerCase();
+			const current = getMessageChromeSettings();
+			const notifyStatus = () => {
+				if (!ctx.hasUI) return;
+				ctx.ui.notify([
+					`Message style: ${current.messageStyle}`,
+					`Assistant prefix: ${current.assistantPrefix}`,
+					`Thinking prefix: ${current.thinkingPrefix}`,
+					`Spacing: ${current.messageSpacing}`,
+					`Working tip: ${current.workingTipEnabled ? "on" : "off"}`,
+					`Tip text: ${current.workingTipText}`,
+					`Hidden thinking label: ${current.hiddenThinkingLabel}`,
+				].join("\n"), "info");
+			};
+
+			if (!rawArgs || sub === "status") {
+				notifyStatus();
+				return;
+			}
+
+			if (sub === "reset") {
+				for (const key of ["messageStyle", "assistantPrefix", "thinkingPrefix", "messageSpacing", "workingTipEnabled", "workingTipText", "hiddenThinkingLabel"]) {
+					writeSettingsKey(key, undefined);
+				}
+				bustSpinnerSettingsCache();
+				applyHiddenThinkingLabel(ctx);
+				if (ctx.hasUI) ctx.ui.notify("Message chrome reset to Claude-style defaults", "info");
+				return;
+			}
+
+			if (sub === "style") {
+				const value = (parts[1] ?? "").toLowerCase();
+				if (value !== "claude" && value !== "classic") {
+					if (ctx.hasUI) ctx.ui.notify("Usage: /cc-message style claude|classic", "error");
+					return;
+				}
+				writeSettingsKey("messageStyle", value);
+				writeSettingsKey("workingTipEnabled", value === "classic" ? false : undefined);
+				bustSpinnerSettingsCache();
+				if (ctx.hasUI) ctx.ui.notify(`Message style → ${value}`, "info");
+				return;
+			}
+
+			if (sub === "spacing") {
+				const value = (parts[1] ?? "").toLowerCase();
+				if (value !== "compact" && value !== "comfortable") {
+					if (ctx.hasUI) ctx.ui.notify("Usage: /cc-message spacing compact|comfortable", "error");
+					return;
+				}
+				writeSettingsKey("messageSpacing", value);
+				if (ctx.hasUI) ctx.ui.notify(`Message spacing → ${value}`, "info");
+				return;
+			}
+
+			if (sub === "assistant-prefix" || sub === "thinking-prefix") {
+				const rawValue = rawArgs.replace(new RegExp(`^${sub}\\s*`, "i"), "");
+				const fallback = sub === "assistant-prefix" ? "●" : "✻";
+				const value = sanitizeMessagePrefix(rawValue, fallback);
+				writeSettingsKey(sub === "assistant-prefix" ? "assistantPrefix" : "thinkingPrefix", value);
+				if (ctx.hasUI) ctx.ui.notify(`${sub === "assistant-prefix" ? "Assistant" : "Thinking"} prefix → ${value}`, "info");
+				return;
+			}
+
+			if (sub === "tip") {
+				const action = (parts[1] ?? "").toLowerCase();
+				if (action === "on" || action === "off") {
+					writeSettingsKey("workingTipEnabled", action === "on");
+					bustSpinnerSettingsCache();
+					if (ctx.hasUI) ctx.ui.notify(`Working tip → ${action}`, "info");
+					return;
+				}
+				if (action === "reset") {
+					writeSettingsKey("workingTipEnabled", undefined);
+					writeSettingsKey("workingTipText", undefined);
+					bustSpinnerSettingsCache();
+					if (ctx.hasUI) ctx.ui.notify("Working tip reset", "info");
+					return;
+				}
+				if (action === "text") {
+					const textArg = rawArgs.match(/^tip\s+text(?:\s+(.+))?$/i)?.[1] ?? "";
+					const value = resolveMessageChromeSettings({ workingTipText: textArg }).workingTipText;
+					writeSettingsKey("workingTipText", value);
+					bustSpinnerSettingsCache();
+					if (ctx.hasUI) ctx.ui.notify(`Working tip text → ${value}`, "info");
+					return;
+				}
+				if (ctx.hasUI) ctx.ui.notify("Usage: /cc-message tip on|off|reset|text <text>", "error");
+				return;
+			}
+
+			if (sub === "hidden-thinking-label") {
+				const textArg = rawArgs.match(/^hidden-thinking-label(?:\s+(.+))?$/i)?.[1] ?? "";
+				const value = resolveMessageChromeSettings({ hiddenThinkingLabel: textArg }).hiddenThinkingLabel;
+				writeSettingsKey("hiddenThinkingLabel", value);
+				applyHiddenThinkingLabel(ctx);
+				if (ctx.hasUI) ctx.ui.notify(`Hidden thinking label → ${value}`, "info");
+				return;
+			}
+
+			if (ctx.hasUI) ctx.ui.notify("Usage: /cc-message style|spacing|assistant-prefix|thinking-prefix|tip|hidden-thinking-label|reset|status", "error");
+		},
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
 		if (!ctx.hasUI) return;
 		applyToolBackgroundMode(ctx.ui.theme);
 		applyThemePaletteIfNeeded(ctx.ui.theme);
+		applyHiddenThinkingLabel(ctx);
 	});
 
 	pi.on("turn_start", async (_event, ctx) => {
 		if (!ctx.hasUI) return;
 		applyToolBackgroundMode(ctx.ui.theme);
 		applyThemePaletteIfNeeded(ctx.ui.theme);
+		applyHiddenThinkingLabel(ctx);
 	});
 
 	const cwd = process.cwd();

package/extensions/message-chrome.ts

@@ -0,0 +1,142 @@
+export type MessageStyle = "classic" | "claude";
+export type MessageSpacing = "compact" | "comfortable";
+
+export interface MessageChromeInput {
+	messageStyle?: unknown;
+	assistantPrefix?: unknown;
+	thinkingPrefix?: unknown;
+	messageSpacing?: unknown;
+	workingTipEnabled?: unknown;
+	workingTipText?: unknown;
+	hiddenThinkingLabel?: unknown;
+}
+
+export interface MessageChromeSettings {
+	messageStyle: MessageStyle;
+	assistantPrefix: string;
+	thinkingPrefix: string;
+	messageSpacing: MessageSpacing;
+	workingTipEnabled: boolean;
+	workingTipText: string;
+	hiddenThinkingLabel: string;
+}
+
+export interface TranscriptLineOptions {
+	prefix: string;
+	spacing?: MessageSpacing;
+	normalizeChecks?: boolean;
+	visibleWidth?: (text: string) => number;
+}
+
+export const DEFAULT_WORKING_TIP_TEXT = "Run /install-github-app to tag @claude right from your GitHub issues and PRs";
+export const DEFAULT_HIDDEN_THINKING_LABEL = "Pondering...";
+
+const DEFAULT_MESSAGE_CHROME: MessageChromeSettings = {
+	messageStyle: "claude",
+	assistantPrefix: "●",
+	thinkingPrefix: "✻",
+	messageSpacing: "comfortable",
+	workingTipEnabled: true,
+	workingTipText: DEFAULT_WORKING_TIP_TEXT,
+	hiddenThinkingLabel: DEFAULT_HIDDEN_THINKING_LABEL,
+};
+
+const ANSI_ESCAPE_SEQUENCE_RE = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
+const ANSI_SGR_RE = /\x1b\[[0-9;]*m/g;
+const CONTROL_CHARS_RE = /[\u0000-\u001F\u007F-\u009F]/g;
+const MAX_PREFIX_GRAPHEMES = 8;
+const MAX_TIP_GRAPHEMES = 160;
+const MAX_LABEL_GRAPHEMES = 80;
+
+function stripAnsi(text: string): string {
+	return text.replace(ANSI_ESCAPE_SEQUENCE_RE, "").replace(ANSI_SGR_RE, "");
+}
+
+function stripControlChars(text: string): string {
+	return text.replace(CONTROL_CHARS_RE, "");
+}
+
+function takeGraphemes(text: string, max: number): string {
+	return Array.from(text).slice(0, max).join("");
+}
+
+function fallbackVisibleWidth(text: string): number {
+	return Array.from(stripAnsi(text)).length;
+}
+
+function isBlankLine(text: string): boolean {
+	return stripAnsi(text).trim().length === 0;
+}
+
+function sanitizeTextSetting(value: unknown, fallback: string, maxGraphemes: number): string {
+	if (typeof value !== "string") return fallback;
+	const cleaned = takeGraphemes(stripControlChars(stripAnsi(value)).trim(), maxGraphemes);
+	return cleaned || fallback;
+}
+
+export function sanitizeMessagePrefix(value: unknown, fallback: string): string {
+	return sanitizeTextSetting(value, fallback, MAX_PREFIX_GRAPHEMES);
+}
+
+export function resolveMessageChromeSettings(input: MessageChromeInput = {}): MessageChromeSettings {
+	const messageStyle: MessageStyle = input.messageStyle === "classic" ? "classic" : "claude";
+	const messageSpacing: MessageSpacing = input.messageSpacing === "compact" ? "compact" : "comfortable";
+	const defaultWorkingTipEnabled = messageStyle === "classic" ? false : DEFAULT_MESSAGE_CHROME.workingTipEnabled;
+	return {
+		messageStyle,
+		assistantPrefix: sanitizeMessagePrefix(input.assistantPrefix, DEFAULT_MESSAGE_CHROME.assistantPrefix),
+		thinkingPrefix: sanitizeMessagePrefix(input.thinkingPrefix, DEFAULT_MESSAGE_CHROME.thinkingPrefix),
+		messageSpacing,
+		workingTipEnabled: typeof input.workingTipEnabled === "boolean" ? input.workingTipEnabled : defaultWorkingTipEnabled,
+		workingTipText: sanitizeTextSetting(input.workingTipText, DEFAULT_MESSAGE_CHROME.workingTipText, MAX_TIP_GRAPHEMES),
+		hiddenThinkingLabel: sanitizeTextSetting(input.hiddenThinkingLabel, DEFAULT_MESSAGE_CHROME.hiddenThinkingLabel, MAX_LABEL_GRAPHEMES),
+	};
+}
+
+function normalizeTranscriptRenderedLines(lines: string[], spacing: MessageSpacing): string[] {
+	let start = 0;
+	while (start < lines.length && isBlankLine(lines[start])) start++;
+	let end = lines.length - 1;
+	while (end >= start && isBlankLine(lines[end])) end--;
+	if (start > end) return [];
+
+	const normalized: string[] = [];
+	let pendingBlank = false;
+	for (const line of lines.slice(start, end + 1)) {
+		if (isBlankLine(line)) {
+			if (spacing === "comfortable" && normalized.length > 0) pendingBlank = true;
+			continue;
+		}
+		if (pendingBlank) {
+			normalized.push("");
+			pendingBlank = false;
+		}
+		normalized.push(line);
+	}
+	return normalized;
+}
+
+function normalizeLeadingCheckGlyph(line: string): string {
+	return line.replace(/^((?:\x1b\[[0-9;]*m|[ \t])*)[✓✔](?=\s)/, "$1●");
+}
+
+export function formatTranscriptLines(lines: string[], options: TranscriptLineOptions): string[] {
+	const prefixGlyph = sanitizeMessagePrefix(options.prefix, DEFAULT_MESSAGE_CHROME.assistantPrefix);
+	const spacing = options.spacing ?? DEFAULT_MESSAGE_CHROME.messageSpacing;
+	const normalized = normalizeTranscriptRenderedLines(lines, spacing);
+	const prefix = ` ${prefixGlyph} `;
+	const measureWidth = options.visibleWidth ?? fallbackVisibleWidth;
+	const continuation = " ".repeat(Math.max(1, measureWidth(prefix)));
+
+	if (normalized.length === 0) return [prefix];
+
+	let prefixPlaced = false;
+	return normalized.map((line) => {
+		const displayLine = options.normalizeChecks === false ? line : normalizeLeadingCheckGlyph(line);
+		if (!prefixPlaced && !isBlankLine(displayLine)) {
+			prefixPlaced = true;
+			return `${prefix}${displayLine}`;
+		}
+		return `${continuation}${displayLine}`;
+	});
+}

package/extensions/spinner.ts

@@ -1,7 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Loader } from "@earendil-works/pi-tui";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Loader } from "@mariozechner/pi-tui";
+
+import { resolveMessageChromeSettings } from "./message-chrome.ts";
 
 // ---------------------------------------------------------------------------
 // Patch built-in Loader with Claude/OpenBrawd-style glyphs.
@@ -26,6 +28,8 @@ interface SpinnerSettings {
 	verbColor: string;
 	statusColor: string;
 	verbs: readonly string[];
+	workingTipEnabled: boolean;
+	workingTipText: string;
 }
 
 let _spinnerSettingsCache: { value: SpinnerSettings; expires: number } | null = null;
@@ -96,6 +100,9 @@ function readSpinnerSettings(): SpinnerSettings {
 	let statusColor = "muted";
 	let customVerbs: string[] | null = null;
 	let verbMode: SpinnerVerbMode = "append";
+	let messageStyle: string | undefined;
+	let workingTipEnabled: boolean | undefined;
+	let workingTipText: string | undefined;
 	const paths = [`${process.cwd()}/.pi/settings.json`, `${process.env.HOME ?? ""}/.pi/settings.json`];
 	for (const p of paths) {
 		try {
@@ -108,10 +115,21 @@ function readSpinnerSettings(): SpinnerSettings {
 				if (typeof raw.spinnerStatusColor === "string" && raw.spinnerStatusColor.length > 0) statusColor = raw.spinnerStatusColor;
 				if (raw.spinnerVerbMode === "append" || raw.spinnerVerbMode === "replace") verbMode = raw.spinnerVerbMode;
 				if (Array.isArray(raw.spinnerVerbs)) customVerbs = sanitizeSpinnerVerbs(raw.spinnerVerbs);
+				if (typeof raw.messageStyle === "string") messageStyle = raw.messageStyle;
+				if (typeof raw.workingTipEnabled === "boolean") workingTipEnabled = raw.workingTipEnabled;
+				if (typeof raw.workingTipText === "string") workingTipText = raw.workingTipText;
 			}
 		} catch { /* ignore */ }
 	}
-	const value: SpinnerSettings = { adaptive, verbColor, statusColor, verbs: resolveSpinnerVerbs(customVerbs, verbMode) };
+	const messageChrome = resolveMessageChromeSettings({ messageStyle, workingTipEnabled, workingTipText });
+	const value: SpinnerSettings = {
+		adaptive,
+		verbColor,
+		statusColor,
+		verbs: resolveSpinnerVerbs(customVerbs, verbMode),
+		workingTipEnabled: messageChrome.workingTipEnabled,
+		workingTipText: messageChrome.workingTipText,
+	};
 	_spinnerSettingsCache = { value, expires: now + SPINNER_SETTINGS_TTL_MS };
 	return value;
 }
@@ -549,6 +567,10 @@ export default function (pi: ExtensionAPI) {
 		if (statusParts.length > 0) {
 			message += statusText(` (${statusParts.join(" · ")})`);
 		}
+		const { workingTipEnabled, workingTipText } = readSpinnerSettings();
+		if (workingTipEnabled && workingTipText) {
+			message += `\n${STATUS_DIM}  └─ Tip: ${workingTipText}${RESET}`;
+		}
 		return message;
 	}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlburtoe/pi-cc-tools",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Claude Code-style tool rows for pi with Ctrl+O image previews and consistent built-in, MCP, and custom tool rendering",
   "keywords": [
     "pi-package",
@@ -14,7 +14,7 @@
     "diff"
   ],
   "license": "MIT",
-  "author": "owlburtoe",
+  "author": "FammasMaz",
   "repository": {
     "type": "git",
     "url": "git+https://forgejo.owlburtoe.dev/owlburtoe/pi-claude-style-tools.git"
@@ -26,19 +26,22 @@
   "files": [
     "extensions/index.ts",
     "extensions/spinner.ts",
+    "extensions/message-chrome.ts",
     "config/config.example.json",
     "README.md"
   ],
   "scripts": {
-    "bench:tools": "bun scripts/benchmark-tools.ts"
+    "bench:tools": "bun scripts/benchmark-tools.ts",
+    "test:message-chrome": "bun scripts/test-message-chrome.ts"
   },
   "dependencies": {
     "@shikijs/cli": "^4.0.2",
     "diff": "^7.0.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
   },
   "pi": {
     "extensions": [
@@ -47,10 +50,11 @@
     ]
   },
   "devDependencies": {
+    "@mariozechner/pi-coding-agent": "latest",
+    "@mariozechner/pi-tui": "latest",
+    "@sinclair/typebox": "latest",
     "@types/diff": "^7.0.2",
     "@types/node": "^25.6.0",
-    "typescript": "^6.0.2",
-    "@earendil-works/pi-coding-agent": "latest",
-    "@earendil-works/pi-tui": "latest"
+    "typescript": "^6.0.2"
   }
 }