@oh-my-pi/pi-coding-agent 15.11.3 → 15.11.6

package/src/tools/job.ts

@@ -5,6 +5,7 @@ import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import type { AsyncJob, AsyncJobManager } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { shimmerEnabled, shimmerText } from "../modes/theme/shimmer";
 import type { Theme } from "../modes/theme/theme";
 import jobDescription from "../prompts/tools/job.md" with { type: "text" };
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
@@ -493,8 +494,15 @@ export const jobToolRenderer = {
 			render(width: number): readonly string[] {
 				const expanded = options.expanded;
 				const spinnerFrame = options.spinnerFrame ?? 0;
-				const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).digest();
-				if (cached?.key === key) return cached.lines;
+				// Running-job labels shimmer while the poll block is live; the band
+				// phase is Date.now()-sampled at render time, so serving cached bytes
+				// would pin it to the ~12.5fps spinner-glyph cadence instead of the
+				// 30fps redraw. Bypass the cache while any row animates, and key on
+				// the animation state so a sealed block never hits stale shimmered
+				// bytes (spinnerFrame falls back to 0 on both sides of the seal).
+				const shimmerActive = counts.running > 0 && options.spinnerFrame !== undefined && shimmerEnabled();
+				const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).bool(shimmerActive).digest();
+				if (!shimmerActive && cached?.key === key) return cached.lines;
 
 				const itemLines = renderTreeList<JobSnapshot>(
 					{
@@ -513,7 +521,9 @@ export const jobToolRenderer = {
 											job.status === "running" ? options.spinnerFrame : undefined,
 										);
 							const typeBadge = formatBadge(job.type, statusToColor(job.status), uiTheme);
-							const idText = uiTheme.fg("muted", job.id);
+							// Task jobs label themselves with their agent id, which is also
+							// the job id — drop the id column instead of stuttering it twice.
+							const idPart = job.label.trim() === job.id ? "" : ` ${uiTheme.fg("muted", job.id)}`;
 							const rawLabelLines = (job.label || "(no label)").split(/\r?\n/);
 							const maxLabelLines = expanded ? LABEL_LINES_EXPANDED : LABEL_LINES_COLLAPSED;
 							const visibleLabelLines = rawLabelLines
@@ -524,8 +534,18 @@ export const jobToolRenderer = {
 								visibleLabelLines[visibleLabelLines.length - 1] = `${last} …`;
 							}
 							const durationText = uiTheme.fg("dim", formatDuration(job.durationMs));
-							const headLabel = uiTheme.fg("toolOutput", visibleLabelLines[0] ?? "");
-							lines.push(`${icon} ${idText} ${typeBadge} ${headLabel} ${durationText}`);
+							// Running rows in a live block shimmer their label; once the block
+							// stops animating (sealed, or a settled snapshot — spinnerFrame
+							// cleared) they render static so scrollback never keeps a mid-sweep
+							// shimmer band.
+							const live = job.status === "running" && options.spinnerFrame !== undefined;
+							const headRaw = visibleLabelLines[0] ?? "";
+							const headLabel = live
+								? shimmerEnabled()
+									? shimmerText(headRaw, uiTheme)
+									: uiTheme.fg("accent", headRaw)
+								: uiTheme.fg("toolOutput", headRaw);
+							lines.push(`${icon}${idPart} ${typeBadge} ${headLabel} ${durationText}`);
 							for (let i = 1; i < visibleLabelLines.length; i++) {
 								lines.push(`  ${uiTheme.fg("toolOutput", visibleLabelLines[i]!)}`);
 							}

package/src/tools/read.ts

@@ -736,17 +736,6 @@ interface ResolvedSqliteReadPath {
 /** Per-execute memo of suffix-glob lookups; `null` records a confirmed miss. */
 type SuffixMatchCache = Map<string, { absolutePath: string; displayPath: string } | null>;
 
-/**
- * Repeated whole-file reads of the same path pin stale copies in context.
- * From this per-session read count onward, file reads carry a trailing nudge
- * to prefer narrower re-reads.
- */
-const REPEAT_READ_NOTICE_THRESHOLD = 3;
-
-function formatRepeatReadNotice(count: number): string {
-	return `[note: read #${count} of this file this session — after edits, prefer the context echoed in the edit result or a narrow range re-read]`;
-}
-
 /**
  * Read tool implementation.
  *
@@ -765,8 +754,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly #autoResizeImages: boolean;
 	readonly #defaultLimit: number;
 	readonly #inspectImageEnabled: boolean;
-	/** Successful file reads per resolved base path (selector stripped) this session. */
-	readonly #readCounts = new Map<string, number>();
 
 	constructor(private readonly session: ToolSession) {
 		const displayMode = resolveFileDisplayMode(session);
@@ -785,19 +772,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		});
 	}
 
-	/**
-	 * Count a file read of `absolutePath` and return the repeat-read nudge once
-	 * the per-session count reaches {@link REPEAT_READ_NOTICE_THRESHOLD}.
-	 * Non-file sources (URLs, internal resources, directories, archives,
-	 * SQLite, images) are never counted.
-	 */
-	#repeatReadNotice(absolutePath: string): string | undefined {
-		const count = (this.#readCounts.get(absolutePath) ?? 0) + 1;
-		this.#readCounts.set(absolutePath, count);
-		if (count < REPEAT_READ_NOTICE_THRESHOLD) return undefined;
-		return formatRepeatReadNotice(count);
-	}
-
 	async #tryReadDelimitedPaths(
 		readPath: string,
 		signal?: AbortSignal,
@@ -974,8 +948,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			ignoreResultLimits?: boolean;
 			raw?: boolean;
 			immutable?: boolean;
-			/** Trailing repeat-read nudge; appended at the very end of the text. */
-			repeatNotice?: string;
 		},
 	): AgentToolResult<ReadToolDetails> {
 		const displayMode = resolveFileDisplayMode(this.session, { raw: options.raw, immutable: options.immutable });
@@ -1120,9 +1092,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					: formatLineEntries(buildLineEntries(endLine), startLineDisplay);
 		}
 
