pi-minimal 0.2.3 → 0.3.1

package/src/tracker.ts

@@ -67,19 +67,24 @@ export function formatTrackerLines(
   }
   if (tasks && tasks.length > 0) {
     const done = tasks.filter((t) => t.status === "complete").length
-    const icons = tasks
-      .map((t) => {
-        if (t.status === "complete") return theme.fg("success", "✓")
-        if (t.status === "in_progress") return theme.fg("warning", "→")
-        if (t.status === "failed") return theme.fg("error", "✗")
-        return theme.fg("dim", "○")
-      })
-      .join("")
+    // One segment per task, coloured by status, so the list reads as a single bar instead of a
+    // row of check marks. Past 12 tasks the bar is scaled to 10 segments (status order kept).
+    const segment = (status: string | undefined) => {
+      if (status === "complete") return theme.fg("success", "▰")
+      if (status === "in_progress") return theme.fg("warning", "▰")
+      if (status === "failed") return theme.fg("error", "▰")
+      return theme.fg("dim", "▱")
+    }
+    const shown =
+      tasks.length <= 12
+        ? tasks.map((t) => t.status)
+        : Array.from({ length: 10 }, (_, i) => tasks[Math.floor((i * tasks.length) / 10)]?.status)
+    const icons = shown.map(segment).join("")
     const current =
       tasks.find((t) => t.status === "in_progress") ?? tasks.find((t) => t.status === "pending")
     const name = current ? theme.fg("text", ` ${current.name}`) : ""
     lines.push(
-      `${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `(${done}/${tasks.length})`)}${name}`,
+      `${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `${done}/${tasks.length}`)}${name}`,
     )
   }
   return lines

package/src/transcript.ts

@@ -1,51 +1,106 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { visibleWidth } from "@earendil-works/pi-tui"
 
 export const THINKING_GUTTER = "┊ "
 
 const FENCE = /^\s*(```|~~~)/
 const BLOCK_START = /^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|>|\||```|~~~|---\s*$|\*\*\*\s*$|___\s*$)/
+/** Below this width wrapping would only make thinking harder to read; prefix source lines instead. */
+const MIN_WRAP_WIDTH = 20
+/** An inline code span stays whole; everything else splits on spaces. */
+const TOKEN = /`[^`]*`|[^\s`]+|`/g
+
+function stripGutter(line: string): string {
+	return line.startsWith(THINKING_GUTTER) ? line.slice(THINKING_GUTTER.length) : line
+}
+
+/** Split a word wider than `room` into `room`-wide pieces (URLs, long paths). */
+function splitWide(word: string, room: number): string[] {
+	if (word.startsWith("`") || visibleWidth(word) <= room) return [word]
+	const pieces: string[] = []
+	let piece = ""
+	for (const char of word) {
+		if (visibleWidth(piece + char) > room) {
+			pieces.push(piece)
+			piece = ""
+		}
+		piece += char
+	}
+	if (piece) pieces.push(piece)
+	return pieces
+}
+
+/**
+ * Greedy word wrap at `room` cells. Markdown markers (`*`, backticks) count toward the width
+ * but are removed when rendered, so lines can only come out shorter than `room`, never wider.
+ */
+export function wrapLine(line: string, room: number): string[] {
+	const words = (line.match(TOKEN) ?? []).flatMap((word) => splitWide(word, room))
+	if (words.length === 0) return [""]
+	const out: string[] = []
+	let current = ""
+	for (const word of words) {
+		if (!current) current = word
+		else if (visibleWidth(current) + 1 + visibleWidth(word) <= room) current += ` ${word}`
+		else {
+			out.push(current)
+			current = word
+		}
+	}
+	out.push(current)
+	return out
+}
 
 /**
- * Prefix the first line of every plain paragraph in thinking Markdown with a gutter glyph.
- * Lines that start a Markdown block (heading, list, quote, table, fence, rule) are left alone so
- * they keep parsing, and nothing inside a fenced code block is touched.
+ * Put the thinking gutter on every rendered line of every plain paragraph, so thinking reads as a
+ * column beside prose rather than a bullet on its first line. With `width` (the content width the
+ * host will render at) paragraph lines are pre-wrapped to `width - 2` so wrapped lines carry the
+ * gutter too; pi-tui keeps single newlines as line breaks. Without a usable width only source
+ * lines are prefixed.
+ *
+ * Block syntax (heading, list, quote, table, fence, rule) is left untouched so it still parses,
+ * including a list or quote that interrupts a paragraph, and nothing inside fenced code changes.
  */
