@owlburtoe/pi-cc-tools 1.1.1 → 1.1.6

package/README.md

@@ -4,15 +4,16 @@ Claude Code inspired tool rendering for Pi — Shiki-powered diffs, status dots,
 
 ## Features
 
-- **Compact built-in tool rendering** for `read`, `bash`, `grep`, `find`, `ls`, `edit`, and `write`
+- **Compact Claude Code-like tool rendering** for `read`, `bash`, `grep`, `find`, `ls`, `edit`, and `write`, including `⏺ Tool(args)` headers and `⎿` result rows
 - **Semantic bash display** that renders common read-only shell one-liners like `nl -ba file | sed -n '1,200p'` as Claude Code-style `Read file (lines 1-200)` rows
+- **Read-only inspection grouping** that collapses consecutive `read`/`grep`/`find`/`ls` rows into one Claude-style `Inspect` block, capped to five visible entries by default
 - **Claude-style OpenAI tool rendering** for `apply_patch` plus common Pi/OpenAI-style tools like `webfetch`, `web_search`, `fetch_content`, task tools, and context tools
 - **`apply_patch` diff previews** that render parsed file patches in the call phase, similar to `edit`/`write`
 - **Adaptive edit/write diffs** with split or unified layouts, syntax highlighting, and inline word-level emphasis
 - **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
+- **Claude-style transcript grammar controls** for assistant/thinking prefixes, message spacing, and hidden thinking labels
 - **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
@@ -26,7 +27,7 @@ Set in `.pi/settings.json` or `~/.pi/settings.json`:
 
 ```json
 {
-  "toolBackground": "border",
+  "toolBackground": "transparent",
   "readOutputMode": "preview",
   "searchOutputMode": "preview",
   "mcpOutputMode": "preview",
@@ -35,6 +36,8 @@ Set in `.pi/settings.json` or `~/.pi/settings.json`:
   "bashCollapsedLines": 10,
   "bashStackConsecutive": true,
   "bashSemanticDisplay": true,
+  "readOnlyToolGrouping": true,
+  "readOnlyToolGroupLimit": 5,
   "diffCollapsedLines": 24,
   "themeAdaptive": true,
   "diffTheme": "github-dark",
@@ -45,8 +48,6 @@ Set in `.pi/settings.json` or `~/.pi/settings.json`:
   "assistantPrefix": "●",
   "thinkingPrefix": "✻",
   "messageSpacing": "comfortable",
-  "workingTipEnabled": true,
-  "workingTipText": "Run /install-github-app to tag @claude right from your GitHub issues and PRs",
   "hiddenThinkingLabel": "Pondering..."
 }
 ```
@@ -113,13 +114,10 @@ Color selections are persisted as `spinnerColor` / `spinnerStatusColor` in `~/.p
 /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.
+`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.
 
 ### Tool background modes
 
@@ -127,7 +125,8 @@ Color selections are persisted as `spinnerColor` / `spinnerStatusColor` in `~/.p
 |-------|----------|
 | `default` | Standard Pi tool backgrounds |
 | `transparent` | Transparent tool backgrounds |
-| `border` | Transparent backgrounds with top/bottom border lines |
+| `border` | Transparent backgrounds with top/bottom border lines (alias for `outlines`) |
+| `outlines` | Transparent backgrounds with top/bottom border lines |
 
 ### Output modes
 
@@ -152,6 +151,7 @@ Color selections are persisted as `spinnerColor` / `spinnerStatusColor` in `~/.p
 |---------|---------|-------------|
 | `bashStackConsecutive` | `true` | Remove the extra synthetic spacer between adjacent bash tool rows so command bursts render as a tight stack |
 | `bashSemanticDisplay` | `true` | Render common read-only shell file-inspection commands as semantic `Read` rows instead of raw `Bash` rows |
+| `readOnlyToolGrouping` | `true` | Collapse adjacent read-only inspection tools into one `Inspect` block; mutating `write`/`edit`/`apply_patch` rows stay independent |
 
 ### Numeric settings
 