-		if (options.repeatNotice) {
-			outputText += `\n${options.repeatNotice}`;
-		}
 		resultBuilder.text(outputText);
 		if (truncationInfo) {
 			resultBuilder.truncation(truncationInfo.result, truncationInfo.options);
@@ -1148,8 +1117,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			entityLabel: string;
 			raw?: boolean;
 			immutable?: boolean;
-			/** Trailing repeat-read nudge; appended at the very end of the text. */
-			repeatNotice?: string;
 		},
 	): AgentToolResult<ReadToolDetails> {
 		const displayMode = resolveFileDisplayMode(this.session, { raw: options.raw, immutable: options.immutable });
@@ -1210,11 +1177,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const bound = range.endLine !== undefined ? `${range.startLine}-${range.endLine}` : `${range.startLine}`;
 			notices.push(`[Range ${bound} is beyond end of ${options.entityLabel} (${totalLines} lines total); skipped]`);
 		}
-		let finalText =
+		const finalText =
 			notices.length > 0 ? (outputText ? `${outputText}\n${notices.join("\n")}` : notices.join("\n")) : outputText;
-		if (options.repeatNotice) {
-			finalText = finalText ? `${finalText}\n${options.repeatNotice}` : options.repeatNotice;
-		}
 		resultBuilder.text(finalText);
 		return resultBuilder.done();
 	}
@@ -1232,7 +1196,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		parsed: ParsedSelector,
 		displayMode: { hashLines: boolean; lineNumbers: boolean },
 		suffixResolution: { from: string; to: string } | undefined,