-export function gutterThinking(markdown: string): string {
-  if (!markdown) return markdown
-  const lines = markdown.split("\n")
-  const out: string[] = []
-  let inFence = false
-  let atParagraphStart = true
-  for (const line of lines) {
-    if (FENCE.test(line)) {
-      inFence = !inFence
-      out.push(line)
-      atParagraphStart = !inFence
-      continue
-    }
-    if (inFence) {
-      out.push(line)
-      continue
-    }
-    if (line.trim() === "") {
-      out.push(line)
-      atParagraphStart = true
-      continue
-    }
-    if (atParagraphStart && !BLOCK_START.test(line) && !line.startsWith(THINKING_GUTTER)) {
-      out.push(`${THINKING_GUTTER}${line}`)
-    } else {
-      out.push(line)
-    }
-    atParagraphStart = false
-  }
-  return out.join("\n")
+export function gutterThinking(markdown: string, width?: number): string {
+	if (!markdown) return markdown
+	const room = width !== undefined && width >= MIN_WRAP_WIDTH ? width - visibleWidth(THINKING_GUTTER) : undefined
+	const out: string[] = []
+	let inFence = false
+	/** "para": inside a plain paragraph; "block": inside block syntax until the next blank line. */
+	let mode: "none" | "para" | "block" = "none"
+	for (const line of markdown.split("\n")) {
+		if (FENCE.test(line)) {
+			inFence = !inFence
+			out.push(line)
+			mode = "none"
+			continue
+		}
+		if (inFence) {
+			out.push(line)
+			continue
+		}
+		if (line.trim() === "") {
+			out.push(line)
+			mode = "none"
+			continue
+		}
+		const body = stripGutter(line)
+		if (mode === "block" || BLOCK_START.test(body)) {
+			out.push(line)
+			mode = "block"
+			continue
+		}
+		mode = "para"
+		if (room === undefined) out.push(`${THINKING_GUTTER}${body}`)
+		else for (const piece of wrapLine(body, room)) out.push(`${THINKING_GUTTER}${piece}`)
+	}
+	return out.join("\n")
 }
 
 export function installTranscript(pi: ExtensionAPI): void {
-  if (typeof pi.registerMarkdownTransformer !== "function") return
-  pi.registerMarkdownTransformer((markdown, context) => {
-    if (context.messageType !== "assistant-thinking") return markdown
-    return gutterThinking(markdown)
-  })
+	if (typeof pi.registerMarkdownTransformer !== "function") return
+	pi.registerMarkdownTransformer((markdown, context) => {
+		if (context.messageType !== "assistant-thinking") return markdown
+		return gutterThinking(markdown, context.availableWidth)
+	})
 }

package/test/codemode-rows.test.ts

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { callSummary, codemodeOutcome, nestedCalls, nestedItem, parseArgs, scriptOutput } from "../src/codemode-rows.js"
+
+const result = (text: string, calls: unknown[] = []) => ({
+	content: [
+		{ type: "text", text: "Script completed\nWall time 1.2 seconds\nOutput:\n" },
+		{ type: "text", text },
+	],
+	details: { calls },
+})
+
+test("parseArgs reads complete JSON and recovers keys from a preview cut at 200 chars", () => {
+	assert.deepEqual(parseArgs('{"action":"update","index":6}'), { action: "update", index: 6 })
+	const cut = '{"command":"cd ~/repo && sed -n 168,180p docs/a.md && echo \\"===\\" && rg -n x docs/b.md | sed -n 1,30p && ech...'
+	assert.equal(parseArgs(cut).command, 'cd ~/repo && sed -n 168,180p docs/a.md && echo "===" && rg -n x docs/b.md | sed -n 1,30p && ech...')
+	assert.deepEqual(parseArgs(""), {})
+	assert.deepEqual(parseArgs("[1,2]"), {})
+	// A cut inside an escape must not throw.
+	assert.equal(typeof parseArgs('{"command":"echo \\').command, "string")
+})
+
+test("nestedItem reads built-ins like their top-level rows and others as key=value", () => {
+	assert.equal(nestedItem({ name: "bash", args: '{"command":"git status\\ngit diff","timeout":10}' }), "git status · +1 line")
+	assert.equal(nestedItem({ name: "read", args: '{"path":"/a/b/c/file.ts"}' }), "c/file.ts")
+	assert.equal(
+		nestedItem({ name: "plan_tracker", args: '{"action":"update","index":6,"status":"complete"}' }),
+		"action=update index=6 status=complete",
+	)
+	assert.equal(nestedItem({ name: "mcp__x__q", args: '{"query":"a","nested":{"b":1},"limit":5,"extra":1,"more":2}' }), "query=a limit=5 extra=1")
+	assert.equal(nestedItem({ name: "subagents_enable", args: "{}" }), "")
+})
+
+test("callSummary names tools in first-call order with repeat counts", () => {
+	assert.equal(callSummary([]), "script")
+	assert.equal(callSummary([{ name: "bash" }]), "1 call · bash")
+	assert.equal(
+		callSummary([{ name: "plan_tracker" }, { name: "plan_tracker" }, { name: "bash" }]),
+		"3 calls · plan_tracker ×2, bash",
+	)
+})
+
+test("scriptOutput drops pi-core's script header; nestedCalls tolerates missing details", () => {
+	assert.equal(scriptOutput(result("hello\n")), "hello")
+	assert.deepEqual(nestedCalls({ content: [] }), [])
+	assert.deepEqual(nestedCalls({ content: [], details: { calls: [null, { name: "bash" }] } }), [{ name: "bash" }])
+})
+
+test("codemodeOutcome counts output lines and surfaces the first failure", () => {
+	assert.deepEqual(codemodeOutcome(result("a\nb\n\nc"), false, 1200), { text: "3 lines · 1.2s", failed: false })
+	assert.deepEqual(codemodeOutcome(result(""), false, 300), { text: "ok · 0.3s", failed: false })
+	const failed = codemodeOutcome(
+		result("TEST_EXIT=1", [{ name: "bash", status: "ok" }, { name: "bash", status: "error", error: "\nboom: exit 2\nmore" }]),
+		false,
+		274_000,
+	)
+	assert.deepEqual(failed, { text: "1 failed · 4m 34s", failed: true, errorLine: "boom: exit 2" })
+	const scriptError = codemodeOutcome(result("partial\nScript error: ReferenceError: x is not defined"), true, 50)
+	assert.equal(scriptError.failed, true)
+	assert.equal(scriptError.errorLine, "ReferenceError: x is not defined")
+})

package/test/package.test.ts

@@ -1,23 +0,0 @@
-import assert from "node:assert/strict"
-import test from "node:test"
-import { readFileSync } from "node:fs"
-
-test("package manifest exposes the committed extension", () => {
-	const pkg = JSON.parse(readFileSync("package.json", "utf8"))
-	assert.equal(pkg.name, "pi-minimal")
-	assert.equal(pkg.version, "0.2.3")
-	const lock = JSON.parse(readFileSync("package-lock.json", "utf8"))
-	assert.equal(lock.version, pkg.version, "lockfile root version matches package")
-	assert.equal(lock.packages[""].version, pkg.version, "lockfile package version matches package")
-	assert.ok(readFileSync("CHANGELOG.md", "utf8").includes(`## [${pkg.version}] - `), "version has a dated release entry")
-	assert.equal(pkg.license, "MIT")
-	assert.equal(pkg.type, "module")
-	assert.deepEqual(pkg.engines, { node: ">=22.19.0" })
-	assert.deepEqual(pkg.keywords, ["pi-package"])
-	assert.deepEqual(pkg.repository, { type: "git", url: "git+https://github.com/raviy06/pi-minimal.git" })
-	assert.deepEqual(pkg.pi, { extensions: ["./dist/index.js"], themes: ["./themes/minimal-dark.json"] })
-	assert.deepEqual(pkg.peerDependencies, {
-		"@earendil-works/pi-coding-agent": "*",
-		"@earendil-works/pi-tui": "*",
-	})
-})

package/test/theme.test.ts

@@ -43,3 +43,31 @@ test("minimal-dark frames code quietly and neutralises tool backgrounds", () =>
 	assert.equal(theme.colors.toolSuccessBg, theme.colors.toolPendingBg)
 	assert.notEqual(theme.colors.mdHeading, theme.colors.warning)
 })
