@gajae-code/coding-agent 0.12.20 → 0.12.21

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [0.12.21] - 2026-08-09
+
+### Fixed
+- Strict session resume now sanitizes stale replay metadata in memory without mutating the selected transcript, then publishes the terminal resume breadcrumb only after the first durable user-visible write. Declined auto-continuations restore their deferred predecessor terminal instead of dropping client settlement evidence.
+- Todo completion reminders now honor `todo.reminders.max` across an interactive turn rather than stopping after the first reminder.
+- Hidden `nextTurn` messages that trigger a follow-up model call no longer deadlock the predecessor prompt during post-prompt settlement.
+
 ## [0.12.20] - 2026-08-09
 
 ### Fixed

package/dist/types/session/session-manager.d.ts

@@ -880,6 +880,7 @@ export declare const SessionManagerTestHooks: {
     materializedCacheMaxBytesOverride?: number;
     beforeResidentTransitionIndexBuild?: () => void;
     afterForkSnapshot?: () => void | Promise<void>;
+    afterForkTranscriptPublished?: () => void | Promise<void>;
     beforeEphemeralArtifactManagerInstall?: (dir: string) => void | Promise<void>;
     beforePersistPatchFence?: (attempt: number) => void;
 };

package/dist/types/tools/todo-contract.d.ts

@@ -7,9 +7,18 @@ import type { RawArgumentValidationResult } from "@gajae-code/ai/types";
  */
 export declare const TODO_DONE_ALIASES: readonly ["complete", "completed"];
 export declare function isDoneAlias(value: string): boolean;
+/**
+ * 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 declare const TODO_OPS: readonly ["init", "start", "done", "rm", "drop", "append", "note"];
 /**
  * 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 declare function validateRawTodoArguments(arguments_: Record<string, unknown>): RawArgumentValidationResult;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.12.20",
+	"version": "0.12.21",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -54,13 +54,13 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.12.20",
-		"@gajae-code/agent-core": "0.12.20",
-		"@gajae-code/ai": "0.12.20",
-		"@gajae-code/bridge-client": "0.12.20",
-		"@gajae-code/natives": "0.12.20",
-		"@gajae-code/tui": "0.12.20",
-		"@gajae-code/utils": "0.12.20",
+		"@gajae-code/stats": "0.12.21",
+		"@gajae-code/agent-core": "0.12.21",
+		"@gajae-code/ai": "0.12.21",
+		"@gajae-code/bridge-client": "0.12.21",
+		"@gajae-code/natives": "0.12.21",
+		"@gajae-code/tui": "0.12.21",
+		"@gajae-code/utils": "0.12.21",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/session/agent-session.ts

@@ -753,7 +753,7 @@ type AutoCompactionTerminalStatus =
  * forced compaction retry).
  */
 type PreSubmitBuilder = {
-	build: () => Promise<AgentMessage[]>;
+	build: () => Promise<AgentMessage[] | null>;
 	reset: () => void;
 };
 
@@ -2629,6 +2629,7 @@ export class AgentSession {
 	}
 	async #settleEndedInFlight(promptWait?: "publication" | "full"): Promise<void> {
 		const flushError = this.#endInFlight();
+		const predecessorPromptStillInFlight = this.#promptInFlightCount > 0;
 		if (promptWait === "publication") {
 			await this.#agentEndPublicationPromise;
 		} else if (promptWait === "full") {
@@ -2636,7 +2637,10 @@ export class AgentSession {
 			await this.#waitForPostPromptRecovery();
 			await this.#agentEndPublicationPromise;
 		}
-		await this.#waitForSessionSettlement();
+		// A post-prompt continuation runs before its predecessor prompt returns. Its
+		// publication must settle, but session-wide settlement can still be owned by
+		// that predecessor; waiting here would make each prompt wait on the other.
+		if (!predecessorPromptStillInFlight) await this.#waitForSessionSettlement();
 		if (flushError) throw flushError;
 	}
 