@@ -161,6 +161,7 @@ Color selections are persisted as `spinnerColor` / `spinnerStatusColor` in `~/.p
 | `expandedPreviewMaxLines` | `4000` | Max lines when fully expanded |
 | `bashCollapsedLines` | `10` | Lines for collapsed bash output |
 | `diffCollapsedLines` | `24` | Diff lines before collapsing |
+| `readOnlyToolGroupLimit` | `5` | Max inspection entries shown inside a grouped read-only tool block |
 
 ## Notes
 

package/config/config.example.json

@@ -9,6 +9,8 @@
   "bashCollapsedLines": 10,
   "bashStackConsecutive": true,
   "bashSemanticDisplay": true,
+  "readOnlyToolGrouping": true,
+  "readOnlyToolGroupLimit": 5,
   "diffCollapsedLines": 24,
   "showTruncationHints": false,
   "themeAdaptive": true,
@@ -21,7 +23,5 @@
   "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

@@ -71,7 +71,12 @@ const WRAP_MARK = "\uE000";
 const KITTY_IMAGE_PREFIX = "\x1b_G";
 const ITERM2_IMAGE_PREFIX = "\x1b]1337;File=";
 
-let toolBackgroundMode: "default" | "transparent" | "outlines" = "outlines";
+let toolBackgroundMode: "default" | "transparent" | "outlines" = "transparent";
+
+const CLAUDE_TOOL_GLYPH = "⏺";
+const CLAUDE_RESULT_GLYPH = "⎿";
+const CLAUDE_RESULT_PREFIX = `  ${CLAUDE_RESULT_GLYPH}  `;
+const CLAUDE_RESULT_CONTINUATION = " ".repeat(CLAUDE_RESULT_PREFIX.length);
 
 type SpinnerVerbMode = "append" | "replace";
 
@@ -88,6 +93,8 @@ interface SettingsFile {
 	bashStackConsecutive?: boolean;
 	/** When true (default), read-only shell file-inspection one-liners render as semantic Read rows instead of raw Bash rows. */
 	bashSemanticDisplay?: boolean;
+	readOnlyToolGrouping?: boolean;
+	readOnlyToolGroupLimit?: number;
 	showTruncationHints?: boolean;
 	diffCollapsedLines?: number;
 	diffTheme?: string;
@@ -127,10 +134,6 @@ interface SettingsFile {
 	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;
 }
@@ -271,7 +274,7 @@ function syncToolBackgroundMode(): void {
 	const settings = readSettings();
 	// Backward compat: "border" was renamed to "outlines"
 	const raw = settings.toolBackground === "border" ? "outlines" : settings.toolBackground;
-	toolBackgroundMode = raw ?? "outlines";
+	toolBackgroundMode = raw ?? "transparent";
 }
 
 function setThemeBg(theme: unknown, key: string, value: string): void {
@@ -341,6 +344,253 @@ function shouldStackConsecutiveBash(): boolean {
 	return readSettings().bashStackConsecutive !== false;
 }
 
+function readOnlyToolGroupingEnabled(): boolean {
+	return readSettings().readOnlyToolGrouping !== false;
+}
+
+function readOnlyToolGroupLimit(): number {
+	const value = readSettings().readOnlyToolGroupLimit;
+	return typeof value === "number" && Number.isFinite(value) && value > 0
+		? Math.max(1, Math.min(20, Math.floor(value)))
+		: 5;
+}
+
+function toolComponentRecord(value: unknown): Record<string, any> {
+	return value as Record<string, any>;
+}
+
+function componentCwd(value: unknown): string {
+	const cwd = toolComponentRecord(value).cwd;
+	return typeof cwd === "string" && cwd ? cwd : process.cwd();
+}
+
+function componentTextContent(value: unknown): string {
+	return getTextContent(toolComponentRecord(value).result);
+}
+
+function componentHasImageResult(value: unknown): boolean {
+	return !!getFirstImageBlock(toolComponentRecord(value).result);
+}
+
+function bashReadDisplayInfo(value: unknown): BashDisplayInfo | null {
+	const rec = toolComponentRecord(value);
+	if (rec.toolName !== "bash" || !bashSemanticDisplayEnabled()) return null;
+	return classifyBashCommandForDisplay(rec.args?.command ?? "");
+}
+
+function isReadOnlyInspectionToolExecution(value: unknown): boolean {
+	if (!readOnlyToolGroupingEnabled() || !isToolExecutionLike(value)) return false;
+	const rec = toolComponentRecord(value);
+	if (rec.expanded === true || componentHasImageResult(value)) return false;
+	if (rec.toolName === "read" || rec.toolName === "grep" || rec.toolName === "find" || rec.toolName === "ls") return true;
+	return !!bashReadDisplayInfo(value);
+}
+
+function hasConsecutiveReadOnlyInspectionToolChildren(children: unknown[]): boolean {
+	let previousWasInspect = false;
+	for (const child of children) {
+		const currentIsInspect = isReadOnlyInspectionToolExecution(child);
+		if (currentIsInspect && previousWasInspect) return true;
+		previousWasInspect = currentIsInspect;
+	}
+	return false;
+}
+
+function plural(count: number, noun: string): string {
+	if (count === 1) return `1 ${noun}`;
+	const suffix = /(?:s|x|z|ch|sh)$/i.test(noun) ? "es" : "s";
+	return `${count} ${noun}${suffix}`;
+}
+
+function textDataLines(text: string): string[] {
+	return text.split("\n").filter((line) => line.trim().length > 0 && !line.trimStart().startsWith("["));
+}
+
+function compactList(values: string[], limit: number): string {
+	if (values.length === 0) return "";
+	const shown = values.slice(0, limit);
+	const suffix = values.length > shown.length ? `, … +${values.length - shown.length}` : "";
+	return `${shown.join(", ")}${suffix}`;
+}
+
+function uniqueLeadingGrepFiles(text: string, limit: number): string[] {
+	const seen = new Set<string>();
+	const files: string[] = [];
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("[")) continue;
+		const match = /^(.+?)(?::\d+:|-\d+-)/.exec(line);
+		if (!match) continue;
+		const file = match[1];
+		if (seen.has(file)) continue;
+		seen.add(file);
+		files.push(file);
+		if (files.length >= limit + 1) break;
+	}
+	return files;
+}
+
+function formatOffsetLimit(args: any): string {
+	const parts: string[] = [];
+	if (args?.offset !== undefined && args?.offset !== null) parts.push(`offset=${args.offset}`);
+	if (args?.limit !== undefined && args?.limit !== null) parts.push(`limit=${args.limit}`);
+	return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
+
+function readInspectionTarget(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	return `${shortPath(componentCwd(value), rec.args?.path ?? "")}${formatOffsetLimit(rec.args)}`;
+}
+
+function grepInspectionTarget(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	const pattern = summarizeText(rec.args?.pattern ?? "", 40);
+	const path = rec.args?.path ? ` in ${shortPath(componentCwd(value), rec.args.path)}` : "";
+	return `"${pattern}"${path}`;
+}
+
+function findInspectionTarget(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	const pattern = summarizeText(rec.args?.pattern ?? "", 40);
+	const path = rec.args?.path ? ` in ${shortPath(componentCwd(value), rec.args.path)}` : "";
+	return `"${pattern}"${path}`;
+}
+
+function listInspectionTarget(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	return shortPath(componentCwd(value), rec.args?.path ?? ".");
+}
+
+function readInspectionStatus(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	if (!rec.result) return "Reading...";
+	if (rec.result?.isError) return "failed";
+	const text = componentTextContent(value);
+	const lines = text.length === 0 ? 0 : text.split("\n").length;
+	const suffix = rec.result?.details?.truncation?.truncated ? " (truncated)" : "";
+	return `${plural(lines, "line")} loaded${suffix}`;
+}
+
+function grepInspectionStatus(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	if (!rec.result) return "Searching...";
+	if (rec.result?.isError) return "failed";
+	const text = componentTextContent(value).trim();
+	if (!text || /^No matches found\b/i.test(text)) return "no matches";
+	const lines = textDataLines(text);
+	let status = plural(lines.length, "match");
+	const files = uniqueLeadingGrepFiles(text, readOnlyToolGroupLimit());
+	if (files.length > 1) status += ` in ${compactList(files, readOnlyToolGroupLimit())}`;
+	if (rec.result?.details?.truncation?.truncated) status += " (truncated)";
+	return status;
+}
+
+function findInspectionStatus(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	if (!rec.result) return "Finding...";
+	if (rec.result?.isError) return "failed";
+	const text = componentTextContent(value).trim();
+	if (!text || /^No files found\b/i.test(text)) return "no files";
+	const items = textDataLines(text);
+	let status = plural(items.length, "file");
+	if (items.length > 0) status += `: ${compactList(items, readOnlyToolGroupLimit())}`;
+	if (rec.result?.details?.truncation?.truncated) status += " (truncated)";
+	return status;
+}
+
+function listInspectionStatus(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	if (!rec.result) return "Listing...";
+	if (rec.result?.isError) return "failed";
+	const text = componentTextContent(value).trim();
+	if (!text || /^empty directory\b/i.test(text)) return "empty directory";
+	const items = textDataLines(text);
+	let status = plural(items.length, "entry");
+	if (items.length > 0) status += `: ${compactList(items, readOnlyToolGroupLimit())}`;
+	return status;
+}
+
+function bashReadInspectionTarget(value: unknown): string {
+	const info = bashReadDisplayInfo(value);
+	if (!info) return "";
+	const range = info.rangeLabel ? ` (${info.rangeLabel})` : "";
+	return `${shortPath(componentCwd(value), info.path)}${range}`;
+}
+
+function bashReadInspectionStatus(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	if (!rec.result) return "Reading...";
+	if (rec.result?.isError) return "failed";
+	const count = componentTextContent(value).split("\n").filter((line) => line.trim().length > 0).length;
+	return `${plural(count, "line")} read`;
+}
+
+function summarizeReadOnlyInspectionTool(value: unknown): string {
+	const rec = toolComponentRecord(value);
+	if (rec.toolName === "read") return `Read ${readInspectionTarget(value)} — ${readInspectionStatus(value)}`;
+	if (rec.toolName === "grep") return `Grep ${grepInspectionTarget(value)} — ${grepInspectionStatus(value)}`;
+	if (rec.toolName === "find") return `Find ${findInspectionTarget(value)} — ${findInspectionStatus(value)}`;
+	if (rec.toolName === "ls") return `List ${listInspectionTarget(value)} — ${listInspectionStatus(value)}`;
+	return `Read ${bashReadInspectionTarget(value)} — ${bashReadInspectionStatus(value)}`;
+}
+
+function renderInspectionGroup(group: unknown[], width: number): string[] {
+	syncToolBackgroundMode();
+	const limit = readOnlyToolGroupLimit();
+	const shown = group.slice(0, limit);
+	const remaining = group.length - shown.length;
+	const core: string[] = [` ${WRAP_MARK}${CLAUDE_TOOL_GLYPH} Inspect(${plural(group.length, "tool use")})`];
+	for (let index = 0; index < shown.length; index++) {
+		const prefix = index === 0 ? `${TOOL_RULE}${CLAUDE_RESULT_PREFIX}${TRANSPARENT_RESET}` : CLAUDE_RESULT_CONTINUATION;
+		core.push(`${prefix}${WRAP_MARK}${summarizeReadOnlyInspectionTool(shown[index])}`);
+	}
+	if (remaining > 0) {
+		const prefix = shown.length === 0 ? `${TOOL_RULE}${CLAUDE_RESULT_PREFIX}${TRANSPARENT_RESET}` : CLAUDE_RESULT_CONTINUATION;
+		core.push(`${prefix}${WRAP_MARK}… ${remaining} more inspection${remaining === 1 ? "" : "s"}`);
+	}
+	const renderedCore = core.flatMap((line) => wrapMarkedLine(line, width)).map((line) => padToWidth(line, width));
+	if (toolBackgroundMode === "outlines") return [" ".repeat(width), borderLine(width), ...renderedCore, borderLine(width)];
+	if (toolBackgroundMode === "transparent") return [" ".repeat(width), ...renderedCore];
+	return renderedCore;
+}
+
+function renderWithGroupedReadOnlyInspectionTools(container: any, width: number): string[] | null {
+	const children = Array.isArray(container?.children) ? container.children : null;
+	if (!children || !hasConsecutiveReadOnlyInspectionToolChildren(children)) return null;
+
+	const rendered: string[] = [];
+	let group: unknown[] = [];
+	let previousWasBash = false;
+	const flushGroup = () => {
+		if (group.length === 0) return;
+		if (group.length === 1) {
+			const child = group[0] as any;
+			const currentIsBash = isBashToolExecution(child);
+			const childLines = typeof child?.render === "function" ? child.render(width) : [];
+			rendered.push(...(currentIsBash && previousWasBash ? dropLeadingSpacerLine(childLines) : childLines));
+			previousWasBash = currentIsBash;
+		} else {
+			rendered.push(...renderInspectionGroup(group, width));
+			previousWasBash = false;
+		}
+		group = [];
+	};
+
+	for (const child of children) {
+		if (isReadOnlyInspectionToolExecution(child)) {
+			group.push(child);
+			continue;
+		}
+		flushGroup();
+		const currentIsBash = isBashToolExecution(child);
+		const childLines = typeof child?.render === "function" ? child.render(width) : [];
+		rendered.push(...(currentIsBash && previousWasBash ? dropLeadingSpacerLine(childLines) : childLines));
+		previousWasBash = currentIsBash;
+	}
+	flushGroup();
+	return rendered;
+}
+
 function hasConsecutiveBashToolChildren(children: unknown[]): boolean {
 	let previousWasBash = false;
 	for (const child of children) {
@@ -402,6 +652,8 @@ function patchGlobalToolBorders(): void {
 	const originalRender = proto.render;
 	proto.render = function patchedContainerRender(width: number): string[] {
 		if (!isToolExecutionLike(this)) {
+			const grouped = renderWithGroupedReadOnlyInspectionTools(this, width);
+			if (grouped) return grouped;
 			const stacked = renderWithStackedConsecutiveBash(this, width);
 			if (stacked) return stacked;
 		}
@@ -1000,7 +1252,7 @@ function toolHeader(tool: string, summary: string, theme: Theme, prefix = ""): s
 	applyThemePaletteIfNeeded(theme);
 	const label = theme.fg("toolTitle", theme.bold(tool));
 	if (!summary) return `${prefix}${label}`;
-	return `${prefix}${label} ${WRAP_MARK}${theme.fg("accent", summary)}`;
+	return `${prefix}${label}${theme.fg("muted", "(")}${WRAP_MARK}${theme.fg("accent", summary)}${theme.fg("muted", ")")}`;
 }
 
 function setToolStatus(ctx: any, status: "pending" | "success" | "error"): void {
@@ -1064,8 +1316,8 @@ function getWriteWasNewFile(ctx: any, cwd: string, filePath: string, reveal = sh
 
 function toolStatusDot(ctx: any, theme: Theme): string {
 	const status = ctx.state?._toolStatus as "pending" | "success" | "error" | undefined;
-	if (status === "success") return `${theme.fg("success", "●")} `;
-	if (status === "error") return `${theme.fg("error", "●")} `;
+	if (status === "error") return `${theme.fg("error", CLAUDE_TOOL_GLYPH)} `;
+	if (status === "success") return `${theme.fg("accent", CLAUDE_TOOL_GLYPH)} `;
 	return `${blinkDot(ctx, theme)} `;
 }
 
@@ -1073,13 +1325,12 @@ function toolStatusDot(ctx: any, theme: Theme): string {
 // Branch connector — visual tree from header to output
 // ---------------------------------------------------------------------------
 
-function branchIndent(text: string, continued = false): string {
-	const prefix = continued ? `${TOOL_RULE}│${TRANSPARENT_RESET}  ` : "   ";
-	return `${prefix}${WRAP_MARK}${text}`;
+function branchIndent(text: string, _continued = false): string {
+	return `${CLAUDE_RESULT_CONTINUATION}${WRAP_MARK}${text}`;
 }
 
-function branchLead(text: string, continued = false): string {
-	return `${TOOL_RULE}${continued ? "├─" : "└─"}${TRANSPARENT_RESET} ${WRAP_MARK}${text}`;
+function branchLead(text: string, _continued = false): string {
+	return `${TOOL_RULE}${CLAUDE_RESULT_PREFIX}${TRANSPARENT_RESET}${WRAP_MARK}${text}`;
 }
 
 function withBranch(content: string, _theme: Theme, _isError = false, continued = false): string {
@@ -1092,20 +1343,11 @@ function withBranch(content: string, _theme: Theme, _isError = false, continued
 }
 
 function withFinalBranchBlock(content: string, theme: Theme, isError = false): string {
-	if (!content || !content.trim()) return "";
-	const lines = content.split("\n");
-	const first = lines[0] ?? "";
-	if (lines.length === 1) return branchLead(first, false);
-	const middle = lines.slice(1, -1).map((line) => branchIndent(line, true));
-	const last = lines[lines.length - 1] ?? "";
-	return [branchLead(first, true), ...middle, branchLead(last, false)].join("\n");
+	return withBranch(content, theme, isError);
 }
 
 function indentBranchBlock(block: string): string {
-	return block
-		.split("\n")
-		.map((line) => (line ? ` ${line}` : line))
-		.join("\n");
+	return block;
 }
 
 // ---------------------------------------------------------------------------
@@ -1207,8 +1449,8 @@ function clearBlinkTimer(ctx: any): void {
 function blinkDot(ctx: any, theme: Theme): string {
 	setupBlinkTimer(ctx);
 	const key = getBlinkKey(ctx);
-	if (key?._blinkActive !== true) return theme.fg("muted", "○");
-	return _globalBlinkPhase ? theme.fg("success", "●") : theme.fg("muted", "○");
+	if (key?._blinkActive !== true) return theme.fg("muted", CLAUDE_TOOL_GLYPH);
+	return _globalBlinkPhase ? theme.fg("accent", CLAUDE_TOOL_GLYPH) : theme.fg("muted", CLAUDE_TOOL_GLYPH);
 }
 
 // ---------------------------------------------------------------------------
@@ -1294,6 +1536,8 @@ function markedContinuationPrefix(prefix: string): string {
 	if (branchMatch) {
 		return `${branchMatch[1]}${TOOL_RULE}│${TRANSPARENT_RESET}  `;
 	}
+	const resultMatch = /^(\s*)⎿\s+/.exec(plain);
+	if (resultMatch) return " ".repeat(visibleWidth(prefix));
 	return " ".repeat(visibleWidth(prefix));
 }
 
@@ -4247,7 +4491,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	const MESSAGE_COMMANDS = ["style", "spacing", "assistant-prefix", "thinking-prefix", "tip", "hidden-thinking-label", "reset", "status"] as const;
+	const MESSAGE_COMMANDS = ["style", "spacing", "assistant-prefix", "thinking-prefix", "hidden-thinking-label", "reset", "status"] as const;
 	pi.registerCommand("cc-message", {
 		description: "Configure Claude-style assistant/thinking transcript chrome",
 		getArgumentCompletions(prefix: string) {
@@ -4264,7 +4508,6 @@ export default function (pi: ExtensionAPI) {
 							: 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",
@@ -4282,12 +4525,6 @@ export default function (pi: ExtensionAPI) {
 					.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) {
@@ -4302,8 +4539,6 @@ export default function (pi: ExtensionAPI) {
 					`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");
 			};
