@oh-my-pi/pi-coding-agent 15.5.15 → 15.6.0

package/src/tools/todo-write.ts

@@ -35,9 +35,15 @@ export interface TodoPhase {
 	tasks: TodoItem[];
 }
 
+export interface TodoCompletionTransition {
+	phase: string;
+	content: string;
+}
+
 export interface TodoWriteToolDetails {
 	phases: TodoPhase[];
 	storage: "session" | "memory";
+	completedTasks?: TodoCompletionTransition[];
 }
 
 // =============================================================================
@@ -97,6 +103,31 @@ function clonePhases(phases: TodoPhase[]): TodoPhase[] {
 	return phases.map(phase => ({ name: phase.name, tasks: phase.tasks.map(cloneTask) }));
 }
 
+function todoTransitionKey(phase: string, content: string): string {
+	return `${phase}\u0000${content}`;
+}
+
+function getCompletionTransitions(previous: TodoPhase[], updated: TodoPhase[]): TodoCompletionTransition[] {
+	const previousStatuses = new Map<string, TodoStatus>();
+	for (const phase of previous) {
+		for (const task of phase.tasks) {
+			previousStatuses.set(todoTransitionKey(phase.name, task.content), task.status);
+		}
+	}
+
+	const transitions: TodoCompletionTransition[] = [];
+	for (const phase of updated) {
+		for (const task of phase.tasks) {
+			if (task.status !== "completed") continue;
+			const previousStatus = previousStatuses.get(todoTransitionKey(phase.name, task.content));
+			if (previousStatus && previousStatus !== "completed") {
+				transitions.push({ phase: phase.name, content: task.content });
+			}
+		}
+	}
+	return transitions;
+}
+
 function normalizeInProgressTask(phases: TodoPhase[]): void {
 	const orderedTasks = phases.flatMap(phase => phase.tasks);
 	if (orderedTasks.length === 0) return;
@@ -577,13 +608,16 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<TodoWriteToolDetails>> {
 		const previousPhases = clonePhases(this.session.getTodoPhases?.() ?? []);
-		const { phases: updated, errors } = applyParams(previousPhases, params);
+		const { phases: updated, errors } = applyParams(clonePhases(previousPhases), params);
+		const completedTasks = getCompletionTransitions(previousPhases, updated);
 		this.session.setTodoPhases?.(updated);
 		const storage = this.session.getSessionFile() ? "session" : "memory";
+		const details: TodoWriteToolDetails = { phases: updated, storage };
+		if (completedTasks.length > 0) details.completedTasks = completedTasks;
 
 		return {
 			content: [{ type: "text", text: formatSummary(updated, errors) }],
-			details: { phases: updated, storage },
+			details,
 			isError: errors.length > 0 ? true : undefined,
 		};
 	}
@@ -667,16 +701,55 @@ function noteMarker(count: number, uiTheme: Theme): string {
 	return uiTheme.fg("dim", chalk.italic(` \u207a${toSuperscript(count)}`));
 }
 
-function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
+export const TODO_WRITE_STRIKE_HOLD_FRAMES = 2;
+export const TODO_WRITE_STRIKE_REVEAL_FRAMES = 12;
+export const TODO_WRITE_STRIKE_TOTAL_FRAMES = TODO_WRITE_STRIKE_HOLD_FRAMES + TODO_WRITE_STRIKE_REVEAL_FRAMES;
+const EMPTY_COMPLETION_KEYS = new Set<string>();
+const STRIKE_START = "\x1b[9m";
+const STRIKE_END = "\x1b[29m";
+
+function strikethroughText(text: string): string {
+	return `${STRIKE_START}${text}${STRIKE_END}`;
+}
+
+function partialStrikethrough(text: string, visibleChars: number): string {
+	if (visibleChars <= 0) return text;
+	const chars = [...text];
+	if (visibleChars >= chars.length) return strikethroughText(text);
+	return `${strikethroughText(chars.slice(0, visibleChars).join(""))}${chars.slice(visibleChars).join("")}`;
+}
+
+function strikeRevealCount(text: string, frame: number | undefined): number | undefined {
+	if (frame === undefined) return undefined;
+	if (frame <= TODO_WRITE_STRIKE_HOLD_FRAMES) return 0;
+	const chars = [...text];
+	if (chars.length === 0) return undefined;
+	const revealFrame = Math.min(frame - TODO_WRITE_STRIKE_HOLD_FRAMES, TODO_WRITE_STRIKE_REVEAL_FRAMES);
+	return Math.ceil((chars.length * revealFrame) / TODO_WRITE_STRIKE_REVEAL_FRAMES);
+}
+
+function formatTodoLine(
+	item: TodoItem,
+	uiTheme: Theme,
+	prefix: string,
+	completionKeys: Set<string>,
+	frame: number | undefined,
+): 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)}`) + marker;
+		case "completed": {
+			const revealCount = completionKeys.has(item.content) ? strikeRevealCount(item.content, frame) : undefined;
+			const content =
+				revealCount === undefined
+					? strikethroughText(item.content)
+					: partialStrikethrough(item.content, revealCount);
+			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${content}`) + marker;
+		}
 		case "in_progress":
 			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
 		case "abandoned":