-		repeatNotice: string | undefined,
 		signal: AbortSignal | undefined,
 	): Promise<{
 		outputText: string;
@@ -1252,7 +1215,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					sourcePath: absolutePath,
 					entityLabel: "file",
 					raw: rawSelector,
-					repeatNotice,
 				});
 				if (suffixResolution) {
 					const notice = `[Path '${suffixResolution.from}' not found; resolved to '${suffixResolution.to}' via suffix match]`;
@@ -1934,7 +1896,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		let details: ReadToolDetails = {};
 		let sourcePath: string | undefined;
 		let columnTruncated = 0;
-		let repeatNotice: string | undefined;
 		let truncationInfo:
 			| { result: TruncationResult; options: { direction: "head"; startLine?: number; totalFileLines?: number } }
 			| undefined;
@@ -1999,13 +1960,11 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			}
 		} else if (isNotebookPath(absolutePath) && !isRawSelector(parsed)) {
 			const notebookText = await readEditableNotebookText(absolutePath, localReadPath);
-			repeatNotice = this.#repeatReadNotice(absolutePath);
 			if (isMultiRange(parsed) && parsed.kind === "lines") {
 				return this.#buildInMemoryMultiRangeResult(notebookText, parsed.ranges, {
 					details: { resolvedPath: absolutePath },
 					sourcePath: absolutePath,
 					entityLabel: "notebook",
-					repeatNotice,
 				});
 			}
 			const { offset, limit } = selToOffsetLimit(parsed);
@@ -2013,13 +1972,11 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				details: { resolvedPath: absolutePath },
 				sourcePath: absolutePath,
 				entityLabel: "notebook",
-				repeatNotice,
 			});
 		} else if (shouldConvertWithMarkit) {
 			// Convert document via markit.
 			const result = await convertFileWithMarkit(absolutePath, signal);
 			if (result.ok) {
-				repeatNotice = this.#repeatReadNotice(absolutePath);
 				// Route the converted markdown through the in-memory text builder
 				// so line-range selectors (`file.pdf:50-100`, `:5-16,40-80`) and
 				// raw mode apply against the converted output. Without this,
@@ -2030,7 +1987,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						details: { resolvedPath: absolutePath },
 						sourcePath: absolutePath,
 						entityLabel: "document",
-						repeatNotice,
 					});
 				}
 				const { offset, limit } = selToOffsetLimit(parsed);
@@ -2039,7 +1995,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					sourcePath: absolutePath,
 					entityLabel: "document",
 					raw: isRawSelector(parsed),
-					repeatNotice,
 				});
 			} else if (result.error) {
 				content = [{ type: "text", text: `[Cannot read ${ext} file: ${result.error || "conversion failed"}]` }];
@@ -2047,7 +2002,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				content = [{ type: "text", text: `[Cannot read ${ext} file: conversion failed]` }];
 			}
 		} else {
-			repeatNotice = this.#repeatReadNotice(absolutePath);
 			if (
 				parsed.kind === "none" &&
 				this.session.settings.get("read.summarize.enabled") &&
@@ -2089,7 +2043,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						parsed,
 						displayMode,
 						suffixResolution,
-						repeatNotice,
 						undefined, // plain-file read: deterministic and fast, never abort mid-read
 					);
 					if (multiResult.bridgeResult) return multiResult.bridgeResult;
@@ -2113,7 +2066,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 								sourcePath: absolutePath,
 								entityLabel: "file",
 								raw: isRawSelector(parsed),
-								repeatNotice,
 							});
 							if (suffixResolution) {
 								const notice = `[Path '${suffixResolution.from}' not found; resolved to '${suffixResolution.to}' via suffix match]`;
@@ -2415,14 +2367,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				content = [{ type: "text", text: notice }, ...content];
 			}
 		}