+
+const lightness = (value: string) => {
+	const resolved = value in theme.vars ? theme.vars[value] : value
+	const m = /okhsl\(\s*[\d.]+\s+[\d.]+%\s+([\d.]+)%\s*\)/.exec(resolved)
+	assert.ok(m, `okhsl literal for ${value}`)
+	return Number(m![1]) / 100
+}
+
+test("minimal-dark keeps a readable grey ladder: text > muted > thinking > dim > faint", () => {
+	const ladder = [theme.vars.text, theme.vars.muted, theme.colors.thinkingText, theme.vars.dim, theme.vars.faint].map(lightness)
+	for (let i = 1; i < ladder.length; i++) assert.ok(ladder[i] < ladder[i - 1], `step ${i}: ${ladder.join(" > ")}`)
+	// Readable tiers stay at or above L .56 (~4.4:1 on bg L .11, estimating Y ≈ L³).
+	assert.ok(lightness(theme.vars.dim) >= 0.56)
+	assert.ok(lightness(theme.colors.thinkingText) >= 0.56)
+})
+
+test("minimal-dark keeps status hues out of syntax colours", () => {
+	const status = new Set([theme.colors.success, theme.colors.warning, theme.colors.error])
+	for (const role of ["syntaxFunction", "syntaxNumber", "syntaxString", "syntaxVariable"]) {
+		assert.ok(!status.has(theme.colors[role]), `${role} reuses a status colour`)
+	}
+})
+
+test("minimal-dark draws no slab behind tool rows; only failures get a background", () => {
+	assert.equal(theme.colors.toolSuccessBg, "bg")
+	assert.equal(theme.colors.toolPendingBg, "bg")
+	assert.notEqual(theme.colors.toolErrorBg, "bg")
+})

