@pi-archimedes/core 2.2.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/core",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -19,13 +19,16 @@
     "./overlay": "./src/overlay.ts",
     "./config": "./src/config.ts",
     "./settings-io": "./src/settings-io.ts",
-    "./profiler": "./src/profiler.ts"
+    "./profiler": "./src/profiler.ts",
+    "./tool-render": "./src/tool-render.ts"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.1.0",
     "@earendil-works/pi-tui": ">=0.1.0"
   },
   "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "@earendil-works/pi-tui": "^0.84.2",
     "typescript": "^6.0.0"
   },
   "pi": {

package/src/bus.ts

@@ -108,7 +108,7 @@ export const Events = {
 
 interface TodoUpdatePayload {
   source: string;       // "main" or "subagent:<agent-name>"
-  todos: Array<{ id: number; title: string; description: string; status: "not-started" | "in-progress" | "completed" }>;
+  todos: Array<{ content: string; description?: string; status: "pending" | "in_progress" | "completed" }>;
 }
 
 interface TodoClearPayload {

package/src/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { TUI, type EditorTheme, type Component, type SettingItem } from "@earendil-works/pi-tui";
+import { type TUI, type EditorTheme, type Component, type SettingItem } from "@earendil-works/pi-tui";
 
 import { HephaestusEditor } from "./editor/index.js";
 
@@ -169,12 +169,15 @@ export function registerCore(pi: ExtensionAPI): void {
       });
     });
 
-    // Patch thinking renderer
-    patchThinkingRenderer(() => ctx.ui.theme);
-
-    // Load config for thinking transformation
+    // Load config for thinking transformation + label overrides
     const config = loadCoreConfig();
 
