@gajae-code/coding-agent 0.12.5 → 0.12.7

package/src/tools/subagent.ts

@@ -32,6 +32,15 @@ const subagentSchema = z.object({
 	id: z.string().optional().describe("single subagent id or backing job id for resume/steer"),
 	message: z.string().optional().describe("message to deliver when resuming or steering a subagent"),
 	pause: z.boolean().optional().describe("pause after steering a currently running subagent"),
+	condition: z
+		.enum(["all_terminal", "any_terminal"])
+		.optional()
+		.describe("terminal wait condition; defaults to all_terminal"),
+	heartbeat_ms: z
+		.number()
+		.refine(value => value === 0 || (Number.isInteger(value) && value >= 100 && value <= 5000))
+		.optional()
+		.describe("heartbeat interval; 0 disables"),
 	timeout_ms: z.number().min(0).max(MAX_AWAIT_TIMEOUT_MS).optional().describe("await timeout in milliseconds"),
 	limit: z.number().min(1).max(MAX_LIST_LIMIT).optional().describe("maximum subagents to return"),
 	verbosity: z
@@ -97,6 +106,11 @@ export interface SubagentToolDetails {
 	subagents: SubagentSnapshot[];
 	/** Await outcome for a live await receipt; omitted when no wait was started. */
 	awaitOutcome?: SubagentAwaitOutcome;
+	waitOutcome?: "completed" | "timed_out_wait" | "interrupted";
+	condition?: "all_terminal" | "any_terminal";
+	heartbeatMs?: number;
+	terminalIds?: string[];
+	acknowledgedTerminalIds?: string[];
 	/** True only when the parent await was interrupted; the child was not cancelled. */
 	interrupted?: true;
 }
@@ -344,35 +358,53 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		signal: AbortSignal | undefined,
 		onUpdate: AgentToolUpdateCallback<SubagentToolDetails> | undefined,
 	): Promise<AgentToolResult<SubagentToolDetails>> {
-		const records = params.ids?.length
-			? this.#visibleRecordsByIds(manager, params.ids, ownerFilter)
+		const ids = params.ids
+			?.map(id => id.trim())
+			.filter(Boolean)
+			.filter((id, index, all) => all.indexOf(id) === index);
+		const records = ids?.length
+			? this.#visibleRecordsByIds(manager, ids, ownerFilter)
 			: this.#runningRecords(manager, ownerFilter);
-		const notFoundIds = this.#notFoundRecordIds(manager, params.ids ?? [], ownerFilter);
-		if (records.length === 0) {
-			const missing = notFoundIds.map(id =>
-				this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."),
+		const notFoundIds = (ids ?? []).filter(id => !this.#findVisibleRecord(manager, id, ownerFilter));
+		if (records.length === 0)
+			return this.#buildSnapshotResult(
+				notFoundIds.map(id =>
+					this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."),
+				),
+				"Subagent await",
 			);
-			return this.#buildSnapshotResult(missing, "Subagent await");
-		}
-
-		const runningJobs = records
-			.filter(record => record.status === "running" && record.currentJobId)
-			.map(record => manager.getJob(record.currentJobId!))
-			.filter((job): job is AsyncJob => job !== undefined);
-		if (runningJobs.length === 0) {
+		const targets = records
+			.map(record => manager.resolveSubagentWaitTarget(record.subagentId, ownerFilter))
+			.filter((target): target is NonNullable<typeof target> => target !== undefined);
+		if (targets.length === 0) return this.#buildSnapshotResult([], "Subagent await");
+		const condition = params.condition ?? "all_terminal";
+		const handle = manager.subscribeTerminalWait(targets, condition);
+		const timeoutMs = Math.min(
+			MAX_AWAIT_TIMEOUT_MS,
+			Math.max(0, Math.floor(params.timeout_ms ?? DEFAULT_AWAIT_TIMEOUT_MS)),
+		);
+		const targetsAlreadyTerminal = targets.every(
+			target =>
+				target.initialStatus === "completed" ||
+				target.initialStatus === "failed" ||
+				target.initialStatus === "cancelled",
+		);
+		if (targetsAlreadyTerminal) {
+			const waitResult = await handle.result;
+			handle.acknowledge(waitResult.terminalJobIds);
+			handle.close();
+			const terminalJobIds = waitResult.terminalJobIds;
 			return await this.#buildRecordResult(manager, records, {
 				title: "Subagent await",
-				notFoundIds,
 				verbosity: params.verbosity ?? "receipt",
+				waitOutcome: "completed",
+				condition,
+				terminalIds: terminalJobIds,
 			});
 		}
-
-		const timeoutMs = Math.min(
-			MAX_AWAIT_TIMEOUT_MS,
-			Math.max(0, Math.floor(params.timeout_ms ?? DEFAULT_AWAIT_TIMEOUT_MS)),
-		);
-		const watchedJobIds = runningJobs.map(job => job.id);
+		const watchedJobIds = targets.map(target => target.jobId).filter((jobId): jobId is string => jobId !== null);
 		manager.watchJobs(watchedJobIds);
+		const heartbeatMs = params.heartbeat_ms === undefined ? 500 : params.heartbeat_ms;
 		let lastEmittedSignature: string | undefined;
 		const emitIfChanged = (force: boolean): void => {
 			if (!onUpdate) return;
@@ -382,57 +414,50 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			lastEmittedSignature = signature;
 			onUpdate(result);
 		};
-		const progressTimer = onUpdate ? setInterval(() => emitIfChanged(false), 500) : undefined;
-		// Initial emission so the panel appears immediately; later idle ticks are
-		// gated on a value-based rendered-state signature so unchanged progress no
-		// longer rebuilds the renderer component or mutates transcript lines above
-		// the viewport (the source of the await-panel repaint storms).
+		const progressTimer =
+			onUpdate && heartbeatMs > 0 ? setInterval(() => emitIfChanged(false), heartbeatMs) : undefined;
 		emitIfChanged(true);
-
-		let awaitOutcome: SubagentAwaitOutcome;
-		const { promise: timeoutPromise, resolve: resolveTimeout } = Promise.withResolvers<SubagentAwaitOutcome>();
-		const timeoutTimer = setTimeout(() => resolveTimeout("timed_out"), timeoutMs);
-		const completionPromise = Promise.all(runningJobs.map(job => job.promise)).then(() => "completed" as const);
+		let waitOutcome: "completed" | "timed_out_wait" | "interrupted";
 		let onAbort: (() => void) | undefined;
 		try {
-			if (signal) {
-				const { promise: abortPromise, resolve: resolveAbort } = Promise.withResolvers<SubagentAwaitOutcome>();
-				onAbort = () => resolveAbort("interrupted");
-				if (signal.aborted) onAbort();
-				else signal.addEventListener("abort", onAbort, { once: true });
-				awaitOutcome = await Promise.race([completionPromise, timeoutPromise, abortPromise]);
-			} else {
-				awaitOutcome = await Promise.race([completionPromise, timeoutPromise]);
-			}
+			const abortPromise = new Promise<"interrupted">(resolve => {
+				onAbort = () => resolve("interrupted");
+				if (signal?.aborted) onAbort();
+				else signal?.addEventListener("abort", onAbort, { once: true });
+			});
+			waitOutcome =
+				targetsAlreadyTerminal && !signal?.aborted
+					? "completed"
+					: await Promise.race([
+							handle.result.then(() => "completed" as const),
+							Bun.sleep(timeoutMs).then(() => "timed_out_wait" as const),
+							abortPromise,
+						]);
 		} finally {
-			clearTimeout(timeoutTimer);
 			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
 			if (progressTimer) clearInterval(progressTimer);
 		}
-		if (awaitOutcome !== "interrupted") {
-			const terminalWatchedJobIds = watchedJobIds.filter(jobId => {
-				const status = manager.getJob(jobId)?.status;
-				return status === "completed" || status === "failed" || status === "cancelled";
-			});
-			manager.acknowledgeDeliveries(terminalWatchedJobIds);
-		}
+		const waitResult = waitOutcome === "completed" ? await handle.result : undefined;
+		if (waitOutcome === "completed") handle.acknowledge(waitResult?.terminalJobIds);
 		manager.unwatchJobs(watchedJobIds);
-
+		handle.close();
+		const awaitOutcome: SubagentAwaitOutcome =
+			waitOutcome === "completed" ? "completed" : waitOutcome === "timed_out_wait" ? "timed_out" : "interrupted";
 		const finalRecords = this.#visibleRecordsByIds(
 			manager,
 			records.map(record => record.subagentId),
 			ownerFilter,
 		);
-		const finalNotFoundIds = [...new Set([...notFoundIds, ...records.map(record => record.subagentId)])].filter(
-			id => !finalRecords.some(record => record.subagentId === id),
-		);
 		return await this.#buildRecordResult(manager, finalRecords, {
-			title: awaitOutcome === "interrupted" ? "Subagent await interrupted" : "Subagent await",
-			notFoundIds: finalNotFoundIds,
-			timedOut: awaitOutcome === "timed_out",
+			title: waitOutcome === "interrupted" ? "Subagent await interrupted" : "Subagent await",
+			notFoundIds,
+			timedOut: waitOutcome === "timed_out_wait",
 			verbosity: params.verbosity ?? "receipt",
 			attachLiveProgress: true,
 			awaitOutcome,
+			waitOutcome,
+			condition,
+			terminalIds: waitResult?.terminalJobIds,
 		});
 	}
 