-			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${chalk.strikethrough(item.content)}`) + marker;
+			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(item.content)}`) + marker;
 		default:
 			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
 	}
@@ -722,6 +795,16 @@ export const todoWriteToolRenderer = {
 		_args?: TodoWriteRenderArgs,
 	): Component {
 		const phases = (result.details?.phases ?? []).filter(phase => phase.tasks.length > 0);
+		const completedTasks = result.details?.completedTasks ?? [];
+		const completionKeysByPhase = new Map<string, Set<string>>();
+		for (const task of completedTasks) {
+			let keys = completionKeysByPhase.get(task.phase);
+			if (!keys) {
+				keys = new Set<string>();
+				completionKeysByPhase.set(task.phase, keys);
+			}
+			keys.add(task.content);
+		}
 		const allTasks = phases.flatMap(phase => phase.tasks);
 		const header = renderStatusLine(
 			{ icon: "success", title: "Todo Write", meta: [`${allTasks.length} tasks`] },
@@ -732,29 +815,45 @@ export const todoWriteToolRenderer = {
 			return new Text(`${header}\n${uiTheme.fg("dim", fallback)}`, 0, 0);
 		}
 
-		const { expanded } = options;
-		const lines: string[] = [header];
-		for (let p = 0; p < phases.length; p++) {
-			const phase = phases[p];
-			if (phases.length > 1) {
-				lines.push(uiTheme.fg("accent", chalk.bold(`  ${formatPhaseDisplayName(phase.name, p + 1)}`)));
-			}
-			const treeLines = renderTreeList(
-				{
-					items: phase.tasks,
-					expanded,
-					maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-					itemType: "todo",
-					renderItem: todo => formatTodoLine(todo, uiTheme, ""),
-				},
-				uiTheme,
-			);
-			for (const line of treeLines) {
-				lines.push(`  ${line}`);
-			}
-		}
-		lines.push(...renderNoteAttachments(phases, uiTheme));
-		return new Text(lines.join("\n"), 0, 0);
+		let cachedKey: string | undefined;
+		let cachedLines: string[] | undefined;
+		return {
+			invalidate(): void {
+				cachedKey = undefined;
+				cachedLines = undefined;
+			},
+			render(width: number): string[] {
+				const { expanded, spinnerFrame } = options;
+				const key = `${expanded ? 1 : 0}:${spinnerFrame ?? -1}:${width}`;
+				if (cachedKey === key && cachedLines) return cachedLines;
+
+				const lines: string[] = [header];
+				for (let p = 0; p < phases.length; p++) {
+					const phase = phases[p];
+					if (phases.length > 1) {
+						lines.push(uiTheme.fg("accent", chalk.bold(`  ${formatPhaseDisplayName(phase.name, p + 1)}`)));
+					}
+					const completionKeys = completionKeysByPhase.get(phase.name) ?? EMPTY_COMPLETION_KEYS;
+					const treeLines = renderTreeList(
+						{
+							items: phase.tasks,
+							expanded,
+							maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+							itemType: "todo",
+							renderItem: todo => formatTodoLine(todo, uiTheme, "", completionKeys, spinnerFrame),
+						},
+						uiTheme,
+					);
+					for (const line of treeLines) {
+						lines.push(`  ${line}`);
+					}
+				}
+				lines.push(...renderNoteAttachments(phases, uiTheme));
+				cachedKey = key;
+				cachedLines = lines;
+				return lines;
+			},
+		};
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/tool-result.ts

@@ -12,6 +12,7 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 	#details: TDetails;
 	#meta = outputMeta();
 	#content: ToolContent = [];
+	#isError = false;
 
 	constructor(details?: TDetails) {
 		this.#details = details ?? ({} as TDetails);
@@ -67,6 +68,12 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 		return this;
 	}
 
+	/** Flag the result as a non-throwing failure (agent-loop surfaces it as a tool error). */
+	error(value = true): this {
+		this.#isError = value;
+		return this;
+	}
+
 	done(): AgentToolResult<TDetails> {
 		const meta = this.#meta.get();
 		if (meta) {
@@ -77,6 +84,7 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 		return {
 			content: this.#content,
 			details: hasDetails ? this.#details : undefined,
+			...(this.#isError ? { isError: true } : {}),
 		};
 	}
 }

package/src/utils/title-generator.ts

@@ -9,13 +9,16 @@ import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
+import { ONLINE_TINY_TITLE_MODEL_KEY } from "../tiny/models";
+import { formatTitleUserMessage, normalizeGeneratedTitle } from "../tiny/text";
+import { tinyTitleClient } from "../tiny/title-client";
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
 const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
-const MAX_INPUT_CHARS = 2000;
+export const TITLE_LOCAL_FALLBACK_DELAY_MS = 10_000;
 const TITLE_MAX_TOKENS = 30;
 const REASONING_SAFE_MAX_TOKENS = 1024;
 const SET_TITLE_TOOL_NAME = "set_title";
@@ -48,6 +51,78 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 	return undefined;
 }
 
+export async function raceFirstNonNull<T>(
+	primary: Promise<T | null>,
+	startFallback: () => Promise<T | null>,
+	delayMs: number = TITLE_LOCAL_FALLBACK_DELAY_MS,
+	onPrimaryWinAfterFallback?: () => void,
+): Promise<T | null> {
+	const { promise, resolve } = Promise.withResolvers<T | null>();
+	let resolved = false;
+	let primarySettled = false;
+	let fallbackStarted = false;
+	let fallbackSettled = false;
+
+	const resolveOnce = (value: T | null): void => {
+		if (resolved) return;
+		resolved = true;
+		resolve(value);
+	};
+	const maybeResolveNull = (): void => {
+		if (primarySettled && fallbackStarted && fallbackSettled) resolveOnce(null);
+	};
+	const startFallbackOnce = (): void => {
+		if (fallbackStarted || resolved) return;
+		fallbackStarted = true;
+		let fallback: Promise<T | null>;
+		try {
+			fallback = startFallback();
+		} catch {
+			fallbackSettled = true;
+			maybeResolveNull();
+			return;
+		}
+		void fallback.then(
+			value => {
+				fallbackSettled = true;
+				if (value !== null) resolveOnce(value);
+				else maybeResolveNull();
+			},
+			() => {
+				fallbackSettled = true;
+				maybeResolveNull();
+			},
+		);
+	};
+
+	const timer = setTimeout(startFallbackOnce, delayMs);
+	void primary.then(
+		value => {
+			primarySettled = true;
+			clearTimeout(timer);
+			if (value !== null) {
+				if (fallbackStarted) onPrimaryWinAfterFallback?.();
+				resolveOnce(value);
+				return;
+			}
+			startFallbackOnce();
+			maybeResolveNull();
+		},
+		() => {
+			primarySettled = true;
+			clearTimeout(timer);
+			startFallbackOnce();
+			maybeResolveNull();
+		},
+	);
+
+	try {
+		return await promise;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 /**
  * Generate a title for a session based on the first user message.
  *
@@ -68,6 +143,41 @@ export async function generateSessionTitle(
 	sessionId?: string,
 	currentModel?: Model<Api>,
 	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+): Promise<string | null> {
+	const tinyModel = settings.get("providers.tinyModel");
+	if (tinyModel === ONLINE_TINY_TITLE_MODEL_KEY) {
+		return generateTitleOnline(firstMessage, registry, settings, sessionId, currentModel, metadataResolver);
+	}
+
+	const onlineAbortController = new AbortController();
+	const localTitle = tinyTitleClient.generate(tinyModel, firstMessage).then(
+		title => title || null,
+		() => null,
+	);
+	const startOnline = (): Promise<string | null> =>
+		generateTitleOnline(
+			firstMessage,
+			registry,
+			settings,
+			sessionId,
+			currentModel,
+			metadataResolver,
+			onlineAbortController.signal,
+		);
+
+	return raceFirstNonNull(localTitle, startOnline, TITLE_LOCAL_FALLBACK_DELAY_MS, () => {
+		onlineAbortController.abort();
+	});
+}
+
+export async function generateTitleOnline(
+	firstMessage: string,
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+	currentModel?: Model<Api>,
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+	signal?: AbortSignal,
 ): Promise<string | null> {
 	const model = getTitleModel(registry, settings, currentModel);
 	if (!model) {
@@ -75,12 +185,7 @@ export async function generateSessionTitle(
 		return null;
 	}
 
-	// Truncate message if too long
-	const truncatedMessage =
-		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}…` : firstMessage;
-	const userMessage = `<user-message>
-${truncatedMessage}
-</user-message>`;
+	const userMessage = formatTitleUserMessage(firstMessage);
 
 	const apiKey = await registry.getApiKey(model, sessionId);
 	if (!apiKey) {
@@ -122,6 +227,7 @@ ${truncatedMessage}
 				disableReasoning: true,
 				toolChoice: { type: "tool", name: SET_TITLE_TOOL_NAME },
 				metadata,
+				signal,
 			},
 		);
 
@@ -134,7 +240,7 @@ ${truncatedMessage}
 			return null;
 		}
 
-		const title = extractGeneratedTitle(response.content);
+		const title = normalizeGeneratedTitle(extractGeneratedTitle(response.content));
 
 		logger.debug("title-generator: response", {
 			model: request.model,
@@ -143,11 +249,7 @@ ${truncatedMessage}
 			stopReason: response.stopReason,
 		});
 
-		if (!title) {
-			return null;
-		}
-
-		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+		return title;
 	} catch (err) {
 		logger.debug("title-generator: error", {
 			model: request.model,

package/src/tools/hindsight-recall.ts

@@ -1,69 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
-import { formatCurrentTime, formatMemories } from "../hindsight/content";
-import recallDescription from "../prompts/tools/recall.md" with { type: "text" };
-import type { ToolSession } from ".";
-
-const hindsightRecallSchema = z.object({
-	query: z.string().describe("natural language search query"),
-});
-
-export type HindsightRecallParams = z.infer<typeof hindsightRecallSchema>;
-
-export class HindsightRecallTool implements AgentTool<typeof hindsightRecallSchema> {
-	readonly name = "recall";
-	readonly approval = "read" as const;
-	readonly label = "Recall";
-	readonly description = recallDescription;
-	readonly parameters = hindsightRecallSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-	readonly summary = "Search hindsight memory for relevant prior context";
-
-	constructor(private readonly session: ToolSession) {}
-
-	static createIf(session: ToolSession): HindsightRecallTool | null {
-		if (session.settings.get("memory.backend") !== "hindsight") return null;
-		return new HindsightRecallTool(session);
-	}
-
-	async execute(_id: string, params: HindsightRecallParams, signal?: AbortSignal): Promise<AgentToolResult> {
-		return untilAborted(signal, async () => {
-			const state = this.session.getHindsightSessionState?.();
-			if (!state) {
-				throw new Error("Hindsight backend is not initialised for this session.");
-			}
-
-			try {
-				const response = await state.client.recall(state.bankId, params.query, {
-					budget: state.config.recallBudget,
-					maxTokens: state.config.recallMaxTokens,
-					types: state.config.recallTypes.length > 0 ? state.config.recallTypes : undefined,
-					tags: state.recallTags,
-					tagsMatch: state.recallTagsMatch,
-				});
-				const results = response.results ?? [];
-				if (results.length === 0) {
-					return {
-						content: [{ type: "text", text: "No relevant memories found." }],
-						details: {},
-					};
-				}
-				const formatted = formatMemories(results);
-				return {
-					content: [
-						{
-							type: "text",
-							text: `Found ${results.length} relevant memories (as of ${formatCurrentTime()} UTC):\n\n${formatted}`,
-						},
-					],
-					details: {},
-				};
-			} catch (err) {
-				logger.warn("recall failed", { bankId: state.bankId, error: String(err) });
-				throw err instanceof Error ? err : new Error(String(err));
-			}
-		});
-	}
-}

package/src/tools/hindsight-reflect.ts

@@ -1,58 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
-import { ensureBankMission } from "../hindsight/bank";
-import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
-import type { ToolSession } from ".";
-
-const hindsightReflectSchema = z.object({
-	query: z.string().describe("question to answer"),
-	context: z.string().describe("optional context").optional(),
-});
-
-export type HindsightReflectParams = z.infer<typeof hindsightReflectSchema>;
-
-export class HindsightReflectTool implements AgentTool<typeof hindsightReflectSchema> {
-	readonly name = "reflect";
-	readonly approval = "read" as const;
-	readonly label = "Reflect";
-	readonly description = reflectDescription;
-	readonly parameters = hindsightReflectSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-	readonly summary = "Reflect on recent work and write hindsight memory";
-
-	constructor(private readonly session: ToolSession) {}
-
-	static createIf(session: ToolSession): HindsightReflectTool | null {
-		if (session.settings.get("memory.backend") !== "hindsight") return null;
-		return new HindsightReflectTool(session);
-	}
-
-	async execute(_id: string, params: HindsightReflectParams, signal?: AbortSignal): Promise<AgentToolResult> {
-		return untilAborted(signal, async () => {
-			const state = this.session.getHindsightSessionState?.();
-			if (!state) {
-				throw new Error("Hindsight backend is not initialised for this session.");
-			}
-
-			try {
-				await ensureBankMission(state.client, state.bankId, state.config, state.missionsSet);
-				const response = await state.client.reflect(state.bankId, params.query, {
-					context: params.context,
-					budget: state.config.recallBudget,
-					tags: state.recallTags,
-					tagsMatch: state.recallTagsMatch,
-				});
-				const text = response.text?.trim() || "No relevant information found to reflect on.";
-				return {
-					content: [{ type: "text", text }],
-					details: {},
-				};
-			} catch (err) {
-				logger.warn("reflect failed", { bankId: state.bankId, error: String(err) });
-				throw err instanceof Error ? err : new Error(String(err));
-			}
-		});
-	}
-}

package/src/tools/hindsight-retain.ts

@@ -1,57 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import * as z from "zod/v4";
-import retainDescription from "../prompts/tools/retain.md" with { type: "text" };
-import type { ToolSession } from ".";
-
-const hindsightRetainSchema = z.object({
-	items: z
-		.array(
-			z.object({
-				content: z.string().describe("information to remember"),
-				context: z.string().describe("source context").optional(),
-			}),
-		)
-		.min(1)
-		.describe("memories to retain"),
-});
-
-export type HindsightRetainParams = z.infer<typeof hindsightRetainSchema>;
-export class HindsightRetainTool implements AgentTool<typeof hindsightRetainSchema> {
-	readonly name = "retain";
-	readonly approval = "read" as const;
-	readonly label = "Retain";
-	readonly description = retainDescription;
-	readonly parameters = hindsightRetainSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-	readonly summary = "Store important facts in hindsight memory";
-
-	constructor(private readonly session: ToolSession) {}
-
-	static createIf(session: ToolSession): HindsightRetainTool | null {
-		if (session.settings.get("memory.backend") !== "hindsight") return null;
-		return new HindsightRetainTool(session);
-	}
-
-	async execute(_id: string, params: HindsightRetainParams): Promise<AgentToolResult> {
-		const state = this.session.getHindsightSessionState?.();
-		if (!state) {
-			throw new Error("Hindsight backend is not initialised for this session.");
-		}
-
-		// Push every item onto the session-owned queue and return immediately.
-		// The queue flushes either when it reaches its batch threshold or when
-		// its debounce timer fires. If the eventual batch fails, the queue
-		// surfaces a UI-only warning notice — the LLM is not informed.
-		for (const item of params.items) {
-			state.enqueueRetain(item.content, item.context);
-		}
-
-		const count = params.items.length;
-		const noun = count === 1 ? "memory" : "memories";
-		return {
-			content: [{ type: "text", text: `${count} ${noun} queued.` }],
-			details: { count },
-		};
-	}
-}