+    // Patch thinking renderer
+    patchThinkingRenderer(() => ctx.ui.theme, {
+      labelText: config.labelText,
+      labelColor: config.labelColor,
+    });
+
     // Register events
     pi.on("message_end", (event, _ctx) => {
       // Transform thinking content (unindent code blocks if enabled)

package/src/settings-io.test.ts

@@ -17,7 +17,148 @@ vi.mock("@earendil-works/pi-coding-agent", () => ({
 }));
 
 // Import after mocks are set up
-const { loadConfig, saveConfig } = await import("./settings-io.js");
+const { loadConfig, saveConfig, removeConfig, isConfigEnabled, setConfigEnabled } = await import("./settings-io.js");
+
+describe("removeConfig", () => {
+  beforeEach(() => {
+    const settingsPath = join(tempDir, "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      fs.unlinkSync(settingsPath);
+    }
+  });
+
+  afterEach(() => {
+    const settingsPath = join(tempDir, "settings.json");
+    const tmpPath = settingsPath + ".tmp";
+    try { fs.unlinkSync(settingsPath); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("deletes an existing namespace key and leaves sibling keys intact", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    fs.writeFileSync(
+      settingsPath,
+      JSON.stringify({ "test.ns": { foo: "bar" }, "other.ns": { baz: 1 }, "third.ns": { qux: "y" } }),
+      "utf-8",
+    );
+    removeConfig("test.ns");
+    const data = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    expect(data["test.ns"]).toBeUndefined();
+    expect(data["other.ns"]).toEqual({ baz: 1 });
+    expect(data["third.ns"]).toEqual({ qux: "y" });
+    expect(fs.existsSync(settingsPath + ".tmp")).toBe(false);
+  });
+
+  it("is a no-op when the key is absent (no rewrite)", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    fs.writeFileSync(
+      settingsPath,
+      JSON.stringify({ "other.ns": { baz: 1 } }),
+      "utf-8",
+    );
+    const beforeMtimeMs = fs.statSync(settingsPath).mtimeMs;
+    removeConfig("test.ns");
+    const afterMtimeMs = fs.statSync(settingsPath).mtimeMs;
+    expect(afterMtimeMs).toBe(beforeMtimeMs);
+    const data = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    expect(data).toEqual({ "other.ns": { baz: 1 } });
+  });
+
+  it("does not create the file when settings.json does not exist", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    expect(fs.existsSync(settingsPath)).toBe(false);
+    removeConfig("test.ns");
+    expect(fs.existsSync(settingsPath)).toBe(false);
+    expect(fs.existsSync(settingsPath + ".tmp")).toBe(false);
+  });
+});
+
+describe("isConfigEnabled", () => {
+  const settingsPath = () => join(tempDir, "settings.json");
+
+  beforeEach(() => {
+    if (fs.existsSync(settingsPath())) {
+      fs.unlinkSync(settingsPath());
+    }
+  });
+
+  afterEach(() => {
+    const path = settingsPath();
+    const tmpPath = path + ".tmp";
+    try { fs.unlinkSync(path); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("missing file/namespace → true", () => {
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("empty namespace object → true", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": {} }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("{ enabled: true } → true", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: true } }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("{ enabled: false } → false", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: false } }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(false);
+  });
+
+  it("{ enabled: \"false\" } → true (strict === false check)", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: "false" } }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+});
+
+describe("setConfigEnabled", () => {
+  const settingsPath = () => join(tempDir, "settings.json");
+
+  beforeEach(() => {
+    if (fs.existsSync(settingsPath())) {
+      fs.unlinkSync(settingsPath());
+    }
+  });
+
+  afterEach(() => {
+    const path = settingsPath();
+    const tmpPath = path + ".tmp";
+    try { fs.unlinkSync(path); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("set to false adds enabled:false, keeping other keys and sibling namespaces", () => {
+    fs.writeFileSync(
+      settingsPath(),
+      JSON.stringify({ "test.ns": { foo: "bar", count: 42 }, "other.ns": { baz: 1 } }),
+      "utf-8",
+    );
+    setConfigEnabled("test.ns", false);
+    const data = JSON.parse(fs.readFileSync(settingsPath(), "utf-8"));
+    expect(data["test.ns"]).toEqual({ foo: "bar", count: 42, enabled: false });
+    expect(data["other.ns"]).toEqual({ baz: 1 });
+    expect(isConfigEnabled("test.ns")).toBe(false);
+  });
+
+  it("set to true on { enabled: false } removes the namespace entirely (zero keys)", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: false } }), "utf-8");
+    setConfigEnabled("test.ns", true);
+    const data = JSON.parse(fs.readFileSync(settingsPath(), "utf-8"));
+    expect(data["test.ns"]).toBeUndefined();
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("set to true on { enabled: false, other: 1 } leaves the namespace as { other: 1 }", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: false, other: 1 } }), "utf-8");
+    setConfigEnabled("test.ns", true);
+    const data = JSON.parse(fs.readFileSync(settingsPath(), "utf-8"));
+    expect(data["test.ns"]).toEqual({ other: 1 });
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+});
 
 describe("loadConfig", () => {
   beforeEach(() => {

package/src/settings-io.ts

@@ -40,3 +40,60 @@ export function saveConfig(namespace: string, config: object): void {
     writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
   }
 }
+
+/**
+ * Delete a namespace section from settings.json entirely.
+ * No-op if the key is absent (including when the file doesn't exist — the file
+ * is never created). Atomic write, same pattern as saveConfig.
+ */
+export function removeConfig(namespace: string): void {
+  const full = readSettings();
+  // No file at all (readSettings returns {} for missing AND for corrupt,
+  // but only for missing is existsSync false) and no key → never create the file.
+  if (!existsSync(SETTINGS_PATH)) return;
+  if (!(namespace in full)) return;
+  delete full[namespace];
+  const tmpPath = SETTINGS_PATH + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(full, null, 2), "utf-8");
+  try {
+    renameSync(tmpPath, SETTINGS_PATH);
+  } catch {
+    try { unlinkSync(tmpPath); } catch { /* ignore */ }
+    writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
+  }
+}
+
+/**
+ * True unless settings[namespace].enabled === false (strict comparison — a
+ * string "false" or 0 does NOT disable). Missing file/namespace/key ⇒ true.
+ */
+export function isConfigEnabled(namespace: string): boolean {
+  const cfg = loadConfig(namespace, {}) as { enabled?: boolean };
+  return cfg.enabled !== false;
+}
+
+/**
+ * Turn a namespace's `enabled` gate on or off without touching the
+ * namespace's other keys or sibling namespaces.
+ *
+ * off: write settings[ns].enabled = false (merged — other keys survive).
+ * on: delete the `enabled` key; if that leaves the namespace with zero keys,
+ * remove the whole namespace key from the file.
+ *
+ * A namespace omitted from settings.json counts as enabled.
+ */
+export function setConfigEnabled(namespace: string, enabled: boolean): void {
+  if (enabled) {
+    const cfg = loadConfig(namespace, {}) as Record<string, unknown>;
+    delete cfg.enabled;
+    if (Object.keys(cfg).length === 0) {
+      removeConfig(namespace);
+    } else {
+      saveConfig(namespace, cfg);
+    }
+  } else {
+    const cfg = loadConfig(namespace, {}) as Record<string, unknown>;
+    cfg.enabled = false;
+    saveConfig(namespace, cfg);
+  }
+}

package/src/startup/index.ts

@@ -4,7 +4,7 @@ import { loadCoreConfig } from "../config.js";
 import { detectSection, parseSectionText, parseModelScope, formatColumns, buildItemWrapper, type ParsedSection, SECTION_KEYS } from "./sections.js";
 import { fetchLatestVersion, compareVersions } from "./version.js";
 import { stripAnsi } from "../text.js";
-import { Text, Spacer, Container, TUI, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import { Text, Spacer, Container, type TUI, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 
 // Symbol keys (survive hot-reload)
 const LISTING_REF = Symbol.for("splashscreen:listingRef");

package/src/text.ts

@@ -29,7 +29,7 @@ export function clampLine(line: string, maxW: number): string {
 }
 
 /** Clamp an array of lines to maxW visible characters each. */
-export function clampLines(lines: string[], maxW: number): string[] {
+function clampLines(lines: string[], maxW: number): string[] {
   return lines.map((l) => clampLine(l, maxW));
 }
 

package/src/thinking/patch.test.ts

@@ -196,6 +196,54 @@ describe("patchThinkingRenderer", () => {
 		expect(MockClassV2.prototype[PATCH_VERSION_KEY]).toBe("2.0.0");
 	});
 
+	it("accepts a minified thinking-check variant (no whitespace around ===)", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			// Minified dist-chunk shape: no whitespace around ===, single quotes
+			const content = { type: "thinking" };
+			if (content.type==="thinking") {
+				this.markdownTheme.codeBlockIndent="";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+
+		// The minification-safe regex probe must accept the minified variant
+		expect(MockClass.prototype[PATCHED_KEY]).toBe(true);
+	});
+
+	it("rejects a negated thinking check", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			// pi 0.84.3's own minified chunk contains
+			// `thinkingContent.type!=="thinking"` (inner batch-loop break). A source whose
+			// ONLY thinking-relations are negations must NOT pass the probe.
+			const content = { type: "thinking" };
+			if (content.type!=="thinking") {
+				this.markdownTheme.codeBlockIndent="";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+
+		// PATCHED_KEY must NOT be set — the probe must not match `!==`
+		expect(MockClass.prototype[PATCHED_KEY]).toBeUndefined();
+	});
+
 	it("re-patches on same version to update getTheme closure", async () => {
 		const MockClass = function AssistantMessageComponent() {};
 		MockClass.prototype.updateContent = function updateContent() {
@@ -224,4 +272,118 @@ describe("patchThinkingRenderer", () => {
 		// The patched function must be a new closure (not the same reference)
 		expect(MockClass.prototype.updateContent).not.toBe(first);
 	});
+
+	// ── Configurable thinking label (issue #36) ────────────────────────────
+
+	// Patches with a valid AssistantMessageComponent + mocked pi-tui so the
+	// Markdown content rendered for a thinking block can be inspected.
+	async function patchAndRender(
+		config?: { labelText?: string; labelColor?: string },
+		thinkingText = "Let me consider this carefully.",
+	) {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			if (this.content.type === "thinking") {
+				this.markdownTheme.codeBlockIndent = "";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const capturedMarkdown: any[] = [];
+		class MockMarkdown {
+			content: string;
+			constructor(content: string, ..._rest: any[]) {
+				this.content = content;
+				capturedMarkdown.push(this);
+			}
+		}
+		class MockSpacer {}
+		class MockText {}
+		vi.doMock("@earendil-works/pi-tui", () => ({
+			Markdown: MockMarkdown,
+			Spacer: MockSpacer,
+			Text: MockText,
+		}));
+
+		vi.resetModules();
+		const mod = await import("./patch.js");
+		mod.patchThinkingRenderer(
+			() => ({ getFgAnsi: () => "", fg: (_t: string, text: string) => text }) as any,
+			config,
+		);
+
+		const instance = {
+			contentContainer: { clear: vi.fn(), addChild: vi.fn() },
+			isStreaming: false,
+			markdownTheme: { codeBlockIndent: "" },
+			markdownTransformers: [],
+			hideThinkingBlock: false,
+			outputPad: 1,
+		};
+		const message = {
+			content: [{ type: "thinking", thinking: thinkingText }],
+			stopReason: undefined,
+		};
+		MockClass.prototype.updateContent.call(instance, message, false);
+		return capturedMarkdown;
+	}
+
+	it("uses configured labelText/labelColor for the thinking label", async () => {
+		const captured = await patchAndRender({
+			labelText: "Yapping...",
+			labelColor: "255,215,0",
+		});
+
+		expect(captured).toHaveLength(1);
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mYapping...\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("defaults to the original Thinking... label when no config is given", async () => {
+		const captured = await patchAndRender();
+
+		expect(captured).toHaveLength(1);
+		// Byte-identical to the previous hardcoded THINKING_LABEL
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mThinking...\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("trims whitespace from configured labelText and labelColor", async () => {
+		const captured = await patchAndRender({
+			labelText: "  Yapping...  ",
+			labelColor: " 255, 215, 0 ",
+		});
+
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mYapping...\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("falls back to 255,215,0 when labelColor is not a valid RGB triple", async () => {
+		const captured = await patchAndRender({
+			labelText: "Hmm",
+			labelColor: "not-a-color",
+		});
+
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mHmm\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("does not double-prepend the label when content already starts with it", async () => {
+		const label = "\x1b[1m\x1b[38;2;255;215;0mYapping...\x1b[39m\x1b[22m";
+		const captured = await patchAndRender(
+			{ labelText: "Yapping...", labelColor: "255,215,0" },
+			`${label}\n\nAlready labelled body.`,
+		);
+
+		expect(captured[0]!.content).toBe(`${label}\n\nAlready labelled body.`);
+	});
 });

package/src/thinking/patch.ts

@@ -3,9 +3,6 @@ import { AssistantMessageComponent, VERSION } from "@earendil-works/pi-coding-ag
 import { Markdown, type MarkdownOptions, type MarkdownTheme, Spacer, Text } from "@earendil-works/pi-tui";
 import { buildMutedMarkdownTheme } from "./theme.js";
 
-// The label we prepend to visible thinking content.
-const THINKING_LABEL = "\x1b[1m\x1b[38;2;255;215;0mThinking...\x1b[39m\x1b[22m";
-
 // Track which pi version we patched against to detect incompatibility
 const PATCHED_KEY = Symbol.for("archimedes:thinkingPatched");
 const PATCH_VERSION_KEY = Symbol.for("archimedes:thinkingPatchVersion");
@@ -16,8 +13,15 @@ const PATCH_VERSION_KEY = Symbol.for("archimedes:thinkingPatchVersion");
  * to capture a fresh `getTheme` closure (required for /resume).
  *
  * Re-patches when pi version changes to catch breaking upstream changes.
+ *
+ * @param config Optional labelText/labelColor overrides for the thinking
+ *   block header. When omitted (or empty/invalid), the original defaults
+ *   ("Thinking..." / "255,215,0") are used, producing byte-identical output.
  */
-export function patchThinkingRenderer(getTheme: () => Theme): void {
+export function patchThinkingRenderer(
+  getTheme: () => Theme,
+  config?: { labelText?: string; labelColor?: string },
+): void {
   if (!AssistantMessageComponent) return;
 
   const proto = AssistantMessageComponent.prototype;
@@ -30,7 +34,13 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
   }
 
   const src = proto.updateContent.toString();
-  const hasThinkingCheck = src.includes('content.type === "thinking"');
+  // NOTE: pi ships the interactive TUI in a minified bundle chunk at runtime, so
+  // the source we see via .toString() can be `content.type==="thinking"` (no
+  // spaces) even where dist is readable. The probe below must therefore be
+  // minification-safe: a whitespace-tolerant regex rather than an exact
+  // substring. A bare `space === "thinking"` (or any other field) still does
+  // not match, as required.
+  const hasThinkingCheck = /content\.type\s*===\s*["']thinking["']/.test(src);
   const hasMarkdownTheme = src.includes("this.markdownTheme");
   if (!hasThinkingCheck || !hasMarkdownTheme) {
     console.warn(
@@ -55,13 +65,44 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
     }
   }
 
-  // Re-patch every time — /resume needs a fresh getTheme closure
-  (proto as any).updateContent = function (this: any, message: any): void {
+  // Re-patched every session_start — /resume needs a fresh getTheme closure.
+  //
+  // Shape: 0.84.3 pi native updateContent:
+  //   updateContent(message, isStreaming = this.isStreaming) {
+  //     this.lastMessage = message;
+  //     this.isStreaming = isStreaming;
+  //     this.contentContainer.clear();
+  //     ...
+  //     // batches consecutive "thinking" parts into thinkingBlocks
+  //     //   (skipping empties), i-- after the inner loop,
+  //     //   renders as ONE Markdown section of thinkingBlocks.join("\n\n")
+  //     // or ONE static Text label when hidden.
+  //     // stop-reason: const hasToolCalls = content.some(...);
+  //     //   this.hasToolCalls = hasToolCalls; (render() uses for OSC-133 zones)
+  //     //   stopReason === "length" → Spacer + "truncated" Text
+  //     //   else if (!hasToolCalls) { aborted / error branches }
+  (proto as any).updateContent = function (this: any, message: any, isStreaming?: boolean): void {
     this.lastMessage = message;
+    if (isStreaming !== undefined) this.isStreaming = isStreaming;
 
     this.markdownTheme.codeBlockIndent = "";
     this.contentContainer.clear();
 
+    // Build the thinking-block header from the closure config once per render.
+    // Defaults preserve the original byte-identical output ("Thinking..." in
+    // bold truecolor 255,215,0).
+    const buildThinkingLabel = (): string => {
+      const label = config?.labelText?.trim() ? config.labelText.trim() : "Thinking...";
+      const color = config?.labelColor?.trim() ? config.labelColor.trim() : "255,215,0";
+      const parts = color.split(",").map((p) => p.trim());
+      // Valid iff exactly three 0..255 components (an "R,G,B" triple).
+      const valid =
+        parts.length === 3 &&
+        parts.every((p) => /^\d{1,3}$/.test(p) && Number(p) >= 0 && Number(p) <= 255);
+      const [r, g, b] = valid ? parts : ["255", "215", "0"];
+      return `\x1b[1m\x1b[38;2;${r};${g};${b}m${label}\x1b[39m\x1b[22m`;
+    };
+
     const hasVisibleContent = message.content.some(
       (c: any) =>
         (c.type === "text" && c.text.trim()) ||
@@ -105,11 +146,11 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
     // We must preserve it here, otherwise those transformers are silently
     // dropped when this patch replaces updateContent.
     //
-    // NOTE: the `transform` option was added to @earendil-works/pi-tui in
-    // 0.84.1. The repo's lockfile pins 0.78.0 whose types lack the field, so we
-    // extend the options type locally; at runtime the field is ignored by very
-    // old pi-tui and honored by 0.84.1+ (which is where Mermaid rendering and
-    // the bug both exist).
+    // NOTE: `createMarkdownTransform` is not exported from pi-coding-agent, so
+    // we inline an equivalent pipeline over `this.markdownTransformers`.
+    //
+    // The `transform` option was added to @earendil-works/pi-tui in 0.84.1.
+    // At runtime older pi-tui ignores the field, 0.84.1+ honors it.
     type MarkdownOptionsWithTransform = MarkdownOptions & {
       transform?: (markdown: string, availableWidth: number) => string;
     };
@@ -139,14 +180,27 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
         this.contentContainer.addChild(
           new Markdown(
             content.text.trim(),
-            1,
+            this.outputPad ?? 1,
             0,
             this.markdownTheme,
             undefined,
             { transform: transformFor("assistant") } as MarkdownOptionsWithTransform,
           ),
         );
-      } else if (content.type === "thinking" && content.thinking.trim()) {
+      } else if (content.type === "thinking") {
+        // Batch a consecutive run of thinking parts into one section
+        // (mirrors 0.84.3 pi native behaviour: thinkBlocks, i-- on the
+        // inner loop, early continue on zero-length runs).
+        const thinkBlocks: string[] = [];
+        for (; i < message.content.length; i++) {
+          const thinkingPart = message.content[i];
+          if (thinkingPart.type !== "thinking") break;
+          const trimmed = thinkingPart.thinking.trim();
+          if (trimmed) thinkBlocks.push(trimmed);
+        }
+        i--;
+        if (thinkBlocks.length === 0) continue;
+
         const hasVisibleContentAfter = message.content
           .slice(i + 1)
           .some(
@@ -156,18 +210,20 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
           );
 
         if (this.hideThinkingBlock) {
+          // One static label for the whole run when hidden.
           const t = ensureTheme();
           if (!t) continue;
           this.contentContainer.addChild(
-            new Text(t.italic(t.fg("thinkingText", this.hiddenThinkingLabel)), 1, 0),
+            new Text(t.italic(t.fg("thinkingText", this.hiddenThinkingLabel)), this.outputPad ?? 1, 0),
           );
           if (hasVisibleContentAfter) {
             this.contentContainer.addChild(new Spacer(1));
           }
         } else {
-          let thinkingContent = content.thinking.trim();
-          if (!thinkingContent.startsWith(THINKING_LABEL)) {
-            thinkingContent = `${THINKING_LABEL}\n\n${thinkingContent}`;
+          let thinkingContent = thinkBlocks.join("\n\n");
+          const label = buildThinkingLabel();
+          if (!thinkingContent.startsWith(label)) {
+            thinkingContent = `${label}\n\n${thinkingContent}`;
           }
           const t = ensureTheme();
           if (!t) continue;
@@ -175,7 +231,7 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
           this.contentContainer.addChild(
             new Markdown(
               thinkingContent,
-              1,
+              this.outputPad ?? 1,
               0,
               muted ?? this.markdownTheme,
               {
@@ -192,9 +248,19 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
       }
     }
 
-    // Aborted/error rendering.
+    // Stop-reason handling — 0.84.3 pi shape. `hasToolCalls` is required by
+    // the component's render() for OSC-133 prompt zones, so it must be set.
     const hasToolCalls = message.content.some((c: any) => c.type === "toolCall");
-    if (!hasToolCalls) {
+    this.hasToolCalls = hasToolCalls;
+
+    if (message.stopReason === "length") {
+      this.contentContainer.addChild(new Spacer(1));
+      const t = ensureTheme();
+      if (t)
+        this.contentContainer.addChild(
+          new Text(t.fg("error", "Response was truncated before completion."), this.outputPad ?? 1, 0),
+        );
+    } else if (!hasToolCalls) {
       if (message.stopReason === "aborted") {
         const abortMessage =
           message.errorMessage && message.errorMessage !== "Request was aborted"
@@ -202,21 +268,18 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
             : "Operation aborted";
         this.contentContainer.addChild(new Spacer(1));
         const t = ensureTheme();
-        if (t) this.contentContainer.addChild(new Text(t.fg("error", abortMessage), 1, 0));
+        if (t) this.contentContainer.addChild(new Text(t.fg("error", abortMessage), this.outputPad ?? 1, 0));
       } else if (message.stopReason === "error") {
         const errorMsg = message.errorMessage || "Unknown error";
         this.contentContainer.addChild(new Spacer(1));
         const t = ensureTheme();
         if (t) {
           this.contentContainer.addChild(
-            new Text(t.fg("error", `Error: ${errorMsg}`), 1, 0),
+            new Text(t.fg("error", `Error: ${errorMsg}`), this.outputPad ?? 1, 0),
           );
         }
       }
     }
-
-    // Bottom padding so next message has breathing room
-    this.contentContainer.addChild(new Spacer(1));
   };
 
   // Mark as patched with version for incompatibility detection

package/src/tool-render.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import {
+  renderToolHeader,
+  renderStatusLabel,
+  renderToolCallLine,
+  STATUS_GLYPH,
+  type ToolRenderTheme,
+} from "./tool-render.js";
+
+// Fake theme: wraps text in visible markers so assertions can verify tokens.
+const theme: ToolRenderTheme = {
+  fg: (token: string, text: string) => `[${token}:${text}]`,
+  bold: (text: string) => `**${text}**`,
+};
+
+describe("renderToolHeader", () => {
+  it("renders blue bold tool name + orange action", () => {
+    expect(renderToolHeader("mcp", "atlassian", theme)).toBe(
+      "[toolTitle:**mcp**] [accent:atlassian]",
+    );
+  });
+
+  it("renders the name only when action is empty", () => {
+    expect(renderToolHeader("todo", "", theme)).toBe("[toolTitle:**todo**]");
+    expect(renderToolHeader("todo", undefined, theme)).toBe(
+      "[toolTitle:**todo**]",
+    );
+  });
+});
+
+describe("renderStatusLabel", () => {
+  it("running: muted glyph + muted label", () => {
+    expect(renderStatusLabel("running", "2/4 completed", theme)).toBe(
+      "[muted:▸ ][muted:2/4 completed]",
+    );
+  });
+
+  it("success: green glyph + muted label", () => {
+    expect(renderStatusLabel("success", "done", theme)).toBe(
+      "[success:✓ ][muted:done]",
+    );
+  });
+
+  it("error: red glyph + muted label", () => {
+    expect(renderStatusLabel("error", "boom", theme)).toBe(
+      "[error:✗ ][muted:boom]",
+    );
+  });
+
+  it("exposes the glyph map", () => {
+    expect(STATUS_GLYPH).toEqual({ running: "▸", success: "✓", error: "✗" });
+  });
+});
+
+describe("renderToolCallLine", () => {
+  it("success: green glyph + green name + dim suffix", () => {
+    expect(renderToolCallLine("success", "read", ": /path", theme)).toBe(
+      "[success:✓ ][success:read][dim:: /path]",
+    );
+  });
+
+  it("error: red glyph + red name + dim suffix", () => {
+    expect(renderToolCallLine("error", "read", ": /missing", theme)).toBe(
+      "[error:✗ ][error:read][dim:: /missing]",
+    );
+  });
+
+  it("running: muted glyph + muted name", () => {
+    expect(renderToolCallLine("running", "grep", ": pattern | 2s", theme)).toBe(
+      "[muted:▸ ][muted:grep][dim:: pattern | 2s]",
+    );
+  });
+
+  it("omits the dim fragment when suffix is empty", () => {
+    expect(renderToolCallLine("success", "bash", "", theme)).toBe(
+      "[success:✓ ][success:bash]",
+    );
+  });
+});

package/src/tool-render.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared tool-row rendering helpers.
+ *
+ * Archimedes tools (mcp, todo, …) render a consistent two-part row:
+ *
+ *   line 1 (header):  <toolName> (blue bold) + <action> (orange accent)
+ *   result line:      <glyph> <label>  — glyph reflects run status:
+ *                       ▸ running (muted) · ✓ success (green) · ✗ error (red)
+ *                     the label is muted so the glyph carries the colour.
+ *
+ * These helpers are pure (no TUI component imports) so they stay directly
+ * unit-testable and can be reused across packages. Callers wrap the returned
+ * string in whatever component they use (typically a pi-tui Text).
+ */
+
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+
+/** Run status of a settled/in-flight tool row. */
+export type ToolStatus = "running" | "success" | "error";
+
+/** Glyph shown before the result label, keyed by status. */
+export const STATUS_GLYPH: Record<ToolStatus, string> = {
+  running: "▸",
+  success: "✓",
+  error: "✗",
+};
+
+/** Theme color token used to colour each status glyph. */
+const STATUS_TOKEN: Record<ToolStatus, ThemeColor> = {
+  running: "muted",
+  success: "success",
+  error: "error",
+};
+
+/**
+ * The subset of a pi Theme these helpers need. Typed with pi's ThemeColor so
+ * pi's real Theme is assignable (parameter contravariance: a fn requiring the
+ * wider string token would NOT accept a Theme whose fg only takes ThemeColor).
+ */
+export type ToolRenderTheme = {
+  fg: (token: ThemeColor, text: string) => string;
+  bold: (text: string) => string;
+};
+
+/**
+ * Render the tool header line:
+ *   <toolName> (toolTitle, bold) + " " + <action> (accent)
+ *
+ * When action is empty/undefined only the tool name is rendered.
+ */
+export function renderToolHeader(
+  toolName: string,
+  action: string | undefined,
+  theme: ToolRenderTheme,
+): string {
+  const name = theme.fg("toolTitle", theme.bold(toolName));
+  if (!action) return name;
+  return name + " " + theme.fg("accent", action);
+}
+
+/**
+ * Render a status result line:
+ *   <glyph> (status-coloured) + <label> (muted)
+ *
+ * e.g. "✓ atlassian_searchJiraIssuesUsingJql" or "▸ 2/4 completed".
+ */
+export function renderStatusLabel(
+  status: ToolStatus,
+  label: string,
+  theme: ToolRenderTheme,
+): string {
+  return (
+    theme.fg(STATUS_TOKEN[status], STATUS_GLYPH[status] + " ") +
+    theme.fg("muted", label)
+  );
+}
+
+/**
+ * Render a tool-call line with a status glyph, a status-coloured name, and an
+ * optional dim args/suffix fragment:
+ *
+ *   <glyph> (status-coloured) + <name> (status-coloured) + <suffix> (dim)
+ *
+ * e.g. "✓ read: /path/to/file" (green glyph+name, dim ": /path...") or
+ *      "▸ grep: pattern" (muted glyph+name while running).
+ *
+ * The name shares the glyph's colour (unlike renderStatusLabel, which mutes
+ * the label) so a completed call reads as a single green/red unit. The suffix
+ * is passed pre-formatted (e.g. ": args" or ": args | 2s") and rendered dim.
+ */
+export function renderToolCallLine(
+  status: ToolStatus,
+  name: string,
+  suffix: string,
+  theme: ToolRenderTheme,
+): string {
+  const token = STATUS_TOKEN[status];
+  const head =
+    theme.fg(token, STATUS_GLYPH[status] + " ") + theme.fg(token, name);
+  return suffix ? head + theme.fg("dim", suffix) : head;
+}