@@ -490,7 +515,8 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		if (direct && isSubagentJob(direct) && (!ownerId || direct.ownerId === ownerId)) return direct;
 		return manager
 			.getAllJobs(ownerId ? { ownerId } : undefined)
-			.find(job => isSubagentJob(job) && job.metadata?.subagent?.id === id);
+			.filter(job => isSubagentJob(job) && job.metadata?.subagent?.id === id)
+			.sort((a, b) => b.startTime - a.startTime)[0];
 	}
 
 	#visibleRecordsByIds(
@@ -551,6 +577,9 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			verbosity?: SubagentParams["verbosity"];
 			attachLiveProgress?: boolean;
 			awaitOutcome?: SubagentAwaitOutcome;
+			waitOutcome?: "completed" | "timed_out_wait" | "interrupted";
+			condition?: "all_terminal" | "any_terminal";
+			terminalIds?: string[];
 		},
 	): Promise<AgentToolResult<SubagentToolDetails>> {
 		const verifiedOutputIds = await this.#verifiedOutputIds(records);
@@ -565,33 +594,28 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		for (const id of options.notFoundIds ?? []) {
 			snapshots.push(this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."));
 		}
-		if (options.awaitOutcome !== "interrupted") {
-			manager.acknowledgeDeliveries(
-				snapshots
-					.filter(
-						s =>
-							s.status !== "running" &&
-							s.status !== "paused" &&
-							s.status !== "queued" &&
-							s.status !== "not_found",
-					)
-					.map(s => s.jobId),
-			);
-		}
 		if (options.awaitOutcome === "interrupted") {
 			for (const snapshot of snapshots) {
-				if (snapshot.status === "running" || snapshot.status === "paused" || snapshot.status === "queued") {
+				if (snapshot.status === "running" || snapshot.status === "paused" || snapshot.status === "queued")
 					snapshot.guidance = AWAIT_INTERRUPTED_GUIDANCE;
-				}
 			}
 		}
-		return this.#buildSnapshotResult(snapshots, options.title, options.awaitOutcome);
+		const details: SubagentToolDetails = {
+			subagents: snapshots,
+			...(options.awaitOutcome !== undefined ? { awaitOutcome: options.awaitOutcome } : {}),
+			...(options.waitOutcome !== undefined ? { waitOutcome: options.waitOutcome } : {}),
+			...(options.condition !== undefined ? { condition: options.condition } : {}),
+			...(options.terminalIds !== undefined ? { terminalIds: options.terminalIds } : {}),
+		};
+		if (options.awaitOutcome === "interrupted") details.interrupted = true;
+		return this.#buildSnapshotResult(snapshots, options.title, options.awaitOutcome, details);
 	}
 
 	#buildSnapshotResult(
 		snapshots: SubagentSnapshot[],
 		title: string,
 		awaitOutcome?: SubagentAwaitOutcome,
+		extraDetails?: SubagentToolDetails,
 	): AgentToolResult<SubagentToolDetails> {
 		const lines = [`## ${title} (${snapshots.length})`, ""];
 		for (const snapshot of snapshots) {
@@ -623,7 +647,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		}
 		return {
 			content: [{ type: "text", text: lines.join("\n").trimEnd() }],
-			details: {
+			details: extraDetails ?? {
 				subagents: snapshots,
 				...(awaitOutcome ? { awaitOutcome } : {}),
 				...(awaitOutcome === "interrupted" ? { interrupted: true } : {}),
@@ -651,8 +675,6 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 	): Pick<SubagentSnapshot, "progress" | "liveProgressAvailable"> {
 		if (!attachLiveProgress) return {};
 		const liveProgressAvailable = manager.hasLiveSubagent(record.subagentId);
-		// Only surface progress when a live producer exists; stale/retained progress
-		// for a record with no live producer must degrade to a static snapshot (AC5).
 		if (!liveProgressAvailable) return { liveProgressAvailable: false };
 		const progress = manager.getSubagentProgress(record.subagentId);
 		return {

package/src/tools/todo-write.ts

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { RawArgumentValidationResult } from "@gajae-code/ai/types";
 import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
 import { prompt } from "@gajae-code/utils";
@@ -62,6 +63,39 @@ const TodoOpEntry = z.object({
 	text: z.string().optional().describe("note text"),
 });
 
+const TODO_WRITE_KEYS = new Set(["ops"]);
+const TODO_OP_KEYS = new Set(["op", "list", "task", "phase", "items", "text"]);
+const TODO_INIT_ENTRY_KEYS = new Set(["phase", "items"]);
+
+function hasUnknownKeys(value: object, allowed: Set<string>): boolean {
+	return Object.keys(value).some(key => !allowed.has(key));
+}
+
+function validateRawTodoArguments(arguments_: Record<string, unknown>): RawArgumentValidationResult {
+	if (hasUnknownKeys(arguments_, TODO_WRITE_KEYS)) return { outcome: "reject" };
+	if (!Array.isArray(arguments_.ops)) return { outcome: "passthrough" };
+	for (const entry of arguments_.ops) {
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
+		if (hasUnknownKeys(entry, TODO_OP_KEYS)) return { outcome: "reject" };
+		const record = entry as Record<string, unknown>;
+		if ((record.op === "done" || record.op === "drop") && !record.task && !record.phase) {
+			return { outcome: "reject" };
+		}
+		const list = record.list;
+		if (!Array.isArray(list)) continue;
+		for (const item of list) {
+			if (
+				typeof item === "object" &&
+				item !== null &&
+				!Array.isArray(item) &&
+				hasUnknownKeys(item, TODO_INIT_ENTRY_KEYS)
+			)
+				return { outcome: "reject" };
+		}
+	}
+	return { outcome: "passthrough" };
+}
+
 const todoWriteSchema = z
 	.object({
 		ops: z.array(TodoOpEntry).min(1).describe("ordered todo operations"),
@@ -497,6 +531,7 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 	readonly summary = "Write a structured todo list to track progress within a session";
 	readonly description: string;
 	readonly parameters = todoWriteSchema;
+	readonly rawArgumentValidation = validateRawTodoArguments;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 	readonly loadMode = "discoverable";
@@ -512,6 +547,18 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<TodoWriteToolDetails>> {
 		const previousPhases = clonePhases(this.session.getTodoPhases?.() ?? []);
+		const missingTarget = params.ops.find(
+			entry => (entry.op === "done" || entry.op === "drop") && !entry.task && !entry.phase,
+		);
+		if (missingTarget) {
+			const storage = this.session.getSessionFile() ? "session" : "memory";
+			const errors = [`Missing task or phase for ${missingTarget.op} operation`];
+			return {
+				content: [{ type: "text", text: formatSummary(previousPhases, errors) }],
+				details: { phases: previousPhases, storage },
+				isError: true,
+			};
+		}
 		const { phases: updated, errors } = applyParams(previousPhases, params);
 		this.session.setTodoPhases?.(updated);
 		const storage = this.session.getSessionFile() ? "session" : "memory";