@oh-my-pi/pi-coding-agent 14.4.0 → 14.4.3

package/src/tools/read.ts

@@ -9,20 +9,11 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { formatHashLines } from "../edit/line-hash";
-import {
-	type ChunkReadTarget,
-	formatChunkedRead,
-	parseChunkReadPath,
-	parseChunkSelector,
-	resolveAnchorStyle,
-	resolveChunkAutoIndent,
-} from "../edit/modes/chunk";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { parseInternalUrl } from "../internal-urls/parse";
 import type { InternalUrl } from "../internal-urls/types";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import readDescription from "../prompts/tools/read.md" with { type: "text" };
-import readChunkDescription from "../prompts/tools/read-chunk.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import {
 	DEFAULT_MAX_BYTES,
@@ -34,7 +25,6 @@ import {
 } from "../session/streaming-output";
 import { renderCodeCell, renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
-import { resolveEditMode } from "../utils/edit-mode";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { ImageInputTooLargeError, loadImageInput, MAX_IMAGE_INPUT_BYTES } from "../utils/image-loading";
 import { convertFileWithMarkit } from "../utils/markit";
@@ -71,12 +61,6 @@ import {
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const PROSE_LANGUAGES = new Set(["markdown", "text", "log", "asciidoc", "restructuredtext"]);
-
-function isProseLanguage(language: string | undefined): boolean {
-	return language !== undefined && PROSE_LANGUAGES.has(language);
-}
-
 // Document types converted to markdown via markit.
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);
 
@@ -92,17 +76,13 @@ function prependLineNumbers(text: string, startNum: number): string {
 	return textLines.map((line, i) => `${startNum + i}|${line}`).join("\n");
 }
 
-function prependHashLines(text: string, startNum: number): string {
-	return formatHashLines(text, startNum);
-}
-
 function formatTextWithMode(
 	text: string,
 	startNum: number,
 	shouldAddHashLines: boolean,
 	shouldAddLineNumbers: boolean,
 ): string {
-	if (shouldAddHashLines) return prependHashLines(text, startNum);
+	if (shouldAddHashLines) return formatHashLines(text, startNum);
 	if (shouldAddLineNumbers) return prependLineNumbers(text, startNum);
 	return text;
 }
@@ -362,7 +342,7 @@ function prependSuffixResolutionNotice(text: string, suffixResolution?: { from:
 
 const readSchema = Type.Object({
 	path: Type.String({ description: "path or url", examples: ["src/foo.ts", "https://example.com"] }),
-	sel: Type.Optional(Type.String({ description: "line range or mode", examples: ["L50", "L50-L120", "raw"] })),
+	sel: Type.Optional(Type.String({ description: "line range or mode", examples: ["50", "50-200", "50+150", "raw"] })),
 	timeout: Type.Optional(Type.Number({ description: "timeout in seconds", default: 20 })),
 });
 
@@ -374,7 +354,6 @@ export interface ReadToolDetails {
 	isDirectory?: boolean;
 	resolvedPath?: string;
 	suffixResolution?: { from: string; to: string };
-	chunk?: ChunkReadTarget;
 	url?: string;
 	finalUrl?: string;
 	contentType?: string;
@@ -393,28 +372,37 @@ type ReadParams = ReadToolInput;
 type ParsedSelector =
 	| { kind: "none" }
 	| { kind: "raw" }
-	| { kind: "lines"; startLine: number; endLine: number | undefined }
-	| { kind: "chunk"; selector: string };
+	| { kind: "lines"; startLine: number; endLine: number | undefined };
 
-const LINE_RANGE_RE = /^L(\d+)(?:-L?(\d+))?$/i;
+const LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+))?$/i;
 
 function parseSel(sel: string | undefined): ParsedSelector {
 	if (!sel || sel.length === 0) return { kind: "none" };
-	const normalizedSelector = parseChunkSelector(sel).selector ?? sel;
-	if (normalizedSelector === "raw") return { kind: "raw" };
-	const lineMatch = LINE_RANGE_RE.exec(normalizedSelector);
+	if (sel === "raw") return { kind: "raw" };
+	const lineMatch = LINE_RANGE_RE.exec(sel);
 	if (lineMatch) {
 		const rawStart = Number.parseInt(lineMatch[1]!, 10);
 		if (rawStart < 1) {
-			throw new ToolError("L0 is invalid; lines are 1-indexed. Use sel=L1.");
+			throw new ToolError("sel=0 is invalid; lines are 1-indexed. Use sel=1.");
 		}
-		const rawEnd = lineMatch[2] ? Number.parseInt(lineMatch[2], 10) : undefined;
-		if (rawEnd !== undefined && rawEnd < rawStart) {
-			throw new ToolError(`Invalid range L${rawStart}-L${rawEnd}: end must be >= start.`);
+		const sep = lineMatch[2];
+		const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
+		let rawEnd: number | undefined;
+		if (sep === "+") {
+			if (rhs === undefined || rhs < 1) {
+				throw new ToolError(`Invalid range ${rawStart}+${rhs ?? 0}: count must be >= 1.`);
+			}
+			rawEnd = rawStart + rhs - 1;
+		} else if (sep === "-") {
+			if (rhs === undefined || rhs < rawStart) {
+				throw new ToolError(`Invalid range ${rawStart}-${rhs ?? 0}: end must be >= start.`);
+			}
+			rawEnd = rhs;
 		}
 		return { kind: "lines", startLine: rawStart, endLine: rawEnd };
 	}
-	return { kind: "chunk", selector: normalizedSelector };
+	// Unrecognized selectors fall through; sqlite/archive/url readers consume `sel` themselves.
+	return { kind: "none" };
 }
 
 /** Convert a line-range selector to the offset/limit pair used by internal pagination. */
@@ -481,18 +469,12 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			Math.min(session.settings.get("read.defaultLimit") ?? DEFAULT_MAX_LINES, DEFAULT_MAX_LINES),
 		);
 		this.#inspectImageEnabled = session.settings.get("inspect_image.enabled");
-		this.description =
-			resolveEditMode(session) === "chunk"
-				? prompt.render(readChunkDescription, {
-						anchorStyle: resolveAnchorStyle(session.settings),
-						chunkAutoIndent: resolveChunkAutoIndent(),
-					})
-				: prompt.render(readDescription, {
-						DEFAULT_LIMIT: String(this.#defaultLimit),
-						DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
-						IS_HASHLINE_MODE: displayMode.hashLines,
-						IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
-					});
+		this.description = prompt.render(readDescription, {
+			DEFAULT_LIMIT: String(this.#defaultLimit),
+			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
+			IS_HASHLINE_MODE: displayMode.hashLines,
+			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
+		});
 	}
 
 	async #resolveArchiveReadPath(readPath: string, signal?: AbortSignal): Promise<ResolvedArchiveReadPath | null> {
@@ -621,7 +603,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const suggestion =
 				allLines.length === 0
 					? `The ${options.entityLabel} is empty.`
-					: `Use sel=L1 to read from the start, or sel=L${allLines.length} to read the last line.`;
+					: `Use sel=1 to read from the start, or sel=${allLines.length} to read the last line.`;
 			return resultBuilder
 				.text(
 					`Line ${startLineDisplay} is beyond end of ${options.entityLabel} (${allLines.length} lines total). ${suggestion}`,
@@ -683,7 +665,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const nextOffset = startLine + userLimitedLines + 1;
 
 			outputText = formatText(selectedContent, startLineDisplay);
-			outputText += `\n\n[${remaining} more lines in ${options.entityLabel}. Use sel=L${nextOffset} to continue]`;
+			outputText += `\n\n[${remaining} more lines in ${options.entityLabel}. Use sel=${nextOffset} to continue]`;
 		} else {
 			outputText = formatText(truncation.content, startLineDisplay);
 		}
@@ -934,7 +916,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			readPath = expandPath(readPath);
 		}
 		const displayMode = resolveFileDisplayMode(this.session);
-		const chunkMode = resolveEditMode(this.session) === "chunk";
 
 		// Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://)
 		const internalRouter = this.session.internalRouter;
@@ -968,13 +949,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return executeReadUrl(this.session, { path: parsedUrlTarget.path, timeout, raw: parsedUrlTarget.raw }, signal);
 		}
 
-		const parsedReadPath = chunkMode ? parseChunkReadPath(readPath) : { filePath: readPath };
-		const localReadPath = parsedReadPath.filePath;
-		const pathSelectorParsed = chunkMode ? parseSel(parsedReadPath.selector) : { kind: "none" as const };
-		const pathChunkSelector = pathSelectorParsed.kind === "chunk" ? pathSelectorParsed.selector : undefined;
-		const selectorInput = sel ?? parsedReadPath.selector;
-		const rawSelectorInput = sel ?? parsedReadPath.selector;
-		const parsed = parseSel(selectorInput);
+		const localReadPath = readPath;
+		const parsed = parseSel(sel);
 
 		const archivePath = await this.#resolveArchiveReadPath(localReadPath, signal);
 		if (archivePath) {
@@ -1034,54 +1010,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const imageMetadata = await readImageMetadata(absolutePath);
 		const mimeType = imageMetadata?.mimeType;
 		const ext = path.extname(absolutePath).toLowerCase();
-		const hasEditTool = this.session.hasEditTool ?? true;
-		const language = getLanguageFromPath(absolutePath);
-		const skipChunksForExplore = !hasEditTool && !this.session.settings.get("read.explorechunks");
-		const skipChunksForProse = isProseLanguage(language) && !this.session.settings.get("read.prosechunks");
-		const shouldConvertWithMarkit =
-			CONVERTIBLE_EXTENSIONS.has(ext) || (ext === ".ipynb" && (parsed.kind === "raw" || !chunkMode));
-
-		if (chunkMode && parsed.kind !== "raw" && !skipChunksForExplore && !skipChunksForProse) {
-			const absoluteLineRange =
-				pathChunkSelector && parsed.kind === "lines"
-					? { startLine: parsed.startLine, endLine: parsed.endLine }
-					: undefined;
-			// sel= wins over path:chunk when both are provided (explicit param > embedded path).
-			const effectiveSelector = sel ? selectorInput : (pathChunkSelector ?? selectorInput);
-			const rawEffectiveSelector = sel ? selectorInput : (rawSelectorInput ?? effectiveSelector);
-			const chunkReadPath =
-				parsed.kind === "chunk" || (pathChunkSelector && !sel)
-					? rawEffectiveSelector
-						? `${localReadPath}:${rawEffectiveSelector}`
-						: localReadPath
-					: parsed.kind === "lines"
-						? parsed.endLine !== undefined
-							? `${localReadPath}:L${parsed.startLine}-L${parsed.endLine}`
-							: `${localReadPath}:L${parsed.startLine}`
-						: localReadPath;
-			const chunkResult = await formatChunkedRead({
-				filePath: absolutePath,
-				readPath: chunkReadPath,
-				cwd: this.session.cwd,
-				language,
-				omitChecksum: !hasEditTool,
-				anchorStyle: resolveAnchorStyle(this.session.settings),
-				absoluteLineRange,
-			});
-			let text = chunkResult.text;
-			if (suffixResolution) {
-				text = prependSuffixResolutionNotice(text, suffixResolution);
-			}
-			return toolResult<ReadToolDetails>({
-				resolvedPath: absolutePath,
-				suffixResolution,
-				chunk: chunkResult.chunk,
-			})
-				.text(text)
-				.sourcePath(absolutePath)
-				.done();
-		}
-
+		const _hasEditTool = this.session.hasEditTool ?? true;
+		const _language = getLanguageFromPath(absolutePath);
+		const shouldConvertWithMarkit = CONVERTIBLE_EXTENSIONS.has(ext) || (ext === ".ipynb" && parsed.kind === "raw");
 		// Read the file based on type
 		let content: Array<TextContent | ImageContent>;
 		let details: ReadToolDetails = {};
@@ -1164,31 +1095,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				content = [{ type: "text", text: `[Cannot read ${ext} file: conversion failed]` }];
 			}
 		} else {
-			// Chunk mode: dispatch to chunk tree unless raw or line range requested
-			if (chunkMode && parsed.kind !== "raw" && parsed.kind !== "lines") {
-				const chunkSel = parsed.kind === "chunk" ? parsed.selector : undefined;
-				const chunkResult = await formatChunkedRead({
-					filePath: absolutePath,
-					readPath: chunkSel ? `${localReadPath}:${chunkSel}` : localReadPath,
-					cwd: this.session.cwd,
-					language: getLanguageFromPath(absolutePath),
-					omitChecksum: !(this.session.hasEditTool ?? true),
-					anchorStyle: resolveAnchorStyle(this.session.settings),
-				});
-				let text = chunkResult.text;
-				if (suffixResolution) {
-					text = prependSuffixResolutionNotice(text, suffixResolution);
-				}
-				return toolResult<ReadToolDetails>({
-					resolvedPath: absolutePath,
-					suffixResolution,
-					chunk: chunkResult.chunk,
-				})
-					.text(text)
-					.sourcePath(absolutePath)
-					.done();
-			}
-
 			// Raw text or line-range mode
 			const { offset, limit } = selToOffsetLimit(parsed);
 			const startLine = offset ? Math.max(0, offset - 1) : 0;
@@ -1222,7 +1128,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				const suggestion =
 					totalFileLines === 0
 						? "The file is empty."
-						: `Use sel=L1 to read from the start, or sel=L${totalFileLines} to read the last line.`;
+						: `Use sel=1 to read from the start, or sel=${totalFileLines} to read the last line.`;
 				return toolResult<ReadToolDetails>({ resolvedPath: absolutePath, suffixResolution })
 					.text(`Line ${startLineDisplay} is beyond end of file (${totalFileLines} lines total). ${suggestion}`)
 					.done();
@@ -1294,7 +1200,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				const nextOffset = startLine + userLimitedLines + 1;
 
 				outputText = formatText(truncation.content, startLineDisplay);
-				outputText += `\n\n[${remaining} more lines in file. Use sel=L${nextOffset} to continue]`;
+				outputText += `\n\n[${remaining} more lines in file. Use sel=${nextOffset} to continue]`;
 				details = {};
 				sourcePath = absolutePath;
 			} else {

package/src/tools/renderers.ts

@@ -20,6 +20,7 @@ import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
 import { grepToolRenderer } from "./grep";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
+import { jobToolRenderer } from "./job";
 import { notebookToolRenderer } from "./notebook";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
@@ -58,6 +59,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	notebook: notebookToolRenderer as ToolRenderer,
 	inspect_image: inspectImageToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
+	job: jobToolRenderer as ToolRenderer,
 	resolve: resolveToolRenderer as ToolRenderer,
 	search_tool_bm25: searchToolBm25Renderer as ToolRenderer,
 	ssh: sshToolRenderer as ToolRenderer,

package/src/tools/todo-write.ts

@@ -23,6 +23,13 @@ export interface TodoItem {
 	id: string;
 	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 {
@@ -40,7 +47,7 @@ export interface TodoWriteToolDetails {
 // Schema
 // =============================================================================
 
-const TodoOp = StringEnum(["replace", "start", "done", "rm", "drop", "append"] as const, {
+const TodoOp = StringEnum(["replace", "start", "done", "rm", "drop", "append", "note"] as const, {
 	description: "operation to apply",
 });
 
@@ -54,7 +61,7 @@ const InputTask = Type.Object({
 });
 
 const InputPhase = Type.Object({
-	name: Type.String({ description: "phase name", examples: ["Investigation", "Implementation"] }),
+	name: Type.String({ description: "phase name", examples: ["I. Foundation", "II. Auth", "III. Verification"] }),
 	tasks: Type.Optional(Type.Array(InputTask)),
 });
 
@@ -71,6 +78,7 @@ const TodoOpEntry = Type.Object({
 		Type.String({ description: "phase id for done/rm/drop/append", examples: ["Implementation", "phase-1"] }),
 	),
 	items: Type.Optional(Type.Array(AppendItem, { minItems: 1, description: "items to append for op=append" })),
+	text: Type.Optional(Type.String({ description: "note text for op=note (appended with newline)" })),
 });
 
 const todoWriteSchema = Type.Object(
@@ -160,8 +168,14 @@ function fileFromPhases(phases: TodoPhase[]): TodoFile {
 	return { phases, nextTaskId, nextPhaseId };
 }
 
+function cloneTask(task: TodoItem): TodoItem {
+	const out: TodoItem = { id: task.id, content: task.content, status: task.status };
+	if (task.notes && task.notes.length > 0) out.notes = [...task.notes];
+	return out;
+}
+
 function clonePhases(phases: TodoPhase[]): TodoPhase[] {
-	return phases.map(phase => ({ ...phase, tasks: phase.tasks.map(task => ({ ...task })) }));
+	return phases.map(phase => ({ ...phase, tasks: phase.tasks.map(cloneTask) }));
 }
 
 function normalizeInProgressTask(phases: TodoPhase[]): void {
@@ -181,11 +195,19 @@ function normalizeInProgressTask(phases: TodoPhase[]): void {
 	if (firstPendingTask) firstPendingTask.status = "in_progress";
 }
 
+export const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
+
 export function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[] {
 	for (let i = entries.length - 1; i >= 0; i--) {
 		const entry = entries[i];
+		if (entry.type === "custom" && entry.customType === USER_TODO_EDIT_CUSTOM_TYPE) {
+			const data = entry.data as { phases?: unknown } | undefined;
+			if (data && Array.isArray(data.phases)) {
+				return clonePhases(data.phases as TodoPhase[]);
+			}
+			continue;
+		}
 		if (entry.type !== "message") continue;
-
 		const message = entry.message as { role?: string; toolName?: string; details?: unknown; isError?: boolean };
 		if (message.role !== "toolResult" || message.toolName !== "todo_write" || message.isError) continue;
 
@@ -328,6 +350,17 @@ function applyEntry(file: TodoFile, entry: TodoOpEntryValue, errors: string[]):
 			removeTasks(file, entry, errors);
 			return file;
 		}
+		case "note": {
+			const task = resolveTaskOrError(file.phases, entry.task, errors);
+			if (!task) return file;
+			const text = (entry.text ?? "").replace(/\s+$/u, "");
+			if (!text) {
+				errors.push("Missing text for note operation");
+				return file;
+			}
+			task.notes = task.notes ? [...task.notes, text] : [text];
+			return file;
+		}
 		case "append": {
 			appendItems(file, entry, errors);
 			return file;
@@ -343,6 +376,142 @@ function applyParams(file: TodoFile, params: TodoWriteParams): { file: TodoFile;
 	normalizeInProgressTask(file.phases);
 	return { file, errors };
 }
+/** Apply an array of `todo_write`-style ops to existing phases. Used by /todo slash command. */
+export function applyOpsToPhases(
+	currentPhases: TodoPhase[],
+	ops: TodoWriteParams["ops"],
+): { phases: TodoPhase[]; errors: string[] } {
+	const startFile = fileFromPhases(currentPhases);
+	const { file, errors } = applyParams(startFile, { ops });
+	return { phases: file.phases, errors };
+}
+
+// =============================================================================
+// Markdown round-trip
+// =============================================================================
+
+const STATUS_TO_MARKER: Record<TodoStatus, string> = {
+	pending: " ",
+	in_progress: "/",
+	completed: "x",
+	abandoned: "-",
+};
+
+/** Render todo phases as a Markdown checklist suitable for editing/copying. */
+export function phasesToMarkdown(phases: TodoPhase[]): string {
+	if (phases.length === 0) return "# I. Todos\n";
+	const out: string[] = [];
+	for (let i = 0; i < phases.length; i++) {
+		if (i > 0) out.push("");
+		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`;
+}
+
+const MARKER_TO_STATUS: Record<string, TodoStatus> = {
+	" ": "pending",
+	"": "pending",
+	x: "completed",
+	X: "completed",
+	"/": "in_progress",
+	">": "in_progress",
+	"-": "abandoned",
+	"~": "abandoned",
+};
+
+/**
+ * Parse a Markdown checklist back into todo phases. Task and phase ids are
+ * regenerated; the agent observes the new ids in the system reminder.
+ */
+export function markdownToPhases(md: string): { phases: TodoPhase[]; errors: string[] } {
+	const errors: string[] = [];
+	const phases: TodoPhase[] = [];
+	let currentPhase: TodoPhase | undefined;
+	let currentTask: TodoItem | undefined;
+	let noteBuf: string[] = [];
+	let nextPhaseId = 1;
+	let nextTaskId = 1;
+
+	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 = { id: `phase-${nextPhaseId++}`, name: headingMatch[1].trim(), tasks: [] };
+			phases.push(currentPhase);
+			continue;
+		}
+
+		const taskMatch = /^[-*+]\s*\[(.?)\]\s+(.+?)\s*$/.exec(trimmed);
+		if (taskMatch) {
+			flushNote();
+			if (!currentPhase) {
+				currentPhase = { id: `phase-${nextPhaseId++}`, name: "I. Todos", tasks: [] };
+				phases.push(currentPhase);
+			}
+			const marker = taskMatch[1];
+			const status = MARKER_TO_STATUS[marker];
+			if (!status) {
+				errors.push(`Line ${lineNum + 1}: unknown status marker "[${marker}]" (use [ ], [x], [/], [-])`);
+				currentTask = undefined;
+				continue;
+			}
+			currentTask = { id: `task-${nextTaskId++}`, content: taskMatch[2].trim(), status };
+			currentPhase.tasks.push(currentTask);
+			continue;
+		}
+
+		flushNote();
+		currentTask = undefined;
+		errors.push(`Line ${lineNum + 1}: unrecognized syntax "${trimmed}"`);
+	}
+	flushNote();
+
+	normalizeInProgressTask(phases);
+	return { phases, errors };
+}
 
 function formatSummary(phases: TodoPhase[], errors: string[]): string {
 	const tasks = phases.flatMap(phase => phase.tasks);
@@ -387,7 +556,17 @@ function formatSummary(phases: TodoPhase[], errors: string[]): string {
 						: task.status === "abandoned"
 							? "✗"
 							: "○";
-			lines.push(`    ${sym} ${task.id} ${task.content}`);
+			const noteCount = task.notes?.length ?? 0;
+			const noteMarker = noteCount > 0 ? ` (+${noteCount} note${noteCount === 1 ? "" : "s"})` : "";
+			lines.push(`    ${sym} ${task.id} ${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}`);
+					}
+				}
+			}
 		}
 	}
 	return lines.join("\n");
@@ -442,18 +621,65 @@ type TodoWriteRenderArgs = {
 	}>;
 };
 
+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("");
+}
+
+function noteMarker(count: number, uiTheme: Theme): string {
+	if (count <= 0) return "";
+	return uiTheme.fg("dim", chalk.italic(` \u207a${toSuperscript(count)}`));
+}
+
 function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
 	const checkbox = uiTheme.checkbox;
+	const marker = noteMarker(item.notes?.length ?? 0, uiTheme);
 	switch (item.status) {
 		case "completed":
-			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`);
+			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`) + marker;
 		case "in_progress":
-			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`);
+			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
 		case "abandoned":
-			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${chalk.strikethrough(item.content)}`);
+			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${chalk.strikethrough(item.content)}`) + marker;
 		default:
-			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`);
+			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
+	}
+}
+
+function renderNoteAttachments(phases: TodoPhase[], uiTheme: Theme): 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;
+			const bar = uiTheme.fg("dim", uiTheme.tree.vertical);
+			const title = uiTheme.fg("dim", chalk.italic(`\u00a7 notes \u2014 ${task.content}`));
+			lines.push("");
+			lines.push(`  ${title}`);
+			for (let j = 0; j < task.notes.length; j++) {
+				if (j > 0) lines.push(`  ${bar}`);
+				for (const noteLine of task.notes[j].split("\n")) {
+					lines.push(`  ${bar} ${uiTheme.fg("dim", noteLine)}`);
+				}
+			}
+		}
 	}
+	return lines;
 }
 
 export const todoWriteToolRenderer = {
@@ -488,9 +714,11 @@ export const todoWriteToolRenderer = {
 
 		const { expanded } = options;
 		const lines: string[] = [header];
-		for (const phase of phases) {
+		for (let p = 0; p < phases.length; p++) {
+			const phase = phases[p];
+			if (p > 0) lines.push("");
 			if (phases.length > 1) {
-				lines.push(uiTheme.fg("accent", `  ${uiTheme.tree.hook} ${phase.name}`));
+				lines.push(uiTheme.fg("accent", chalk.bold(`  ${phase.name}`)));
 			}
 			const treeLines = renderTreeList(
 				{
@@ -502,8 +730,11 @@ export const todoWriteToolRenderer = {
 				},
 				uiTheme,
 			);
-			lines.push(...treeLines);
+			for (const line of treeLines) {
+				lines.push(`  ${line}`);
+			}
 		}
+		lines.push(...renderNoteAttachments(phases, uiTheme));
 		return new Text(lines.join("\n"), 0, 0);
 	},
 	mergeCallAndResult: true,

package/src/tools/write.ts

@@ -59,7 +59,7 @@ export interface WriteToolDetails {
 /**
  * Strip hashline display prefixes from write content.
  *
- * Only active when hashline edit mode is enabled — the model sees `LINE+ID:`
+ * Only active when hashline edit mode is enabled — the model sees `LINE+ID|`
  * prefixes in read output and sometimes copies them into write content.
  */
 function stripWriteContent(session: ToolSession, content: string): { text: string; stripped: boolean } {
@@ -418,7 +418,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<WriteToolDetails>> {
 		return untilAborted(signal, async () => {
-			// Strip hashline display prefixes (LINE+ID:) if the model copied them from read output
+			// Strip hashline display prefixes (LINE+ID|) if the model copied them from read output
 			const { text: cleanContent, stripped } = stripWriteContent(this.session, content);
 			const resolvedArchivePath = await this.#resolveArchiveWritePath(path);
 			if (resolvedArchivePath) {