@@ -4314,7 +4549,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			if (sub === "reset") {
-				for (const key of ["messageStyle", "assistantPrefix", "thinkingPrefix", "messageSpacing", "workingTipEnabled", "workingTipText", "hiddenThinkingLabel"]) {
+				for (const key of ["messageStyle", "assistantPrefix", "thinkingPrefix", "messageSpacing", "hiddenThinkingLabel"]) {
 					writeSettingsKey(key, undefined);
 				}
 				bustSpinnerSettingsCache();
@@ -4330,8 +4565,6 @@ export default function (pi: ExtensionAPI) {
 					return;
 				}
 				writeSettingsKey("messageStyle", value);
-				writeSettingsKey("workingTipEnabled", value === "classic" ? false : undefined);
-				bustSpinnerSettingsCache();
 				if (ctx.hasUI) ctx.ui.notify(`Message style → ${value}`, "info");
 				return;
 			}
@@ -4356,33 +4589,6 @@ export default function (pi: ExtensionAPI) {
 				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;
@@ -4392,7 +4598,7 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			if (ctx.hasUI) ctx.ui.notify("Usage: /cc-message style|spacing|assistant-prefix|thinking-prefix|tip|hidden-thinking-label|reset|status", "error");
+			if (ctx.hasUI) ctx.ui.notify("Usage: /cc-message style|spacing|assistant-prefix|thinking-prefix|hidden-thinking-label|reset|status", "error");
 		},
 	});
 