-		if (repeatNotice) {
-			// Trailing nudge goes at the very end of the textual result so it never
-			// disturbs hashline tag headers or inline notices.
-			const lastText = content.findLast((c): c is TextContent => c.type === "text");
-			if (lastText) {
-				lastText.text = `${lastText.text}\n${repeatNotice}`;
-			}
-		}
 		const resultBuilder = toolResult(details).content(content);
 		if (sourcePath) {
 			resultBuilder.sourcePath(sourcePath);

package/src/tools/render-utils.ts

@@ -183,24 +183,32 @@ export function formatMoreItems(remaining: number, itemType: string): string {
 }
 
 /**
- * Maximum rows a tool's streaming/pending *call* preview may render before it is
- * capped. This is intentionally conservative: the preview still sits inside a
- * transcript that already consumed some viewport rows, and tool blocks carry
- * extra chrome (status/header/border/"more lines"), so a "reasonable" raw code
- * or command preview like 10-12 lines can still overflow and strand its top
- * while the block is volatile. Keeping the live call window short avoids that
- * across terminals without turning the transcript into an interactive scroller.
+ * Collapsed command/code previews render a tail window sized from the live
+ * viewport: terminal rows minus a reserve for the rest of the block (frame,
+ * Output section, stats line) and the editor/status area below the
+ * transcript. This keeps a volatile streaming block from growing past the
+ * viewport and stranding its top, while letting tall terminals show more.
  */
-export const CALL_PREVIEW_MAX_LINES = 6;
+const PREVIEW_WINDOW_RESERVED_ROWS = 20;
+/** Floor so tiny or unknown viewports still show a useful window. */
+const PREVIEW_WINDOW_MIN_LINES = 6;
+/** Assumed viewport when rows are unknown (non-TTY, tests). */
+const PREVIEW_WINDOW_FALLBACK_ROWS = 30;
+
+/** Tail-window height for collapsed command/code previews. */
+export function previewWindowRows(): number {
+	const rows = process.stdout.rows || PREVIEW_WINDOW_FALLBACK_ROWS;
+	return Math.max(PREVIEW_WINDOW_MIN_LINES, rows - PREVIEW_WINDOW_RESERVED_ROWS);
+}
 
 /**
- * Cap a pre-rendered pending/call preview to a bounded window. When truncated,
- * show both the head and the live tail so the user can still see what the tool
- * is currently writing while the volatile block stays short enough not to strand
- * its top above the viewport. `Ctrl+O` widens the bounded window, but does not
- * fully uncap live tool previews for the same reason.
+ * Cap a pre-rendered command preview to a viewport-sized tail window: the end
+ * of the command stays visible (it is the live edge while args stream) behind
+ * an "… N earlier lines" marker on top. The same window applies while
+ * streaming and after completion so the block never jumps; only `expanded`
+ * (ctrl+o) uncaps it.
  *
- * `prefix` (raw, e.g. a dim tree gutter) is prepended to the summary line so
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the marker line so
  * nested previews stay aligned.
  */
 export function capPreviewLines(
@@ -208,24 +216,14 @@ export function capPreviewLines(
 	theme: Theme,
 	options: { max?: number; expanded?: boolean; prefix?: string } = {},
 ): string[] {
-	const max = options.max ?? (options.expanded ? PREVIEW_LIMITS.EXPANDED_LINES : CALL_PREVIEW_MAX_LINES);
+	if (options.expanded) return lines;
+	const max = options.max ?? previewWindowRows();
 	if (lines.length <= max) return lines;
-	if (max <= 1) {
-		const hint = formatExpandHint(theme, options.expanded, true);
-		const moreLine = `${formatMoreItems(lines.length, "line")}${hint ? ` ${hint}` : ""}`;
-		return [`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`];
-	}
-	const bodyBudget = max - 1; // reserve one summary row
-	const headCount = Math.max(1, Math.ceil(bodyBudget / 2));
-	const tailCount = Math.max(1, bodyBudget - headCount);
-	const hidden = Math.max(0, lines.length - headCount - tailCount);
-	const hint = formatExpandHint(theme, options.expanded, true);
-	const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
-	return [
-		...lines.slice(0, headCount),
-		`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`,
-		...lines.slice(lines.length - tailCount),
-	];
+	const visible = max <= 1 ? [] : lines.slice(lines.length - (max - 1));
+	const hidden = lines.length - visible.length;
+	const hint = formatExpandHint(theme, false, true);
+	const marker = `… ${hidden} earlier ${pluralize("line", hidden)}${hint ? ` ${hint}` : ""}`;
+	return [`${options.prefix ?? ""}${theme.fg("dim", marker)}`, ...visible];
 }
 
 export function formatMeta(meta: string[], theme: Theme): string {

package/src/tools/ssh.ts

@@ -329,9 +329,9 @@ export const sshToolRenderer = {
 						state: "success",
 						sections: [
 							{
-								lines: options.isPartial
-									? capPreviewLines(cmdLines, uiTheme, { expanded: options.expanded })
-									: cmdLines,
+								// Viewport-sized tail window in every state — streaming and final
+								// render identically; only ctrl+o uncaps.
+								lines: capPreviewLines(cmdLines, uiTheme, { expanded }),
 							},
 							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
 						],

package/src/tools/todo.ts

@@ -21,13 +21,6 @@ export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
 export interface TodoItem {
 	content: string;
 	status: TodoStatus;
-	/**
-	 * Append-only list of freeform notes attached by `op: "note"`.
-	 * Each element is one note and may itself be multi-line.
-	 * Rendered as text only when the task is in_progress; otherwise shown as a
-	 * dim marker indicating the task has notes.
-	 */
-	notes?: string[];
 }
 
 export interface TodoPhase {
@@ -51,7 +44,7 @@ export interface TodoToolDetails {
 // =============================================================================
 
 const TodoOp = z
-	.enum(["init", "start", "done", "rm", "drop", "append", "note", "view"] as const)
+	.enum(["init", "start", "done", "rm", "drop", "append", "view"] as const)
 	.describe("operation to apply");
 
 const InitListEntry = z.object({
@@ -65,7 +58,6 @@ const TodoOpEntry = z.object({
 	task: z.string().optional().describe("task content"),
 	phase: z.string().optional().describe("phase name"),
 	items: z.array(z.string().describe("task content")).min(1).optional().describe("tasks to append"),
-	text: z.string().optional().describe("note text"),
 });
 
 const todoSchema = z
@@ -94,9 +86,7 @@ function findPhaseByName(phases: TodoPhase[], name: string): TodoPhase | undefin
 }
 
 function cloneTask(task: TodoItem): TodoItem {
-	const out: TodoItem = { content: task.content, status: task.status };
-	if (task.notes && task.notes.length > 0) out.notes = [...task.notes];
-	return out;
+	return { content: task.content, status: task.status };
 }
 
 function clonePhases(phases: TodoPhase[]): TodoPhase[] {
@@ -392,17 +382,6 @@ function applyEntry(phases: TodoPhase[], entry: TodoOpEntryValue, errors: string
 		}
 		case "rm":
 			return removeTasks(phases, entry, errors);
-		case "note": {
-			const hit = resolveTaskOrError(phases, entry.task, errors);
-			if (!hit) return phases;
-			const text = (entry.text ?? "").replace(/\s+$/u, "");
-			if (!text) {
-				errors.push("Missing text for note operation");
-				return phases;
-			}
-			hit.task.notes = hit.task.notes ? [...hit.task.notes, text] : [text];
-			return phases;
-		}
 		case "append":
 			return appendItems(phases, entry, errors);
 		case "view":
@@ -448,14 +427,6 @@ export function phasesToMarkdown(phases: TodoPhase[]): string {
 		out.push(`# ${phases[i].name}`);
 		for (const task of phases[i].tasks) {
 			out.push(`- [${STATUS_TO_MARKER[task.status]}] ${task.content}`);
-			if (task.notes && task.notes.length > 0) {
-				for (let j = 0; j < task.notes.length; j++) {
-					if (j > 0) out.push("  >");
-					for (const noteLine of task.notes[j].split("\n")) {
-						out.push(noteLine === "" ? "  >" : `  > ${noteLine}`);
-					}
-				}
-			}
 		}
 	}
 	return `${out.join("\n")}\n`;
@@ -477,45 +448,16 @@ export function markdownToPhases(md: string): { phases: TodoPhase[]; errors: str
 	const errors: string[] = [];
 	const phases: TodoPhase[] = [];
 	let currentPhase: TodoPhase | undefined;
-	let currentTask: TodoItem | undefined;
-	let noteBuf: string[] = [];
-
-	const flushNote = () => {
-		if (!currentTask || noteBuf.length === 0) {
-			noteBuf = [];
-			return;
-		}
-		while (noteBuf.length > 0 && noteBuf[noteBuf.length - 1] === "") noteBuf.pop();
-		if (noteBuf.length === 0) return;
-		const joined = noteBuf.join("\n");
-		currentTask.notes = currentTask.notes ? [...currentTask.notes, joined] : [joined];
-		noteBuf = [];
-	};
 
 	const lines = md.split(/\r?\n/);
 	for (let lineNum = 0; lineNum < lines.length; lineNum++) {
 		const raw = lines[lineNum];
 
-		// Blockquote line attached to the current task: `  > text` or `  >`
-		const noteMatch = /^\s*>\s?(.*)$/.exec(raw);
-		if (noteMatch && currentTask) {
-			const noteLine = noteMatch[1];
-			if (noteLine === "") {
-				// Blank `>` separates two distinct notes
-				flushNote();
-			} else {
-				noteBuf.push(noteLine);
-			}
-			continue;
-		}
-
 		const trimmed = raw.trim();
 		if (!trimmed) continue;
 
 		const headingMatch = /^#{1,6}\s+(.+?)\s*$/.exec(trimmed);
 		if (headingMatch) {
-			flushNote();
-			currentTask = undefined;
 			currentPhase = { name: headingMatch[1].trim(), tasks: [] };
 			phases.push(currentPhase);
 			continue;
@@ -523,7 +465,6 @@ export function markdownToPhases(md: string): { phases: TodoPhase[]; errors: str
 
 		const taskMatch = /^[-*+]\s*\[(.?)\]\s+(.+?)\s*$/.exec(trimmed);
 		if (taskMatch) {
-			flushNote();
 			if (!currentPhase) {
 				currentPhase = { name: "Todos", tasks: [] };
 				phases.push(currentPhase);
@@ -532,19 +473,14 @@ export function markdownToPhases(md: string): { phases: TodoPhase[]; errors: str
 			const status = MARKER_TO_STATUS[marker];
 			if (!status) {
 				errors.push(`Line ${lineNum + 1}: unknown status marker "[${marker}]" (use [ ], [x], [/], [-])`);
-				currentTask = undefined;
 				continue;
 			}
-			currentTask = { content: taskMatch[2].trim(), status };
-			currentPhase.tasks.push(currentTask);
+			currentPhase.tasks.push({ content: taskMatch[2].trim(), status });
 			continue;
 		}
 
-		flushNote();
-		currentTask = undefined;
 		errors.push(`Line ${lineNum + 1}: unrecognized syntax "${trimmed}"`);
 	}
-	flushNote();
 
 	normalizeInProgressTask(phases);
 	return { phases, errors };
@@ -596,17 +532,7 @@ function formatSummary(phases: TodoPhase[], errors: string[], readOnly = false):
 						: task.status === "abandoned"
 							? "✗"
 							: "○";
-			const noteCount = task.notes?.length ?? 0;
-			const noteMarker = noteCount > 0 ? ` (+${noteCount} note${noteCount === 1 ? "" : "s"})` : "";
-			lines.push(`    ${sym} ${task.content}${noteMarker}`);
-			if (task.status === "in_progress" && task.notes && task.notes.length > 0) {
-				for (let j = 0; j < task.notes.length; j++) {
-					if (j > 0) lines.push("        ---");
-					for (const noteLine of task.notes[j].split("\n")) {
-						lines.push(`        ${noteLine}`);
-					}
-				}
-			}
+			lines.push(`    ${sym} ${task.content}`);
 		}
 	}
 	return lines.join("\n");
@@ -675,27 +601,6 @@ type TodoRenderArgs = {
 	}>;
 };
 
-const SUP_DIGITS: Record<string, string> = {
-	"0": "\u2070",
-	"1": "\u00b9",
-	"2": "\u00b2",
-	"3": "\u00b3",
-	"4": "\u2074",
-	"5": "\u2075",
-	"6": "\u2076",
-	"7": "\u2077",
-	"8": "\u2078",
-	"9": "\u2079",
-};
-
-function toSuperscript(n: number): string {
-	return n
-		.toString()
-		.split("")
-		.map(d => SUP_DIGITS[d] ?? d)
-		.join("");
-}
-
 // =============================================================================
 // Phase numbering (display-only)
 // =============================================================================
@@ -735,11 +640,6 @@ export function formatPhaseDisplayName(name: string, oneBasedIndex: number): str
 	return `${phaseRomanNumeral(oneBasedIndex)}. ${name}`;
 }
 
-function noteMarker(count: number, uiTheme: Theme): string {
-	if (count <= 0) return "";
-	return uiTheme.fg("dim", chalk.italic(` \u207a${toSuperscript(count)}`));
-}
-
 export const TODO_STRIKE_HOLD_FRAMES = 2;
 export const TODO_STRIKE_REVEAL_FRAMES = 12;
 export const TODO_STRIKE_TOTAL_FRAMES = TODO_STRIKE_HOLD_FRAMES + TODO_STRIKE_REVEAL_FRAMES;
@@ -775,7 +675,6 @@ function formatTodoLine(
 	frame: number | undefined,
 ): string {
 	const checkbox = uiTheme.checkbox;
-	const marker = noteMarker(item.notes?.length ?? 0, uiTheme);
 	switch (item.status) {
 		case "completed": {
 			const revealCount = completionKeys.has(item.content) ? strikeRevealCount(item.content, frame) : undefined;
@@ -783,33 +682,15 @@ function formatTodoLine(
 				revealCount === undefined
 					? strikethroughText(item.content)
 					: partialStrikethrough(item.content, revealCount);
-			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${content}`) + marker;
+			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${content}`);
 		}
 		case "in_progress":
-			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
+			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`);
 		case "abandoned":
-			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(item.content)}`) + marker;
+			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(item.content)}`);
 		default:
-			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
-	}
-}
-
-function renderNoteAttachments(phases: TodoPhase[], uiTheme: Theme, indent: string): string[] {
-	const lines: string[] = [];
-	for (const phase of phases) {
-		for (const task of phase.tasks) {
-			if (task.status !== "in_progress" || !task.notes || task.notes.length === 0) continue;
-			lines.push("");
-			lines.push(`${indent}${uiTheme.fg("dim", chalk.italic(`§ notes — ${task.content}`))}`);
-			for (let j = 0; j < task.notes.length; j++) {
-				if (j > 0) lines.push("");
-				for (const noteLine of task.notes[j].split("\n")) {
-					lines.push(`${indent}  ${uiTheme.fg("dim", noteLine)}`);
-				}
-			}
-		}
+			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`);
 	}
-	return lines;
 }
 
 /**
@@ -966,7 +847,6 @@ export const todoToolRenderer = {
 					bodyLines.push(`${indent}${line}`);
 				}
 			}
-			bodyLines.push(...renderNoteAttachments(phases, uiTheme, indent));
 			while (bodyLines.length > 0 && bodyLines[0].trim() === "") bodyLines.shift();
 			return {
 				header,