@gajae-code/coding-agent 0.12.19 → 0.12.21

package/src/task/executor.ts

@@ -41,7 +41,10 @@ import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
 import { SKILL_PROMPT_MESSAGE_TYPE } from "../session/messages";
 import { SessionManager } from "../session/session-manager";
+import { FileSessionStorage } from "../session/session-storage";
 import { truncateTail } from "../session/streaming-output";
+// Ensure mandatory subagent result extraction is available even when a session is mocked.
+import "../tools/yield";
 import type { ContextFileEntry } from "../tools";
 import { jtdToJsonSchema, normalizeSchema } from "../tools/jtd-to-json-schema";
 import type { ReportFindingDetails } from "../tools/review";
@@ -285,7 +288,7 @@ export class ManagedTaskPersistence {
 			throw new Error("Managed task persistence authority is unavailable");
 	}
 
-	async openSession(cwd: string): Promise<SessionManager> {
+	async openSession(cwd: string, sessionMemoryMode: "off" | "shadow" | "enabled" = "shadow"): Promise<SessionManager> {
 		const store = this.#artifacts.getManagedStore();
 		if (!store) throw new Error("Managed task persistence authority is unavailable");
 		this.#artifacts.assertManagedBinding();
@@ -296,6 +299,7 @@ export class ManagedTaskPersistence {
 			store,
 			undefined,
 			cwd,
+			sessionMemoryMode,
 		);
 		this.#artifacts.assertManagedBinding();
 		return session;
@@ -1509,7 +1513,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					options.parentActiveModelPattern,
 					modelRegistry,
 					settings,
-					options.parentSessionId,
+					canonicalChildScope,
 					{ managedFallback: true },
 					canonicalChildScope,
 				),
@@ -1555,10 +1559,18 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			effectiveThinkingLevelForWarning = effectiveThinkingLevel;
 
 			const sessionManager = options.managedPersistence
-				? await awaitAbortable(options.managedPersistence.openSession(worktree ?? cwd))
+				? await awaitAbortable(
+						options.managedPersistence.openSession(worktree ?? cwd, subagentSettings.get("sessionMemory.mode")),
+					)
 				: sessionFile
 					? await awaitAbortable(
-							SessionManager.open(sessionFile, SessionManager.explicitDestination(path.dirname(sessionFile))),
+							SessionManager.open(
+								sessionFile,
+								SessionManager.explicitDestination(path.dirname(sessionFile)),
+								new FileSessionStorage(),
+								subagentSettings.get("session.directoryMigration") === "disabled" ? "disabled" : "copy-retain",
+								subagentSettings.get("sessionMemory.mode"),
+							),
 						)
 					: SessionManager.inMemory(worktree ?? cwd);
 			if (options.parentArtifactManager) {
@@ -1649,6 +1661,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					authStorage,
 					modelRegistry,
 					settings: subagentSettings,
+					providerSessionId: canonicalChildScope,
 					model,
 					thinkingLevel: effectiveThinkingLevel,
 					modelSubstitution:

package/src/tools/bash.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import type { Component } from "@gajae-code/tui";
-import { ImageProtocol, TERMINAL, Text } from "@gajae-code/tui";
+import { getKeybindings, ImageProtocol, TERMINAL, Text, visibleWidth } from "@gajae-code/tui";
 import { getProjectDir, isEnoent, logger, prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import { AsyncJobManager } from "../async";
@@ -32,7 +32,8 @@ import {
 } from "../session/streaming-output";
 
 import { renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { CachedOutputBlock, getOutputBlockContentWidth } from "../tui/output-block";
+import { truncateToWidth } from "../tui/utils";
 import { getSixelLineMask } from "../utils/sixel";
 import type { ToolSession } from ".";
 import { checkBashAllowedPrefixes, normalizeReadOnlyBashCommand } from "./bash-allowed-prefixes";
@@ -1635,6 +1636,7 @@ export interface ShellRendererConfig<TArgs> {
 	resolveCommand?: (args: TArgs | undefined) => string | undefined;
 	resolveCwd?: (args: TArgs | undefined) => string | undefined;
 	resolveEnv?: (args: TArgs | undefined) => Record<string, string> | undefined;
+	compactCommand?: boolean;
 }
 
 function getPartialJson<TArgs>(args: TArgs | undefined): string | undefined {
@@ -1682,6 +1684,85 @@ export function formatBashCommandLines(args: BashRenderArgs, uiTheme: Theme): st
 	return highlightedLines.map((line, i) => (i === 0 ? `${prefix}${line}` : line));
 }
 
+const BASH_COLLAPSED_COMMAND_MAX_VISUAL_ROWS = 5;
+const BASH_COMMAND_SENTINEL_MAX_VISUAL_ROWS = 3;
+
+interface BashCommandProjection {
+	lines: string[];
+}
+
+function resolveBashExpandKeyLabel(): string | undefined {
+	return getKeybindings().getKeys("app.tools.expand")[0];
+}
+
+function formatBashExpandActionHint(maxWidth?: number): string {
+	const keyLabel = resolveBashExpandKeyLabel();
+	const actionHint = keyLabel ? `${keyLabel} to expand` : "expand tools";
+	return maxWidth !== undefined && visibleWidth(actionHint) > Math.max(1, maxWidth) ? "expand tools" : actionHint;
+}
+
+function renderBashCommandProjection(
+	commandLines: string[],
+	width: number,
+	expanded: boolean,
+	actionHint: string,
+	uiTheme: Theme,
+): BashCommandProjection {
+	const renderWidth = Math.max(1, width);
+	const visualLines = new Text(commandLines.join("\n"), 0, 0).render(renderWidth);
+	if (expanded || visualLines.length <= BASH_COLLAPSED_COMMAND_MAX_VISUAL_ROWS) {
+		return { lines: visualLines };
+	}
+
+	const retained = visualLines.slice(0, BASH_COLLAPSED_COMMAND_MAX_VISUAL_ROWS);
+	const omittedVisualRows = visualLines.length - retained.length;
+	let sentinel = new Text(
+		uiTheme.fg("dim", `… ${omittedVisualRows} command rows omitted\n${actionHint}`),
+		0,
+		0,
+	).render(renderWidth);
+
+	if (sentinel.length > BASH_COMMAND_SENTINEL_MAX_VISUAL_ROWS) {
+		sentinel = new Text(uiTheme.fg("dim", `… ${omittedVisualRows} rows omitted\nexpand tools`), 0, 0).render(
+			renderWidth,
+		);
+	}
+	if (sentinel.length > BASH_COMMAND_SENTINEL_MAX_VISUAL_ROWS) {
+		sentinel = [
+			uiTheme.fg("dim", truncateToWidth(`… +${omittedVisualRows}`, renderWidth)),
+			uiTheme.fg("dim", truncateToWidth("expand tools", renderWidth)),
+		];
+	}
+
+	return { lines: [...retained, ...sentinel] };
+}
+
+function createBashCommandProjector(commandLines: string[], uiTheme: Theme) {
+	let cached:
+		| {
+				width: number;
+				expanded: boolean;
+				actionHint: string;
+				projection: BashCommandProjection;
+		  }
+		| undefined;
+
+	return {
+		render(width: number, expanded: boolean): BashCommandProjection {
+			const actionHint = formatBashExpandActionHint(width);
+			if (cached?.width === width && cached.expanded === expanded && cached.actionHint === actionHint) {
+				return cached.projection;
+			}
+			const projection = renderBashCommandProjection(commandLines, width, expanded, actionHint, uiTheme);
+			cached = { width, expanded, actionHint, projection };
+			return projection;
+		},
+		invalidate(): void {
+			cached = undefined;
+		},
+	};
+}
+
 function toBashRenderArgs<TArgs>(args: TArgs | undefined, config: ShellRendererConfig<TArgs>): BashRenderArgs {
 	return {
 		command: config.resolveCommand?.(args),
@@ -1695,10 +1776,23 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 	return {
 		renderCall(args: TArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 			const renderArgs = toBashRenderArgs(args, config);
-			const cmdText = formatBashCommand(renderArgs);
 			const title = config.resolveTitle(args, options);
-			const text = renderStatusLine({ icon: "pending", title, description: cmdText }, uiTheme);
-			return new Text(text, 0, 0);
+			if (!config.compactCommand) {
+				const cmdText = formatBashCommand(renderArgs);
+				const text = renderStatusLine({ icon: "pending", title, description: cmdText }, uiTheme);
+				return new Text(text, 0, 0);
+			}
+
+			const header = renderStatusLine({ icon: "pending", title }, uiTheme);
+			const projectCommand = createBashCommandProjector(formatBashCommandLines(renderArgs, uiTheme), uiTheme);
+			const renderOptions = options as RenderResultOptions & { renderContext?: BashRenderContext };
+			return {
+				render: (width: number): string[] => {
+					const expanded = renderOptions.renderContext?.expanded ?? renderOptions.expanded;
+					return [header, ...projectCommand.render(width, expanded).lines];
+				},
+				invalidate: () => projectCommand.invalidate(),
+			};
 		},
 
 		renderResult(
@@ -1713,6 +1807,8 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 		): Component {
 			const renderArgs = toBashRenderArgs(args, config);
 			const cmdLines = args ? formatBashCommandLines(renderArgs, uiTheme) : undefined;
+			const projectCommand =
+				config.compactCommand && cmdLines ? createBashCommandProjector(cmdLines, uiTheme) : undefined;
 			const isError = result.isError === true;
 			const icon = options.isPartial ? "pending" : isError ? "error" : "success";
 			const title = config.resolveTitle(args, options);
@@ -1726,6 +1822,10 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 					const { renderContext } = options;
 					const expanded = renderContext?.expanded ?? options.expanded;
 					const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
+					const commandLines =
+						cmdLines && projectCommand
+							? projectCommand.render(getOutputBlockContentWidth(width, uiTheme), expanded).lines
+							: (cmdLines ?? []);
 
 					// Get output from context (preferred) or fall back to result content.
 					// Strip the LLM-facing notice appended by wrappedExecute so we don't
@@ -1778,7 +1878,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 								outputLines.push(
 									uiTheme.fg(
 										"dim",
-										`… (${result.skippedCount} earlier lines, showing ${result.visualLines.length} of ${result.skippedCount + result.visualLines.length}) (ctrl+o to expand)`,
+										`… (${result.skippedCount} earlier lines, showing ${result.visualLines.length} of ${result.skippedCount + result.visualLines.length}) (${formatBashExpandActionHint(getOutputBlockContentWidth(width, uiTheme))})`,
 									),
 								);
 							}
@@ -1793,7 +1893,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 							header,
 							state: options.isPartial ? "pending" : isError ? "error" : "success",
 							sections: [
-								{ lines: cmdLines ?? [] },
+								{ lines: commandLines },
 								{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
 							],
 							width,
@@ -1803,6 +1903,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 				},
 				invalidate: () => {
 					outputBlock.invalidate();
+					projectCommand?.invalidate();
 				},
 			};
 		},
@@ -1816,4 +1917,5 @@ export const bashToolRenderer = createShellRenderer<BashRenderArgs>({
 	resolveCommand: args => args?.command,
 	resolveCwd: args => args?.cwd,
 	resolveEnv: args => args?.env,
+	compactCommand: true,
 });

package/src/tools/descriptors.test.ts

@@ -485,6 +485,8 @@ describe("tool descriptor compatibility gate", () => {
 			{ ops: "not-an-array" },
 			{ ops: [{ op: "done", task: "x" }], stray: true },
 			{ _i: "Tracking progress", ops: [{ op: "done", task: "x" }] },
+			{ ops: [{ op: "retitle", task: "x", newTask: "y" }] },
+			{ ops: [{ op: "add", phase: "P", items: ["a"] }] },
 		];
 		for (const payload of payloads) {
 			expect(lazy.rawArgumentValidation(payload)).toEqual(eager.rawArgumentValidation(payload));
@@ -508,6 +510,55 @@ describe("tool descriptor compatibility gate", () => {
 		).toThrow("todo_write done and drop entries require a task or phase target");
 	});
 
+	test("deferred and loaded todo_write reject a bad payload with the same message", async () => {
+		const session = makeSession({ "tools.discoveryMode": "all" });
+		session.hasUI = true;
+		const lazy = (await createTools(session)).find(tool => tool.name === "todo_write");
+		const eager = await BUILTIN_TOOL_DESCRIPTORS.todo_write.load(session);
+		if (!lazy || !eager) throw new Error("expected deferred and loaded todo_write tools");
+		const capture = (run: () => unknown): string => {
+			try {
+				run();
+			} catch (error) {
+				return error instanceof Error ? error.message : String(error);
+			}
+			throw new Error("expected a raw-argument rejection");
+		};
+		const call = (arguments_: Record<string, unknown>) => ({
+			id: "call-parity",
+			type: "toolCall" as const,
+			name: "todo_write",
+			arguments: arguments_,
+		});
+		// The observed incident: four usable entries discarded alongside one
+		// invented op. Whichever path runs first must say the same thing, or the
+		// caller that hit the cold registry sees none of the added guidance.
+		const invalidOp = call({
+			ops: [
+				{ op: "append", phase: "Work", items: ["ship it"] },
+				{ op: "done", task: "first" },
+				{ op: "done", task: "second" },
+				{ op: "done", task: "third" },
+				{ op: "retitle", task: "third", newTask: "fourth" },
+			],
+		});
+		const lazyOpMessage = capture(() => validateToolArguments(lazy, invalidOp));
+		expect(lazyOpMessage).toBe(capture(() => validateToolArguments(eager, invalidOp)));
+		expect(lazyOpMessage).toContain("todo_write operation entries require a known op value");
+		expect(lazyOpMessage).toContain("op must be one of: init, start, done, rm, drop, append, note");
+		expect(lazyOpMessage).toContain("ops[4]");
+
+		const unknownKey = call({
+			ops: [
+				{ op: "done", task: "x" },
+				{ op: "done", task: "y", bogusOpKey: 1 },
+			],
+		});
+		const lazyKeyMessage = capture(() => validateToolArguments(lazy, unknownKey));
+		expect(lazyKeyMessage).toBe(capture(() => validateToolArguments(eager, unknownKey)));
+		expect(lazyKeyMessage).toContain('rejected key: "bogusOpKey" (ops[1])');
+	});
+
 	test("deferred ask validator recovers the canonical round-zero pair", async () => {
 		const session = makeSession({ "tools.discoveryMode": "all" });
 		session.hasUI = true;

package/src/tools/find.ts

@@ -59,6 +59,25 @@ const DEFAULT_GLOB_TIMEOUT_MS = 5000;
 const MIN_GLOB_TIMEOUT_MS = 500;
 const MAX_GLOB_TIMEOUT_MS = 60_000;
 
+function comparePaths(left: string, right: string): number {
+	let leftIndex = 0;
+	let rightIndex = 0;
+	while (leftIndex < left.length && rightIndex < right.length) {
+		const leftCodePoint = left.codePointAt(leftIndex);
+		const rightCodePoint = right.codePointAt(rightIndex);
+		if (leftCodePoint === undefined || rightCodePoint === undefined) break;
+		if (leftCodePoint !== rightCodePoint) return leftCodePoint - rightCodePoint;
+		leftIndex += leftCodePoint > 0xffff ? 2 : 1;
+		rightIndex += rightCodePoint > 0xffff ? 2 : 1;
+	}
+	return left.length - right.length;
+}
+
+function compareMtimePath(left: { path: string; mtime?: number }, right: { path: string; mtime?: number }): number {
+	const mtimeOrder = (right.mtime ?? 0) - (left.mtime ?? 0);
+	return mtimeOrder || comparePaths(left.path, right.path);
+}
+
 /**
  * Reject comma-separated path lists packed into a single array element
  * (`["a.py,b.py"]`). The schema is array-of-string; agents that pass a
@@ -317,29 +336,43 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 
 			let matches: natives.GlobMatch[];
-			const onUpdateMatches: string[] = [];
+			const onUpdateMatches = new Map<string, number>();
+			const rankedUpdateMatches = (): Array<{ path: string; mtime: number }> =>
+				Array.from(onUpdateMatches, ([matchPath, mtime]) => ({ path: matchPath, mtime })).sort(compareMtimePath);
+			const retainUpdateMatch = (matchPath: string, mtime: number) => {
+				onUpdateMatches.set(matchPath, mtime);
+				if (onUpdateMatches.size <= effectiveLimit) return;
+				let worst: { path: string; mtime: number } | undefined;
+				for (const [candidatePath, candidateMtime] of onUpdateMatches) {
+					const candidate = { path: candidatePath, mtime: candidateMtime };
+					if (!worst || compareMtimePath(candidate, worst) > 0) worst = candidate;
+				}
+				if (worst) onUpdateMatches.delete(worst.path);
+			};
 			const updateIntervalMs = 200;
 			let lastUpdate = 0;
+			let terminal = false;
 			const emitUpdate = () => {
 				if (!onUpdate) return;
 				const now = Date.now();
 				if (now - lastUpdate < updateIntervalMs) return;
 				lastUpdate = now;
+				const ranked = rankedUpdateMatches().map(entry => entry.path);
 				const details: FindToolDetails = {
 					scopePath,
-					fileCount: onUpdateMatches.length,
-					files: onUpdateMatches.slice(),
+					fileCount: ranked.length,
+					files: ranked,
 					truncated: false,
 				};
 				onUpdate({
-					content: [{ type: "text", text: onUpdateMatches.join("\n") }],
+					content: [{ type: "text", text: ranked.join("\n") }],
 					details,
 				});
 			};
 			const onMatch = (err: Error | null, match: natives.GlobMatch | null) => {
-				if (err || signal?.aborted || !match?.path) return;
+				if (err || terminal || combinedSignal.aborted || !match?.path) return;
 				const relativePath = formatMatchPath(match.path, match.fileType);
-				onUpdateMatches.push(relativePath);
+				retainUpdateMatch(relativePath, match.mtime ?? 0);
 				emitUpdate();
 			};
 
@@ -355,6 +388,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 							sortByMtime: true,
 							gitignore: useGitignore,
 							signal: combinedSignal,
+							timeoutMs,
 						},
 						onMatch,
 					),
@@ -363,34 +397,29 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			let timedOut = false;
 			try {
 				const result = await doGlob(useGitignore);
-				// Sort by mtime descending (most recent first) in JS instead of native.
-				// This allows native glob to early-terminate at maxResults.
-				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
+				// Native uncached glob retains a bounded newest set; keep the same tie-break after callback delivery.
+				result.matches.sort(compareMtimePath);
 				matches = result.matches;
 			} catch (error) {
-				if (error instanceof Error && error.name === "AbortError") {
-					if (timeoutSignal.aborted && !signal?.aborted) {
-						timedOut = true;
-						matches = [];
-					} else {
-						throw new ToolAbortError();
-					}
+				const nativeTimedOut = error instanceof Error && error.message === "Aborted: Timeout";
+				if (
+					(error instanceof Error && error.name === "AbortError" && timeoutSignal.aborted && !signal?.aborted) ||
+					(nativeTimedOut && !signal?.aborted)
+				) {
+					timedOut = true;
+					matches = [];
+				} else if (error instanceof Error && error.name === "AbortError") {
+					throw new ToolAbortError();
 				} else {
 					throw error;
 				}
+			} finally {
+				terminal = true;
 			}
 
 			if (timedOut) {
-				// Drain the partial matches accumulated during streaming and return them
-				// instead of throwing — empty results after a multi-second wait force the
-				// caller to retry blind, which is the worst possible outcome.
-				const seen = new Set<string>();
-				const partial: string[] = [];
-				for (const entry of onUpdateMatches) {
-					if (seen.has(entry)) continue;
-					seen.add(entry);
-					partial.push(entry);
-				}
+				// Return the bounded, deterministically ranked candidates observed before timeout.
+				const partial = rankedUpdateMatches().map(entry => entry.path);
 				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
 				const notice = `find timed out after ${seconds}s; returning ${partial.length} partial matches — increase timeout or narrow pattern`;
 				return buildResult(partial, { notice, forceTruncated: true });

package/src/tools/todo-contract.ts

@@ -8,7 +8,7 @@
  * tool ever loaded, with no correction hint to recover from.
  */
 import { INTENT_FIELD } from "@gajae-code/agent-core";
-import type { RawArgumentValidationResult } from "@gajae-code/ai/types";
+import type { RawArgumentRejectionDetail, RawArgumentValidationResult } from "@gajae-code/ai/types";
 
 /**
  * Models reliably reach for `complete`/`completed` because the status an op
@@ -22,6 +22,23 @@ export function isDoneAlias(value: string): boolean {
 	return (TODO_DONE_ALIASES as readonly string[]).includes(value);
 }
 
+/**
+ * Legal `op` values. Exported so the todo_write schema and this contract read
+ * from one list: a rejection that names a vocabulary the schema no longer
+ * accepts is exactly the drift this file exists to prevent.
+ */
+export const TODO_OPS = ["init", "start", "done", "rm", "drop", "append", "note"] as const;
+
+function isKnownOp(value: string): boolean {
+	return (TODO_OPS as readonly string[]).includes(value);
+}
+
+/**
+ * The whole vocabulary, not a guess at which entry the caller meant. Static
+ * text, so clamping a rejection detail can never truncate it away.
+ */
+const TODO_OP_VOCABULARY_HINT = `op must be one of: ${TODO_OPS.join(", ")}`;
+
 /**
  * `_i` is the intent field injected into tool schemas by the agent loop. The
  * loop strips it before validation, but replayed, bridged, and directly
@@ -34,8 +51,30 @@ const TODO_INIT_ENTRY_KEYS = new Set(["phase", "items"]);
 /** `content` is accepted only as a synonym the schema rewrites to `task`. */
 const TODO_OP_KEYS_WITH_ALIASES = new Set([...TODO_OP_KEYS, "content"]);
 
-function hasUnknownKeys(value: object, allowed: Set<string>): boolean {
-	return Object.keys(value).some(key => !allowed.has(key));
+/**
+ * Exact key corrections. `note` is the one repeatable confusion: it is an `op`
+ * value, and the body of a note op goes in `text`, so a caller who wrote
+ * `note: "..."` on an entry can be told exactly which fields a note op takes.
+ * The correction names both required fields rather than a literal rewrite,
+ * because a rewrite that omits `task` is rejected again on the retry. Only add
+ * an entry here when the replacement is unambiguous — never from fuzzy or
+ * edit-distance matching, because a wrong suggestion costs more turns than no
+ * suggestion.
+ */
+const TODO_KEY_CORRECTIONS = new Map<string, string>([
+	["note", 'note is an op, not a key; note operations require both "task" and "text"'],
+	["newTask", "there is no rename op; re-run init with the corrected list to rename a task"],
+	["tasks", 'tasks is not a key; append operations take "items"'],
+]);
+
+function unknownKeys(value: object, allowed: Set<string>): string[] {
+	return Object.keys(value).filter(key => !allowed.has(key));
+}
+
+function keyRejectionDetail(keys: readonly string[], location?: string): RawArgumentRejectionDetail {
+	const hints = keys.map(key => TODO_KEY_CORRECTIONS.get(key)).filter((hint): hint is string => hint !== undefined);
+	const parts = location === undefined ? hints : [location, ...hints];
+	return parts.length > 0 ? { rejectedKeys: keys, hint: parts.join("; ") } : { rejectedKeys: keys };
 }
 
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
@@ -45,27 +84,57 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
 /**
  * Single source of truth for todo_write pre-coercion validation. Every
  * rejection carries a code so the caller can surface an actionable correction
- * instead of a bare "raw arguments rejected" message.
+ * instead of a bare "raw arguments rejected" message, and every entry-level
+ * rejection names the failing `ops` index. Rejection stays batch-atomic, but a
+ * caller told which entry failed can resubmit the rest instead of rebuilding
+ * the payload from memory — or, as observed, silently abandoning the list.
  */
 export function validateRawTodoArguments(arguments_: Record<string, unknown>): RawArgumentValidationResult {
-	if (hasUnknownKeys(arguments_, TODO_WRITE_KEYS)) return { outcome: "reject", code: "todo-write-unknown-root-key" };
+	const unknownRootKeys = unknownKeys(arguments_, TODO_WRITE_KEYS);
+	if (unknownRootKeys.length > 0)
+		return { outcome: "reject", code: "todo-write-unknown-root-key", detail: keyRejectionDetail(unknownRootKeys) };
 	if (!Array.isArray(arguments_.ops)) return { outcome: "passthrough" };
-	for (const entry of arguments_.ops) {
+	const ops: readonly unknown[] = arguments_.ops;
+	for (const [index, entry] of ops.entries()) {
 		if (!isPlainRecord(entry)) continue;
+		const location = `ops[${index}]`;
+		// The op value is checked before the entry keys. An entry that invents
+		// both an op and a key is an unknown-op problem, and reporting the key
+		// first tells the caller which keys are legal while leaving it to guess
+		// that the operation it reached for does not exist at all.
+		const rawOp = entry.op;
+		const op = typeof rawOp === "string" && isDoneAlias(rawOp) ? "done" : rawOp;
+		if (typeof op === "string" && !isKnownOp(op))
+			return {
+				outcome: "reject",
+				code: "todo-write-unknown-op-value",
+				detail: { rejectedKeys: [op], hint: `${location}; ${TODO_OP_VOCABULARY_HINT}` },
+			};
 		// `content` is normalized to `task` by the schema preprocessor, so it must
 		// not be rejected here as an unknown key first.
-		if (hasUnknownKeys(entry, TODO_OP_KEYS_WITH_ALIASES))
-			return { outcome: "reject", code: "todo-write-unknown-op-entry-key" };
-		const op = typeof entry.op === "string" && isDoneAlias(entry.op) ? "done" : entry.op;
+		const unknownEntryKeys = unknownKeys(entry, TODO_OP_KEYS_WITH_ALIASES);
+		if (unknownEntryKeys.length > 0)
+			return {
+				outcome: "reject",
+				code: "todo-write-unknown-op-entry-key",
+				detail: keyRejectionDetail(unknownEntryKeys, location),
+			};
 		const target = entry.task ?? entry.content;
 		if ((op === "done" || op === "drop") && !target && !entry.phase) {
-			return { outcome: "reject", code: "todo-write-done-drop-requires-target" };
+			return { outcome: "reject", code: "todo-write-done-drop-requires-target", detail: { hint: location } };
 		}
 		const list = entry.list;
 		if (!Array.isArray(list)) continue;
-		for (const item of list) {
-			if (isPlainRecord(item) && hasUnknownKeys(item, TODO_INIT_ENTRY_KEYS))
-				return { outcome: "reject", code: "todo-write-unknown-init-entry-key" };
+		const items: readonly unknown[] = list;
+		for (const [itemIndex, item] of items.entries()) {
+			if (!isPlainRecord(item)) continue;
+			const unknownItemKeys = unknownKeys(item, TODO_INIT_ENTRY_KEYS);
+			if (unknownItemKeys.length > 0)
+				return {
+					outcome: "reject",
+					code: "todo-write-unknown-init-entry-key",
+					detail: keyRejectionDetail(unknownItemKeys, `${location}.list[${itemIndex}]`),
+				};
 		}
 	}
 	return { outcome: "passthrough" };

package/src/tools/todo-write.ts

@@ -11,7 +11,7 @@ import type { ToolSession } from "../sdk";
 import type { SessionEntry } from "../session/session-manager";
 import { renderStatusLine, renderTreeList } from "../tui";
 import { PREVIEW_LIMITS } from "./render-utils";
-import { isDoneAlias, validateRawTodoArguments } from "./todo-contract";
+import { isDoneAlias, TODO_OPS, validateRawTodoArguments } from "./todo-contract";
 
 // =============================================================================
 // Types
@@ -47,10 +47,7 @@ export interface TodoWriteToolDetails {
 // =============================================================================
 
 const TodoOp = z
-	.preprocess(
-		value => (typeof value === "string" && isDoneAlias(value) ? "done" : value),
-		z.enum(["init", "start", "done", "rm", "drop", "append", "note"] as const),
-	)
+	.preprocess(value => (typeof value === "string" && isDoneAlias(value) ? "done" : value), z.enum(TODO_OPS))
 	.describe('operation to apply; use "done" to complete a task');
 
 const InitListEntry = z.object({

package/src/tui/output-block.ts

@@ -23,6 +23,16 @@ export interface OutputBlockOptions {
 	width: number;
 	applyBg?: boolean;
 }
+/**
+ * Return the width available to section content after the output block's
+ * visible left and right borders. Keep callers on the same layout contract as
+ * renderOutputBlock so width-aware projections are not wrapped a second time.
+ */
+export function getOutputBlockContentWidth(width: number, theme: Theme): number {
+	const lineWidth = Math.max(0, width);
+	const borderWidth = visibleWidth(`${theme.boxSharp.vertical} `) + visibleWidth(theme.boxSharp.vertical);
+	return Math.max(0, lineWidth - borderWidth);
+}
 
 export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[] {
 	const { header, headerMeta, state, sections = [], width, applyBg = true } = options;
@@ -70,7 +80,7 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 
 	const contentPrefix = border(`${v} `);
 	const contentSuffix = border(v);
-	const contentWidth = Math.max(0, lineWidth - visibleWidth(contentPrefix) - visibleWidth(contentSuffix));
+	const contentWidth = getOutputBlockContentWidth(lineWidth, theme);
 	const lines: string[] = [];
 
 	lines.push(