pi-minimal 0.3.0 → 0.4.0

package/test/config.test.ts

@@ -30,85 +30,106 @@ test("defaults hideGauntletWidgets to true", (t) => {
 	const { agentDir, cwd } = setup(t)
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: true })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("global false overrides default", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("trusted project true overrides global false", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
-	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: true }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
+	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: true, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: true })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("untrusted project false does not override global true", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: true }))
-	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: true, editDiff: "expanded" }))
+	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
-	assert.deepEqual(config, { hideGauntletWidgets: true })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("omitted keys do not override", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify({}))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("unknown keys do not override", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify({ extra: true }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
 test("invalid JSON calls console.error and leaves the lower-precedence value unchanged", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, "{")
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
 test("non-object root calls console.error and leaves the lower-precedence value unchanged", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify(["hideGauntletWidgets", false]))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
 test("non-boolean hideGauntletWidgets calls console.error and leaves the lower-precedence value unchanged", (t) => {
 	const { agentDir, cwd } = setup(t)
-	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false }))
+	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: "yes" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
 	assert.ok(error.mock.callCount() >= 1)
 })
+
+test("editDiff accepts always, never and expanded, layered like other keys", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ editDiff: "always" }))
+	writeProject(cwd, JSON.stringify({ editDiff: "never" }))
+	const error = t.mock.method(console, "error")
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).editDiff, "always")
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true }).editDiff, "never")
+	assert.equal(error.mock.callCount(), 0)
+})
+
+test("an invalid editDiff value is reported and does not override", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ editDiff: "always", hideGauntletWidgets: false }))
+	writeProject(cwd, JSON.stringify({ editDiff: "sometimes" }))
+	const error = t.mock.method(console, "error")
+	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "always" })
+	assert.equal(error.mock.callCount(), 1)
+	assert.match(String(error.mock.calls[0]!.arguments[0]), /editDiff must be one of "always", "never", "expanded"/)
+})

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.3.0")
-	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/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,18 @@
 import assert from "node:assert/strict"
 import test from "node:test"
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { codemodeRenderers, compactRenderers, installToolRenderers, isToolKind, stopLiveWatch } from "../src/tools.js"
+import {
+	codemodeRenderers,
+	compactRenderers,
+	genericItem,
+	genericOutcome,
+	genericRenderers,
+	genericVerb,
+	installToolRenderers,
+	isToolKind,
+	setEditDiffMode,
+	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 +30,12 @@ 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!("mcp__foo__bar", () => 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 }
@@ -90,7 +106,7 @@ test("codemode renders one parent row plus one child row per nested call, no scr
 	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+cd ~\/r && sed -n 1,2p a.md\s+0.6s$/)
+	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)
@@ -123,3 +139,105 @@ test("codemode shows nested calls live while the script is still running", () =>
 	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"])
+})
+
+// pi's edit tool emits its own line-numbered form, not a unified diff: "+123 content", "-123 content", " 123 context", "..." between hunks.
+const EDIT_DIFF = " 1 context\n-2 const a = old(x)\n+2 const a = fresh(x)\n 3 context"
+const editResult = { content: [{ type: "text", text: "Successfully replaced 1 block(s)" }], details: { diff: EDIT_DIFF } }
+function editRows(expanded: boolean, result: unknown = editResult, isError = false): string[] {
+	const renderers = compactRenderers("edit")
+	const context = { args: { path: "a.ts" }, toolCallId: "e1", invalidate() {}, state: {}, isPartial: false, isError, durationMs: 100 } as never
+	const theme = {
+		fg: (c: string, s: string) => (c.startsWith("toolDiff") ? `<${c.slice(8).toLowerCase()}>${s}` : s),
+		inverse: (s: string) => `[${s}]`,
+	} as never
+	const block = renderers.renderResult!(result as never, { expanded, isPartial: false } as never, theme, context)
+	return block.render(80).map((line) => line.trimEnd())
+}
+
+test("editDiff=expanded (default) shows the diff only behind ctrl+o, in the theme's diff colours", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("expanded")
+	assert.deepEqual(editRows(false), [])
+	const rows = editRows(true)
+	assert.equal(rows.length, 4)
+	assert.match(rows[0]!, /│ <context> 1 context$/)
+	assert.match(rows[1]!, /│ <removed>-2 const a = /)
+	assert.match(rows[2]!, /│ <added>\+2 const a = /)
+	assert.ok(rows.every((row) => !row.includes("Successfully replaced")), "the diff replaces the result text")
+})
+
+test("a one-line replacement highlights only the changed tokens with inverse", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("expanded")
+	const [, removed, added] = editRows(true)
+	assert.match(removed!, /-2 const a = \[old\]\(x\)$/)
+	assert.match(added!, /\+2 const a = \[fresh\]\(x\)$/)
+	const multi = editRows(true, { content: [], details: { diff: "-1 a\n-2 b\n+1 c" } })
+	assert.ok(multi.every((row) => !row.includes("[")), "blocks that are not 1:1 are not token-highlighted")
+})
+
+test("editDiff=always shows the diff inline and editDiff=never only on request falls back to the result text", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("always")
+	assert.equal(editRows(false).length, 4)
+	assert.equal(editRows(true).length, 4)
+	setEditDiffMode("never")
+	assert.deepEqual(editRows(false), [])
+	assert.match(editRows(true)[0]!, /│ Successfully replaced 1 block\(s\)$/)
+})
+
+test("editDiff=always truncates a long inline diff and leaves the full diff to ctrl+o", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("always")
+	const long = { content: [{ type: "text", text: "ok" }], details: { diff: Array.from({ length: 60 }, (_, i) => `+${i + 1} line ${i}`).join("\n") } }
+	const inline = editRows(false, long)
+	assert.equal(inline.length, 41)
+	assert.match(inline[40]!, /… 20 more lines \(ctrl\+o\)$/)
+	assert.equal(editRows(true, long).length, 60)
+})
+
+test("edit failures and results without a diff never render a diff block", (t) => {
+	t.after(() => setEditDiffMode("expanded"))
+	setEditDiffMode("always")
+	assert.deepEqual(editRows(false, { content: [{ type: "text", text: "edited" }] }), [])
+	const failed = editRows(false, { content: [{ type: "text", text: "oldText not found" }] }, true)
+	assert.ok(failed.every((row) => !row.includes("<removed>")))
+})

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}`)
+		}
+	}
 })