@@ -4815,7 +5021,7 @@ export default function (pi: ExtensionAPI) {
 			const revealSummary = shouldRevealCallArgs(ctx) || (!!fp && hasOwnArg(args, "edits"));
 			const summary = stableCallSummary(ctx, "_callSummary", () => shouldRevealCallArgs(ctx) && operations.length > 1 ? `${sp(fp)} ${theme.fg("muted", `(${operations.length} edits)`)}` : sp(fp), revealSummary);
 			syncToolCallStatus(ctx);
-			const hdr = toolHeader("Edit", summary, theme, ` ${toolStatusDot(ctx, theme)}`);
+			const hdr = toolHeader("Edit", summary, theme, toolStatusDot(ctx, theme));
 			if (!(ctx.argsComplete && operations.length > 0)) return makeText(ctx.lastComponent, hdr);
 			const diffWidth = branchDiffWidth();
 			const key = `edit:${fp}:${hashText(operations.map((edit) => `${edit.oldText}\u0000${edit.newText}`).join("\u0001"))}:${diffWidth}:${ctx.expanded ? 1 : 0}`;

package/extensions/message-chrome.ts

@@ -6,8 +6,6 @@ export interface MessageChromeInput {
 	assistantPrefix?: unknown;
 	thinkingPrefix?: unknown;
 	messageSpacing?: unknown;
-	workingTipEnabled?: unknown;
-	workingTipText?: unknown;
 	hiddenThinkingLabel?: unknown;
 }
 
@@ -16,8 +14,6 @@ export interface MessageChromeSettings {
 	assistantPrefix: string;
 	thinkingPrefix: string;
 	messageSpacing: MessageSpacing;
-	workingTipEnabled: boolean;
-	workingTipText: string;
 	hiddenThinkingLabel: string;
 }
 
@@ -28,7 +24,6 @@ export interface TranscriptLineOptions {
 	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 = {
@@ -36,8 +31,6 @@ const DEFAULT_MESSAGE_CHROME: MessageChromeSettings = {
 	assistantPrefix: "●",
 	thinkingPrefix: "✻",
 	messageSpacing: "comfortable",
-	workingTipEnabled: true,
-	workingTipText: DEFAULT_WORKING_TIP_TEXT,
 	hiddenThinkingLabel: DEFAULT_HIDDEN_THINKING_LABEL,
 };
 
@@ -45,7 +38,6 @@ const ANSI_ESCAPE_SEQUENCE_RE = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*
 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 {
@@ -81,14 +73,11 @@ export function sanitizeMessagePrefix(value: unknown, fallback: string): string
 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),
 	};
 }

package/extensions/spinner.ts

@@ -3,8 +3,6 @@ import { existsSync, readFileSync } from "node:fs";
 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.
 // Keep animation cadence constant so the spinner doesn't appear to slow down
@@ -28,8 +26,6 @@ interface SpinnerSettings {
 	verbColor: string;
 	statusColor: string;
 	verbs: readonly string[];
-	workingTipEnabled: boolean;
-	workingTipText: string;
 }
 
 let _spinnerSettingsCache: { value: SpinnerSettings; expires: number } | null = null;
@@ -100,9 +96,6 @@ 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 {
@@ -115,20 +108,14 @@ 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 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;
@@ -567,10 +554,6 @@ 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.1.1",
+  "version": "1.1.6",
   "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",