@gajae-code/coding-agent 0.4.3 → 0.4.5

package/src/tools/subagent-render.ts

@@ -0,0 +1,169 @@
+/**
+ * TUI renderer for the `subagent` tool.
+ *
+ * The await panel surfaces each awaited subagent's live streaming status at
+ * parity with the inline `task` panel by reusing `renderSubagentLiveProgress`.
+ * Falls back to a `running, no activity yet` placeholder when a live producer
+ * exists but has not emitted yet, and to a static status line when no live
+ * producer is available (resumed-from-disk or backward-compat records).
+ */
+import type { Component } from "@gajae-code/tui";
+import { Text } from "@gajae-code/tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { renderSubagentLiveProgress } from "../task/render";
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine } from "../tui";
+import {
+	formatDuration,
+	formatStatusIcon,
+	getPreviewLines,
+	replaceTabs,
+	type ToolUIStatus,
+	truncateToWidth,
+} from "./render-utils";
+import type { SubagentSnapshot, SubagentToolDetails } from "./subagent";
+
+const PREVIEW_LINES_COLLAPSED = 1;
+const PREVIEW_LINES_EXPANDED = 4;
+const PREVIEW_LINE_WIDTH = 80;
+
+function statusIconKind(status: SubagentSnapshot["status"]): ToolUIStatus {
+	switch (status) {
+		case "completed":
+		case "already_completed":
+			return "success";
+		case "failed":
+			return "error";
+		case "cancelled":
+		case "not_found":
+			return "warning";
+		case "queued":
+			return "pending";
+		default:
+			return "info";
+	}
+}
+
+function renderSubagentSnapshot(
+	snapshot: SubagentSnapshot,
+	expanded: boolean,
+	theme: Theme,
+	spinnerFrame: number | undefined,
+): string[] {
+	const lines: string[] = [];
+	const icon = formatStatusIcon(
+		statusIconKind(snapshot.status),
+		theme,
+		snapshot.status === "running" ? spinnerFrame : undefined,
+	);
+	const id = theme.fg("muted", snapshot.id);
+	const status = theme.fg("dim", snapshot.status);
+	const duration = theme.fg("dim", formatDuration(snapshot.durationMs));
+	lines.push(`${icon} ${id} ${status} ${duration}`);
+
+	// Static receipt fields (parity with the markdown content for non-await actions).
+	if (snapshot.jobId !== snapshot.id) lines.push(`  ${theme.fg("dim", `Job: ${snapshot.jobId}`)}`);
+	if (snapshot.agent && snapshot.agent !== "unknown") {
+		lines.push(`  ${theme.fg("dim", `Agent: ${snapshot.agent} (${snapshot.agentSource})`)}`);
+	}
+	if (snapshot.description) lines.push(`  ${theme.fg("dim", `Description: ${snapshot.description}`)}`);
+	if (snapshot.outputRef) lines.push(`  ${theme.fg("dim", `Output: ${snapshot.outputRef}`)}`);
+	if (snapshot.assignment) {
+		lines.push(`  ${theme.fg("dim", "Assignment:")}`);
+		for (const al of snapshot.assignment.split("\n")) lines.push(`    ${theme.fg("toolOutput", replaceTabs(al))}`);
+	}
+
+	// Defense in depth: the producer only attaches `progress` when a live
+	// producer exists (subagent.ts #liveProgressFields), but the renderer
+	// also honors an explicit `liveProgressAvailable: false` so stale retained
+	// progress can never resurrect a live panel (AC5).
+	if (snapshot.progress && snapshot.liveProgressAvailable !== false) {
+		// Live streaming panel (full task-panel parity), indented under the header.
+		for (const pl of renderSubagentLiveProgress(snapshot.progress, expanded, theme, spinnerFrame)) {
+			lines.push(`  ${pl}`);
+		}
+	} else if (snapshot.liveProgressAvailable && (snapshot.status === "running" || snapshot.status === "queued")) {
+		lines.push(`  ${theme.fg("dim", "running, no activity yet")}`);
+	}
+
+	const preview = snapshot.errorText?.trim() || snapshot.resultText?.trim();
+	if (preview) {
+		const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
+		const tone = snapshot.errorText ? "error" : "dim";
+		for (const pl of getPreviewLines(preview, maxLines, PREVIEW_LINE_WIDTH, Ellipsis.Unicode)) {
+			lines.push(`  ${theme.fg(tone, replaceTabs(pl))}`);
+		}
+		if (snapshot.truncated) {
+			lines.push(
+				`  ${theme.fg("dim", "Preview truncated; use the output ref or explicit ids with `verbosity=full` for more.")}`,
+			);
+		}
+	}
+
+	if (snapshot.guidance) lines.push(`  ${theme.fg("dim", snapshot.guidance)}`);
+	return lines;
+}
+
+export const subagentToolRenderer = {
+	inline: true,
+
+	renderCall(_args: unknown, _options: RenderResultOptions, theme: Theme): Component {
+		return new Text(renderStatusLine({ icon: "pending", title: "Subagent" }, theme), 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: SubagentToolDetails },
+		options: RenderResultOptions,
+		theme: Theme,
+	): Component {
+		const subagents = result.details?.subagents ?? [];
+		if (subagents.length === 0) {
+			const fallback = result.content.find(c => c.type === "text")?.text || "No subagents";
+			return new Text(theme.fg("dim", truncateToWidth(fallback, 100)), 0, 0);
+		}
+
+		const runningCount = subagents.filter(s => s.status === "running").length;
+
+		let cached: RenderCache | undefined;
+		return {
+			render(width: number): string[] {
+				const expanded = options.expanded;
+				const spinnerFrame = options.spinnerFrame ?? 0;
+				const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).digest();
+				if (cached?.key === key) return cached.lines;
+
+				const header = renderStatusLine(
+					{
+						icon: runningCount > 0 ? "info" : "success",
+						spinnerFrame: runningCount > 0 ? options.spinnerFrame : undefined,
+						title: "Subagent",
+						description:
+							runningCount > 0
+								? `awaiting ${runningCount} of ${subagents.length}`
+								: `${subagents.length} ${subagents.length === 1 ? "subagent" : "subagents"}`,
+					},
+					theme,
+				);
+
+				const lines: string[] = [header];
+				// Discoverability: the inline panel is a bounded preview; the session
+				// observer (ctrl+s) streams the full per-subagent message history.
+				if (runningCount > 0) {
+					lines.push(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`);
+				}
+				for (const snapshot of subagents) {
+					lines.push(...renderSubagentSnapshot(snapshot, expanded, theme, options.spinnerFrame));
+				}
+
+				const out = lines.map(l => (l.length > 0 ? truncateToWidth(l, width, Ellipsis.Omit) : ""));
+				cached = { key, lines: out };
+				return out;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
+	},
+
+	mergeCallAndResult: true,
+};

package/src/tools/subagent.ts

@@ -4,7 +4,7 @@ import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import { type AsyncJob, AsyncJobManager, type SubagentRecord } from "../async";
 import subagentDescription from "../prompts/tools/subagent.md" with { type: "text" };
-import type { AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource } from "../task/types";
 import { Ellipsis, truncateToWidth } from "../tui";
 import type { ToolSession } from "./index";
 import { replaceTabs } from "./render-utils";
@@ -63,6 +63,10 @@ export interface SubagentSnapshot {
 	outputRef?: string;
 	truncated?: boolean;
 	guidance?: string;
+	/** Live streaming progress for the awaited subagent (await panel only; UI detail). */
+	progress?: AgentProgress;
+	/** True when a live in-session progress producer exists for this subagent. */
+	liveProgressAvailable?: boolean;
 }
 
 export interface SubagentToolDetails {
@@ -322,10 +326,10 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		manager.watchJobs(watchedJobIds);
 		const progressTimer = onUpdate
 			? setInterval(() => {
-					onUpdate(this.#progressResult(manager, records));
+					onUpdate(this.#progressResult(manager, records, true));
 				}, 500)
 			: undefined;
-		onUpdate?.(this.#progressResult(manager, records));
+		onUpdate?.(this.#progressResult(manager, records, true));
 
 		let timedOut = false;
 		try {
@@ -355,6 +359,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			notFoundIds,
 			timedOut,
 			verbosity: params.verbosity ?? "receipt",
+			attachLiveProgress: true,
 		});
 	}
 
@@ -450,17 +455,29 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		return ids.filter(id => !this.#findVisibleRecord(manager, id, ownerFilter));
 	}
 
-	#progressResult(manager: AsyncJobManager, records: SubagentRecord[]): AgentToolResult<SubagentToolDetails> {
+	#progressResult(
+		manager: AsyncJobManager,
+		records: SubagentRecord[],
+		attachLiveProgress = false,
+	): AgentToolResult<SubagentToolDetails> {
 		return {
 			content: [{ type: "text", text: "" }],
-			details: { subagents: this.#recordSnapshots(manager, records, false, "receipt", new Set()) },
+			details: {
+				subagents: this.#recordSnapshots(manager, records, false, "receipt", new Set(), attachLiveProgress),
+			},
 		};
 	}
 
 	async #buildRecordResult(
 		manager: AsyncJobManager,
 		records: SubagentRecord[],
-		options: { title: string; notFoundIds?: string[]; timedOut?: boolean; verbosity?: SubagentParams["verbosity"] },
+		options: {
+			title: string;
+			notFoundIds?: string[];
+			timedOut?: boolean;
+			verbosity?: SubagentParams["verbosity"];
+			attachLiveProgress?: boolean;
+		},
 	): Promise<AgentToolResult<SubagentToolDetails>> {
 		const verifiedOutputIds = await this.#verifiedOutputIds(records);
 		const snapshots = this.#recordSnapshots(
@@ -469,6 +486,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			options.timedOut,
 			options.verbosity ?? "receipt",
 			verifiedOutputIds,
+			options.attachLiveProgress ?? false,
 		);
 		for (const id of options.notFoundIds ?? []) {
 			snapshots.push(this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."));
@@ -513,8 +531,28 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		timedOut = false,
 		verbosity: SubagentParams["verbosity"] = "receipt",
 		verifiedOutputIds: ReadonlySet<string>,
+		attachLiveProgress = false,
 	): SubagentSnapshot[] {
-		return records.map(record => this.#recordSnapshot(manager, record, timedOut, verbosity, verifiedOutputIds));
+		return records.map(record =>
+			this.#recordSnapshot(manager, record, timedOut, verbosity, verifiedOutputIds, attachLiveProgress),
+		);
+	}
+
+	#liveProgressFields(
+		manager: AsyncJobManager,
+		record: SubagentRecord,
+		attachLiveProgress: boolean,
+	): 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 {
+			liveProgressAvailable: true,
+			...(progress ? { progress } : {}),
+		};
 	}
 
 	#recordSnapshot(
@@ -523,7 +561,9 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		timedOut = false,
 		verbosity: SubagentParams["verbosity"] = "receipt",
 		verifiedOutputIds: ReadonlySet<string>,
+		attachLiveProgress = false,
 	): SubagentSnapshot {
+		const liveFields = this.#liveProgressFields(manager, record, attachLiveProgress);
 		const job = record.currentJobId ? manager.getJob(record.currentJobId) : undefined;
 		if (job) {
 			return {
@@ -531,6 +571,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 				id: record.subagentId,
 				jobId: record.currentJobId ?? job.id,
 				status: record.status,
+				...liveFields,
 			};
 		}
 		return {
@@ -542,6 +583,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			agentSource: "bundled",
 			durationMs: 0,
 			...(verifiedOutputIds.has(record.subagentId) ? { outputRef: `agent://${record.subagentId}` } : {}),
+			...liveFields,
 		};
 	}
 

package/src/utils/title-generator.ts

@@ -12,7 +12,7 @@ import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
-const DEFAULT_TERMINAL_TITLE = "π";
+const DEFAULT_TERMINAL_TITLE = "GJC";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
 const MAX_INPUT_CHARS = 2000;
@@ -20,6 +20,13 @@ const TITLE_MAX_TOKENS = 30;
 const REASONING_SAFE_MAX_TOKENS = 1024;
 const SET_TITLE_TOOL_NAME = "set_title";
 
+// Some models (notably cursor/composer-*) ignore the forced set_title tool call
+// and instead emit a long free-text narrative. Without the tool call we fall back
+// to the plain text, so cap its length: a real 3-6 word title never exceeds these.
+// Beyond the cap we treat the response as a non-title hallucination and reject it.
+const MAX_TITLE_CHARS = 80;
+const MAX_TITLE_WORDS = 12;
+
 const setTitleTool: Tool = {
 	name: SET_TITLE_TOOL_NAME,
 	description: "Set the generated session title.",
@@ -169,7 +176,14 @@ function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): stri
 			textTitle += content.text;
 		}
 	}
-	return textTitle.trim();
+	// Plain-text fallback (no set_title tool call): only accept it if it actually
+	// looks like a title. A model that ignored the tool and rambled produces a long
+	// blob — reject it so the caller falls back rather than persisting the narrative.
+	const trimmed = textTitle.trim();
+	if (trimmed.length > MAX_TITLE_CHARS || trimmed.split(/\s+/).length > MAX_TITLE_WORDS) {
+		return "";
+	}
+	return trimmed;
 }
 
 /**