@@ -8932,8 +8936,12 @@ export class AgentSession {
 			// Phase A products (including the plan reference) remain stable.
 			let attemptMessages: AgentMessage[] | undefined;
 
-			const buildPreSubmit = async (): Promise<AgentMessage[]> => {
+			const buildPreSubmit = async (): Promise<AgentMessage[] | null> => {
 				this.#throwIfPromptPreflightCancelled(generation, preflightSignal);
+				if (options?.onFinalPreflight && !(await options.onFinalPreflight({ hasPendingNextTurnMessages }))) {
+					this.#resetInjectedContextSignatures();
+					return null;
+				}
 				if (!phaseACompleted) {
 					phaseACompleted = true;
 					// Phase A (one-time side-effectful products; runs once).
@@ -9094,6 +9102,10 @@ export class AgentSession {
 						message.role,
 					);
 				}
+				if (options?.onFinalPreflight && !(await options.onFinalPreflight({ hasPendingNextTurnMessages }))) {
+					this.#resetInjectedContextSignatures();
+					return null;
+				}
 				attemptMessages = messages;
 				return messages;
 			};
@@ -9123,10 +9135,6 @@ export class AgentSession {
 					if (this.#cancelAndSubmitInProgress) this.#cancelAndSubmitPendingNextTurnDrained = true;
 				},
 			};
-			if (options?.onFinalPreflight && !(await options.onFinalPreflight({ hasPendingNextTurnMessages }))) {
-				this.#resetInjectedContextSignatures();
-				return;
-			}
 			await this.#promptAgentWithIdleRetry(preSubmit, agentPromptOptions, predecessorAgentEndHold, {
 				signal: preflightSignal,
 				resourceRunId: this.#runResourceLeaseContext.getStore()?.resourceRunId,
@@ -16160,6 +16168,10 @@ export class AgentSession {
 				continuationHold = undefined;
 				try {
 					const messages = await preSubmit.build();
+					if (messages === null) {
+						this.#restoreDeferredAgentEndAfterContinuationFailure(predecessorAgentEnd);
+						return;
+					}
 					if (!preflightAccepted) {
 						await seam?.onPreflightAccepted?.();
 						preflightAccepted = true;

package/src/session/session-manager.ts

@@ -6216,6 +6216,7 @@ export const SessionManagerTestHooks: {
 	materializedCacheMaxBytesOverride?: number;
 	beforeResidentTransitionIndexBuild?: () => void;
 	afterForkSnapshot?: () => void | Promise<void>;
+	afterForkTranscriptPublished?: () => void | Promise<void>;
 	beforeEphemeralArtifactManagerInstall?: (dir: string) => void | Promise<void>;
 	beforePersistPatchFence?: (attempt: number) => void;
 } = {};
@@ -6310,6 +6311,7 @@ export class SessionManager {
 	#sessionFile: string | undefined;
 	#flushed: boolean = false;
 	#needsFullRewriteOnNextPersist: boolean = false;
+	#readOnlyResume = false;
 	#ensuredOnDisk: boolean = false;
 	#recoveryHydrationContext: RecoveryHydrationContext | undefined;
 	#recoveryPromotionTranscriptPath: string | undefined;
@@ -8754,6 +8756,7 @@ export class SessionManager {
 					publishedSha256,
 				};
 			}
+			await SessionManagerTestHooks.afterForkTranscriptPublished?.();
 			if (forkArtifactPublication?.kind === "managed") {
 				forkArtifactPublication.store.verifyRootSecurity();
 				forkArtifactPublication.store.assertBound();
@@ -13429,6 +13432,7 @@ export class SessionManager {
 	 */
 	async ensureOnDisk(): Promise<void> {
 		if (!this.persist || !this.#sessionFile) return;
+		if (this.#readOnlyResume) return;
 		if (this.#flushed && !this.#needsFullRewriteOnNextPersist) return;
 		await this.#rewriteFile();
 		this.#ensuredOnDisk = true;
@@ -13480,7 +13484,7 @@ export class SessionManager {
 				await this.#closePersistWriterInternal();
 				this.#flushed = true;
 			}
-			if (this.#needsFullRewriteOnNextPersist) await this.#rewriteFileContents();
+			if (this.#needsFullRewriteOnNextPersist && !this.#readOnlyResume) await this.#rewriteFileContents();
 		});
 		this.#retireEphemeralArtifacts();
 		await this.#drainEphemeralArtifactCleanups();
@@ -14388,6 +14392,8 @@ export class SessionManager {
 		if (records.length === 0) return;
 		if (this.#coldSidecarActive()) this.#deactivateColdForBranchMutation();
 		if (!this.persist || !this.#sessionFile || !this.storage.existsSync(this.#sessionFile)) return;
+		const sessionFile = this.#sessionFile;
+		const publishResumeBreadcrumb = this.#readOnlyResume;
 		await this.#queuePersistTask(async () => {
 			for (let attempt = 0; attempt <= 2; attempt++) {
 				const token = this.#capturePersistenceInputToken();
@@ -14396,8 +14402,12 @@ export class SessionManager {
 					this.#needsFullRewriteOnNextPersist ||
 					!this.#flushed ||
 					(header?.version ?? 1) < CURRENT_SESSION_VERSION
-				)
-					return this.#rewriteFileContents();
+				) {
+					await this.#rewriteFileContents();
+					if (publishResumeBreadcrumb) writeTerminalBreadcrumb(this.cwd, sessionFile);
+					this.#readOnlyResume = false;
+					return;
+				}
 				const persistedRecords = records.map(record =>
 					record.type === "entry_patch"
 						? (prepareEntryForPersistenceSync(
@@ -14411,27 +14421,40 @@ export class SessionManager {
 						: record,
 				);
 				SessionManagerTestHooks.beforePersistPatchFence?.(attempt);
+				let persisted = false;
 				const written = this.#withSessionPersistenceFenceSync(() => {
 					if (!this.#persistenceInputTokenMatches(token)) return false;
 					if (this.destination.kind === "managed") {
 						this.#appendManagedRecordsSync(persistedRecords);
+						persisted = true;
 						return true;
 					}
 					const writer = this.#ensurePersistWriter();
 					if (!writer) {
-						this.#rewriteFile().catch(() => {});
+						void this.#rewriteFile()
+							.then(() => {
+								if (publishResumeBreadcrumb) writeTerminalBreadcrumb(this.cwd, sessionFile);
+								this.#readOnlyResume = false;
+							})
+							.catch(() => {});
 						return true;
 					}
 					for (const persistedRecord of persistedRecords) writer.writeSync(persistedRecord);
+					persisted = true;
 					return true;
 				});
-				if (written) return;
+				if (written) {
+					if (publishResumeBreadcrumb && persisted) writeTerminalBreadcrumb(this.cwd, sessionFile);
+					if (persisted) this.#readOnlyResume = false;
+					return;
+				}
 			}
 			throw new Error("session_persistence_input_stale");
 		});
 	}
 	_persist(entry: SessionEntry): void {
 		if (!this.persist || !this.#sessionFile) return;
+		const publishResumeBreadcrumb = this.#readOnlyResume;
 		if (this.#persistError) throw this.#persistError;
 
 		// Normally we wait for the first assistant message before persisting to avoid
@@ -14456,6 +14479,8 @@ export class SessionManager {
 			// test-level tempDir cleanup.
 			try {
 				this.#rewriteFileSync();
+				if (publishResumeBreadcrumb) writeTerminalBreadcrumb(this.cwd, this.#sessionFile);
+				this.#readOnlyResume = false;
 			} catch (err) {
 				this.#recordPersistError(err);
 				throw this.#persistError ?? toError(err);
@@ -14468,6 +14493,7 @@ export class SessionManager {
 		// landing immediately after this call. Image externalization (rare) runs via
 		// the synchronous blob-store path so blob bytes are durable before the JSONL
 		// line referencing them is written.
+		let persisted = false;
 		try {
 			this.#withSessionPersistenceFenceSync(() => {
 				if (this.destination.kind === "managed") {
@@ -14478,6 +14504,7 @@ export class SessionManager {
 					);
 					const persistedEntry = prepareEntryForPersistenceSync(materializedEntry, this.#blobStore);
 					this.#appendManagedRecordsSync([persistedEntry]);
+					persisted = true;
 					return;
 				}
 				const writer = this.#ensurePersistWriter();
@@ -14496,7 +14523,10 @@ export class SessionManager {
 				);
 				const persistedEntry = prepareEntryForPersistenceSync(materializedEntry, this.#blobStore);
 				writer.writeSync(persistedEntry);
+				persisted = true;
 			});
+			if (publishResumeBreadcrumb && persisted) writeTerminalBreadcrumb(this.cwd, this.#sessionFile);
+			if (persisted) this.#readOnlyResume = false;
 		} catch (err) {
 			this.#recordPersistError(err);
 			throw this.#persistError ?? toError(err);
@@ -17535,18 +17565,13 @@ export class SessionManager {
 		const manager = new SessionManager(header.cwd || getProjectDir(), dir, true, storage, destination);
 		manager.#sessionMemoryMode = sessionMemoryMode;
 		await manager.#hydrateExistingSession(sessionPath, entries, inspected.migrationApplied);
+		manager.#readOnlyResume = true;
 		const ownershipInspection = revalidateResumeSessionIdentity(sessionPath, storage, inspected.identity);
 		if (ownershipInspection.kind === "error") {
 			await manager.close();
 			return ownershipInspection;
 		}
-		try {
-			await manager.#sanitizeLoadedOpenAIResponsesReplayMetadataAndPersist();
-			writeTerminalBreadcrumb(manager.cwd, sessionPath);
-		} catch (error) {
-			await manager.close();
-			throw error;
-		}
+		manager.#sanitizeLoadedOpenAIResponsesReplayMetadata();
 		return { kind: "opened", manager };
 	}
 

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/todo-contract.ts

@@ -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
@@ -46,15 +63,18 @@ const TODO_OP_KEYS_WITH_ALIASES = new Set([...TODO_OP_KEYS, "content"]);
  */
 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[]): RawArgumentRejectionDetail {
+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);
-	return hints.length > 0 ? { rejectedKeys: keys, hint: hints.join("; ") } : { rejectedKeys: keys };
+	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> {
@@ -64,15 +84,32 @@ 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 {
 	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.
 		const unknownEntryKeys = unknownKeys(entry, TODO_OP_KEYS_WITH_ALIASES);
@@ -80,23 +117,23 @@ export function validateRawTodoArguments(arguments_: Record<string, unknown>): R
 			return {
 				outcome: "reject",
 				code: "todo-write-unknown-op-entry-key",
-				detail: keyRejectionDetail(unknownEntryKeys),
+				detail: keyRejectionDetail(unknownEntryKeys, location),
 			};
-		const op = typeof entry.op === "string" && isDoneAlias(entry.op) ? "done" : entry.op;
 		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) {
+		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),
+					detail: keyRejectionDetail(unknownItemKeys, `${location}.list[${itemIndex}]`),
 				};
 		}
 	}

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({