package/test/tool-rows.test.ts

@@ -8,6 +8,7 @@ import {
 	formatOutcome,
 	layoutRow,
 	rowGlyph,
+	setSessionCwd,
 	shortName,
 	toolItem,
 } from "../src/tool-rows.js"
@@ -15,7 +16,7 @@ import {
 const text = (s: string) => ({ content: [{ type: "text", text: s }] })
 
 test("toolItem picks the first command line for bash and a two-segment path otherwise", () => {
-	assert.equal(toolItem("bash", { command: "git status\ngit diff" }), "git status")
+	assert.equal(toolItem("bash", { command: "git status" }), "git status")
 	assert.equal(toolItem("read", { path: "/a/b/c/file.ts" }), "c/file.ts")
 	assert.equal(toolItem("grep", { pattern: "foo" }), "foo")
 	assert.equal(toolItem("ls", {}), "ls")
@@ -107,3 +108,18 @@ test("layoutRow drops the outcome when the row is too narrow", () => {
 	assert.equal(row.outcome, "")
 	assert.equal(row.gap, 0)
 })
+
+test("bash items drop cd into the session cwd, shorten other cd targets, and count extra lines", () => {
+	setSessionCwd("/Users/me/repo", "/Users/me")
+	try {
+		assert.equal(toolItem("bash", { command: "cd /Users/me/repo && npm test" }), "npm test")
+		assert.equal(toolItem("bash", { command: "cd ~/repo/ && npm test" }), "npm test")
+		assert.equal(toolItem("bash", { command: "cd ~/Dev/src/github.com/raviy06/pi-subagents && sed -n 1,2p a.ts" }), "pi-subagents › sed -n 1,2p a.ts")
+		assert.equal(toolItem("bash", { command: 'cd "/tmp/with space" && ls' }), "with space › ls")
+		assert.equal(toolItem("bash", { command: "cd /tmp" }), "cd /tmp", "a bare cd stays as written")
+		assert.equal(toolItem("bash", { command: "cd ~/repo && python3 - <<'EOF'\nprint(1)\n\nprint(2)\nEOF" }), "python3 - <<'EOF' · +3 lines")
+		assert.equal(toolItem("bash", { command: "git status\ngit diff" }), "git status · +1 line")
+	} finally {
+		setSessionCwd(undefined)
+	}
+})

package/test/tools.test.ts

@@ -1,7 +1,17 @@
 import assert from "node:assert/strict"
 import test from "node:test"
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { compactRenderers, installToolRenderers, isToolKind } from "../src/tools.js"
+import {
+	codemodeRenderers,
+	compactRenderers,
+	genericItem,
+	genericOutcome,
+	genericRenderers,
+	genericVerb,
+	installToolRenderers,
+	isToolKind,
+	stopLiveWatch,
+} from "../src/tools.js"
 
 test("isToolKind recognises the built-in tools only", () => {
 	for (const name of ["bash", "read", "edit", "write", "grep", "find", "ls"]) assert.equal(isToolKind(name), true)
@@ -19,7 +29,14 @@ test("installToolRenderers registers a resolver at load time that only claims bu
 	installToolRenderers(pi)
 	assert.ok(resolver, "resolver registered synchronously, before session_start")
 	const fallback = { renderShell: "default" }
-	assert.equal(resolver!("codemode", () => fallback), fallback)
+	const own = { renderCall() {}, renderResult() {} }
+	assert.equal(resolver!("subagent", () => own), own, "tools with their own renderer keep it")
+	const generic = resolver!("mcp__foo__bar", () => fallback) as { renderShell?: string; renderCall?: unknown }
+	assert.equal(generic.renderShell, "self", "renderer-less tools get the compact row")
+	assert.equal(typeof generic.renderCall, "function")
+	assert.equal((resolver!("mcp__foo__bar", () => undefined) as { renderShell?: string }).renderShell, "self")
+	const codemode = resolver!("codemode", () => fallback) as { renderShell?: string }
+	assert.equal(codemode.renderShell, "self")
 	const mine = resolver!("bash", () => fallback) as { renderShell?: string }
 	assert.equal(mine.renderShell, "self")
 	assert.equal(typeof (mine as { renderCall?: unknown }).renderCall, "function")
@@ -53,3 +70,109 @@ test("compactRenderers render a one-line row with the outcome once the result la
 	const [line] = row.render(60)
 	assert.match(line, /✓ bash\s+ls\s+2 lines · 1.2s$/)
 })
+
+function codemodeContext(extra: Record<string, unknown> = {}) {
+	return {
+		args: { code: "await tools.bash({command:'ls'})\ntext(1)" },
+		toolCallId: "c1",
+		invalidate() {},
+		state: {} as Record<string, unknown>,
+		isPartial: false,
+		isError: false,
+		durationMs: 1200,
+		...extra,
+	}
+}
+
+const plainTheme = { fg: (_c: string, s: string) => s } as never
+const codemodeResult = (calls: unknown[], output = "a\nb") => ({
+	content: [
+		{ type: "text", text: "Script completed\nWall time 1.2 seconds\nOutput:\n" },
+		{ type: "text", text: output },
+	],
+	details: { calls },
+})
+
+test("codemode renders one parent row plus one child row per nested call, no script", () => {
+	const r = codemodeRenderers()
+	const context = codemodeContext()
+	const calls = [
+		{ name: "plan_tracker", args: '{"action":"update","index":6,"status":"complete"}', status: "ok", durationMs: 309 },
+		{ name: "bash", args: '{"command":"cd ~/r && sed -n 1,2p a.md"}', status: "ok", durationMs: 636 },
+	]
+	const body = r.renderResult!(codemodeResult(calls) as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	const lines = r.renderCall!(context.args as never, plainTheme, context as never).render(100)
+	assert.equal(lines.length, 3)
+	assert.match(lines[0], /✓ code\s+2 calls · plan_tracker, bash\s+2 lines · 1.2s$/)
+	assert.match(lines[1], /✓ plan_tracker action=update index=6 status=complete\s+0.3s$/)
+	assert.match(lines[2], /✓ bash\s+r › sed -n 1,2p a.md\s+0.6s$/)
+	assert.ok(lines.every((line) => !line.includes("await")), "script hidden when collapsed")
+	assert.deepEqual(body.render(100), [])
+	for (const line of lines) assert.ok(line.length <= 100)
+})
+
+test("codemode shows the first failure under the row, and script + output when expanded", () => {
+	const r = codemodeRenderers()
+	const context = codemodeContext({ durationMs: 274_000 })
+	const calls = [{ name: "bash", args: '{"command":"npm test"}', status: "error", durationMs: 274_000, error: "fail 2" }]
+	const collapsed = r.renderResult!(codemodeResult(calls, "TEST_EXIT=1") as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	const [row, child] = r.renderCall!(context.args as never, plainTheme, context as never).render(100)
+	assert.match(row, /✗ code\s+1 call · bash\s+1 failed · 4m 34s$/)
+	assert.match(child, /✗ bash npm test\s+failed · 4m 34s$/)
+	assert.match(collapsed.render(100).join("\n"), /│ fail 2/)
+
+	const open = r.renderResult!(codemodeResult(calls, "TEST_EXIT=1") as never, { expanded: true, isPartial: false } as never, plainTheme, { ...context, expanded: true } as never)
+	const text = open.render(100).join("\n")
+	assert.match(text, /\/\/ script · 2 lines/)
+	assert.match(text, /await tools.bash/)
+	assert.match(text, /\/\/ output\n.*TEST_EXIT=1/)
+})
+
+test("codemode shows nested calls live while the script is still running", () => {
+	const r = codemodeRenderers()
+	const context = codemodeContext({ isPartial: true, durationMs: undefined })
+	r.renderResult!(codemodeResult([{ name: "bash", args: '{"command":"sleep 5"}', status: "running" }], "") as never, { expanded: false, isPartial: true } as never, plainTheme, context as never)
+	const lines = r.renderCall!(context.args as never, plainTheme, context as never).render(80)
+	assert.match(lines[0], /^\s+[◐◓] code\s+1 call · bash/)
+	assert.match(lines[1], /[◐◓] bash sleep 5/)
+	assert.equal((context.state as { done?: boolean }).done, undefined)
+	stopLiveWatch()
+})
+
+test("generic rows label MCP and agent tools and read arguments as key=value", () => {
+	assert.equal(genericVerb("mcp__re_mcp__query_prometheus"), "mcp")
+	assert.equal(genericVerb("subagents_enable"), "agent")
+	assert.equal(genericVerb("todo"), "tool")
+	assert.equal(genericItem("mcp__re_mcp__query_prometheus", { query: "sum(rate(x[5m]))", limit: 5 }), "re_mcp · query_prometheus query=sum(rate(x[5m])) limit=5")
+	assert.equal(genericItem("subagents_enable", {}), "subagents_enable")
+	assert.equal(genericItem("todo", { action: "add", text: "line one\nline two" }), "todo action=add text=line one")
+})
+
+test("generic outcomes show a short first line verbatim, otherwise a line count", () => {
+	const text = (s: string) => ({ content: [{ type: "text", text: s }] })
+	assert.deepEqual(genericOutcome(text("Updated (9/9 done)"), false, 300), { text: "Updated (9/9 done) · 0.3s" })
+	assert.deepEqual(genericOutcome(text("Enabled: subagent. If your tool list includes subagent, call it now."), false, 0), { text: "1 line · 0s" })
+	assert.deepEqual(genericOutcome(text("a\nb\n"), false, 1400), { text: "2 lines · 1.4s" })
+	assert.deepEqual(genericOutcome(text(""), false, undefined), { text: "ok" })
+	assert.deepEqual(genericOutcome(text("\nboom\nmore"), true, 100), { text: "failed · 0.1s", errorLine: "boom" })
+})
+
+test("generic renderer draws one row, an error line on failure, and output on expand", () => {
+	const r = genericRenderers("mcp__re_mcp__query_prometheus")
+	const make = (extra: Record<string, unknown> = {}) => ({ toolCallId: "g1", invalidate() {}, state: {}, isPartial: false, isError: false, durationMs: 1400, ...extra })
+	const args = { query: "up" }
+	let context = make()
+	r.renderResult!({ content: [{ type: "text", text: "a\nb\nc" }] } as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	const [line, ...rest] = r.renderCall!(args as never, plainTheme, context as never).render(90)
+	assert.match(line, /✓ mcp\s+re_mcp · query_prometheus query=up\s+3 lines · 1.4s$/)
+	assert.equal(rest.length, 0)
+
+	context = make({ isError: true })
+	const failed = r.renderResult!({ content: [{ type: "text", text: "401 unauthorized" }] } as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	assert.match(r.renderCall!(args as never, plainTheme, context as never).render(90)[0], /✗ mcp .*failed · 1.4s$/)
+	assert.match(failed.render(90).join(""), /│ 401 unauthorized/)
+
+	context = make({ expanded: true })
+	const open = r.renderResult!({ content: [{ type: "text", text: "a\nb" }] } as never, { expanded: true, isPartial: false } as never, plainTheme, context as never)
+	assert.deepEqual(open.render(90).map((l) => l.trim()), ["│ a", "│ b"])
+})

package/test/tracker.test.ts

@@ -102,3 +102,21 @@ test("hideGauntletWidgets clears phase_tracker and plan_tracker", () => {
 		["plan_tracker", undefined],
 	])
 })
+
+test("task line is a segmented bar coloured by status, scaled past 12 tasks", () => {
+	const colour = { fg: (name: string, s: string) => `<${name}>${s}` }
+	const tasks = [
+		{ name: "a", status: "complete" },
+		{ name: "b", status: "failed" },
+		{ name: "c", status: "in_progress" },
+		{ name: "d", status: "pending" },
+	] as never
+	const [line] = formatTrackerLines(ctxFrom({ tasks }), colour)
+	assert.ok(line.includes("<success>▰<error>▰<warning>▰<dim>▱"), line)
+	assert.ok(line.includes("1/4"), line)
+	assert.ok(!line.includes("✓"), "no check-mark run")
+	const many = Array.from({ length: 40 }, (_, i) => ({ name: `t${i}`, status: i < 20 ? "complete" : "pending" })) as never
+	const [scaled] = formatTrackerLines(ctxFrom({ tasks: many }), theme)
+	assert.equal((scaled.match(/[▰▱]/g) ?? []).length, 10)
+	assert.ok(scaled.includes("▰▰▰▰▰▱▱▱▱▱"), scaled)
+})

package/test/transcript.test.ts

@@ -1,10 +1,12 @@
 import assert from "node:assert/strict"
 import test from "node:test"
-import { gutterThinking } from "../src/transcript.js"
+import { stripVTControlCharacters } from "node:util"
+import { Markdown, visibleWidth } from "@earendil-works/pi-tui"
+import { gutterThinking, wrapLine } from "../src/transcript.js"
 
-test("gutterThinking prefixes paragraph starts only", () => {
+test("gutterThinking prefixes every line of a plain paragraph", () => {
 	const input = "First thought\ncontinues here.\n\nSecond thought."
-	assert.equal(gutterThinking(input), "┊ First thought\ncontinues here.\n\n┊ Second thought.")
+	assert.equal(gutterThinking(input), "┊ First thought\n┊ continues here.\n\n┊ Second thought.")
 })
 
 test("gutterThinking leaves block syntax and fenced code alone", () => {
@@ -15,8 +17,53 @@ test("gutterThinking leaves block syntax and fenced code alone", () => {
 	)
 })
 
+test("a list or quote interrupting a paragraph keeps its syntax", () => {
+	assert.equal(gutterThinking("Plan:\n- one\n- two\n\nDone."), "┊ Plan:\n- one\n- two\n\n┊ Done.")
+	assert.equal(gutterThinking("Note\n> quoted\nlazy line"), "┊ Note\n> quoted\nlazy line")
+})
+
 test("gutterThinking is idempotent and handles empty input", () => {
 	assert.equal(gutterThinking(""), "")
 	const once = gutterThinking("a\n\nb")
 	assert.equal(gutterThinking(once), once)
+	const wrapped = gutterThinking("one two three four five six seven eight nine ten eleven", 24)
+	assert.equal(gutterThinking(wrapped, 24), wrapped)
+})
+
+test("with a width, paragraphs are pre-wrapped so wrapped lines carry the gutter", () => {
+	const out = gutterThinking("alpha beta gamma delta epsilon zeta eta theta iota kappa", 24)
+	assert.deepEqual(out.split("\n"), ["┊ alpha beta gamma delta", "┊ epsilon zeta eta theta", "┊ iota kappa"])
+	for (const line of out.split("\n")) assert.ok(visibleWidth(line) <= 24, line)
+})
+
+test("narrow or unknown widths fall back to prefixing source lines", () => {
+	const long = "alpha beta gamma delta epsilon zeta eta theta"
+	assert.equal(gutterThinking(long, 10), `┊ ${long}`)
+	assert.equal(gutterThinking(long), `┊ ${long}`)
+})
+
+test("wrapLine keeps inline code whole and splits over-wide words", () => {
+	assert.deepEqual(wrapLine("use `ctx.ui.confirm here` now", 12), ["use", "`ctx.ui.confirm here`", "now"])
+	assert.deepEqual(wrapLine("see https://example.com/a/very/long/path", 12), ["see", "https://exam", "ple.com/a/ve", "ry/long/path"])
+	assert.deepEqual(wrapLine("", 12), [""])
+})
+
+test("rendered through pi-tui Markdown, every line has the gutter and fits the width", () => {
+	const theme = new Proxy({}, { get: () => (s: string) => s }) as never
+	const thinking =
+		"There's an existing **/subagents** admin TUI with field editing, including `override removal`. " +
+		"I should check what it covers so the roster feature doesn't duplicate it — maybe I can hook into it instead, " +
+		"like adding model/fallback editing there.\n\nThen the `/roster` command."
+	for (const width of [40, 80, 120]) {
+		const md = new Markdown(thinking, 0, 0, theme, { color: (s: string) => s, italic: true }, {
+			transform: (text: string, available: number) => gutterThinking(text, available),
+		} as never)
+		const lines = md.render(width).map((line) => stripVTControlCharacters(line).trimEnd())
+		const content = lines.filter((line) => line.length > 0)
+		assert.ok(content.length >= 3, `width ${width}: ${JSON.stringify(lines)}`)
+		for (const line of content) {
+			assert.ok(line.startsWith("┊ "), `width ${width}: ${JSON.stringify(line)}`)
+			assert.ok(visibleWidth(line) <= width, `width ${width}: ${line}`)
+		}
+	}
 })

package/themes/minimal-dark.json

@@ -7,8 +7,8 @@
 		"panel": "okhsl(230 5% 17%)",
 		"text": "okhsl(234 3% 90%)",
 		"muted": "okhsl(229 6% 64%)",
-		"dim": "okhsl(229 7% 48%)",
-		"faint": "okhsl(230 6% 34%)",
+		"dim": "okhsl(229 7% 56%)",
+		"faint": "okhsl(230 6% 36%)",
 		"violet": "okhsl(295 50% 67%)",
 		"violetSoft": "okhsl(295 45% 74%)",
 		"blue": "okhsl(232 54% 67%)",
@@ -29,7 +29,7 @@
 		"muted": "muted",
 		"dim": "dim",
 		"text": "text",
-		"thinkingText": "okhsl(229 6% 52%)",
+		"thinkingText": "okhsl(229 6% 58%)",
 		"selectedBg": "userBg",
 		"scrollbarTrack": "faint",
 		"scrollbarThumb": "dim",
@@ -40,8 +40,8 @@
 		"customMessageBg": "okhsl(295 30% 20%)",
 		"customMessageText": "muted",
 		"customMessageLabel": "violet",
-		"toolPendingBg": "panel",
-		"toolSuccessBg": "panel",
+		"toolPendingBg": "bg",
+		"toolSuccessBg": "bg",
 		"toolErrorBg": "errorBg",
 		"toolTitle": "text",
 		"toolOutput": "dim",
@@ -60,10 +60,10 @@
 		"toolDiffContext": "dim",
 		"syntaxComment": "dim",
 		"syntaxKeyword": "blue",
-		"syntaxFunction": "yellow",
+		"syntaxFunction": "okhsl(265 45% 76%)",
 		"syntaxVariable": "okhsl(202 58% 70%)",
 		"syntaxString": "okhsl(52 67% 70%)",
-		"syntaxNumber": "green",
+		"syntaxNumber": "okhsl(180 40% 68%)",
 		"syntaxType": "violet",
 		"syntaxOperator": "muted",
 		"syntaxPunctuation": "muted",