@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/exec/idle-timeout-watchdog.ts

@@ -0,0 +1,126 @@
+export type ExecutionAbortReason = "idle-timeout" | "signal";
+
+export interface IdleTimeoutWatchdogOptions {
+	timeoutMs?: number;
+	signal?: AbortSignal;
+	hardTimeoutGraceMs: number;
+	onAbort?: (reason: ExecutionAbortReason) => void;
+}
+
+export class IdleTimeoutWatchdog {
+	#abortController = new AbortController();
+	#abortReason?: ExecutionAbortReason;
+	#hardTimeoutDeferred = Promise.withResolvers<"hard-timeout">();
+	#hardTimeoutGraceMs: number;
+	#hardTimeoutTimer?: NodeJS.Timeout;
+	#idleTimer?: NodeJS.Timeout;
+	#onAbort?: (reason: ExecutionAbortReason) => void;
+	#signal?: AbortSignal;
+	#signalAbortHandler?: () => void;
+	#timeoutMs?: number;
+
+	constructor(options: IdleTimeoutWatchdogOptions) {
+		this.#timeoutMs = options.timeoutMs;
+		this.#hardTimeoutGraceMs = options.hardTimeoutGraceMs;
+		this.#onAbort = options.onAbort;
+		this.#signal = options.signal;
+
+		if (this.#signal) {
+			if (this.#signal.aborted) {
+				this.#abort("signal");
+				return;
+			}
+
+			this.#signalAbortHandler = () => {
+				this.#abort("signal");
+			};
+			this.#signal.addEventListener("abort", this.#signalAbortHandler, { once: true });
+		}
+
+		this.touch();
+	}
+
+	get abortedBySignal(): boolean {
+		return this.#abortReason === "signal";
+	}
+
+	get hardTimeoutPromise(): Promise<"hard-timeout"> {
+		return this.#hardTimeoutDeferred.promise;
+	}
+
+	get signal(): AbortSignal {
+		return this.#abortController.signal;
+	}
+
+	get timedOut(): boolean {
+		return this.#abortReason === "idle-timeout";
+	}
+
+	touch(): void {
+		if (this.#abortReason || this.#timeoutMs === undefined || this.#timeoutMs <= 0) {
+			return;
+		}
+
+		if (this.#idleTimer) {
+			clearTimeout(this.#idleTimer);
+		}
+
+		this.#idleTimer = setTimeout(() => {
+			this.#abort("idle-timeout");
+		}, this.#timeoutMs);
+	}
+
+	dispose(): void {
+		if (this.#idleTimer) {
+			clearTimeout(this.#idleTimer);
+			this.#idleTimer = undefined;
+		}
+		if (this.#hardTimeoutTimer) {
+			clearTimeout(this.#hardTimeoutTimer);
+			this.#hardTimeoutTimer = undefined;
+		}
+		if (this.#signal && this.#signalAbortHandler) {
+			this.#signal.removeEventListener("abort", this.#signalAbortHandler);
+			this.#signalAbortHandler = undefined;
+		}
+	}
+
+	#abort(reason: ExecutionAbortReason): void {
+		if (this.#abortReason) {
+			return;
+		}
+
+		this.#abortReason = reason;
+
+		if (this.#idleTimer) {
+			clearTimeout(this.#idleTimer);
+			this.#idleTimer = undefined;
+		}
+
+		if (!this.#abortController.signal.aborted) {
+			this.#abortController.abort(reason);
+		}
+
+		this.#onAbort?.(reason);
+		this.#armHardTimeout();
+	}
+
+	#armHardTimeout(): void {
+		if (this.#hardTimeoutTimer || this.#hardTimeoutGraceMs <= 0) {
+			return;
+		}
+
+		this.#hardTimeoutTimer = setTimeout(() => {
+			this.#hardTimeoutDeferred.resolve("hard-timeout");
+		}, this.#hardTimeoutGraceMs);
+	}
+}
+
+export function formatIdleTimeoutMessage(timeoutMs?: number): string {
+	if (timeoutMs === undefined) {
+		return "Command timed out without output";
+	}
+
+	const seconds = Math.max(1, Math.round(timeoutMs / 1000));
+	return `Command timed out after ${seconds} seconds without output`;
+}

package/src/exec/non-interactive-env.ts

@@ -13,6 +13,11 @@ export const NON_INTERACTIVE_ENV: Readonly<Record<string, string>> = {
 	AWS_PAGER: "",
 	HOMEBREW_PAGER: "cat",
 	LESS: "FRX",
+	// Disable terminal features that can block the process.
+	TERM: "dumb",
+	GPG_TTY: "not a tty",
+	NO_COLOR: "1",
+	PYTHONUNBUFFERED: "1",
 	// Disable editor and terminal credential prompts.
 	GIT_EDITOR: "true",
 	VISUAL: "true",

package/src/extensibility/custom-commands/bundled/ci-green/index.ts

@@ -1,27 +1,15 @@
-import { renderPromptTemplate } from "../../../../config/prompt-templates";
+import { prompt } from "@oh-my-pi/pi-utils";
 import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
 import type { HookCommandContext } from "../../../../extensibility/hooks/types";
 import ciGreenRequestTemplate from "../../../../prompts/ci-green-request.md" with { type: "text" };
+import * as git from "../../../../utils/git";
 
 async function getHeadTag(api: CustomCommandAPI): Promise<string | undefined> {
-	const result = await api.exec("git", [
-		"for-each-ref",
-		"--points-at",
-		"HEAD",
-		"--sort=-version:refname",
-		"--format=%(refname:strip=2)",
-		"refs/tags",
-	]);
-
-	if (result.code !== 0 || result.killed) {
+	try {
+		return (await git.ref.tags(api.cwd))[0];
+	} catch {
 		return undefined;
 	}
-
-	const tag = result.stdout
-		.split("\n")
-		.map(line => line.trim())
-		.find(Boolean);
-	return tag || undefined;
 }
 
 export class GreenCommand implements CustomCommand {
@@ -32,6 +20,6 @@ export class GreenCommand implements CustomCommand {
 
 	async execute(_args: string[], _ctx: HookCommandContext): Promise<string> {
 		const headTag = await getHeadTag(this.api);
-		return renderPromptTemplate(ciGreenRequestTemplate, { headTag });
+		return prompt.render(ciGreenRequestTemplate, { headTag });
 	}
 }

package/src/extensibility/custom-commands/bundled/review/index.ts

@@ -11,10 +11,11 @@
  * rich context for the orchestrating agent to distribute work across
  * multiple reviewer agents based on diff weight and locality.
  */
-import { renderPromptTemplate } from "../../../../config/prompt-templates";
+import { prompt } from "@oh-my-pi/pi-utils";
 import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
 import type { HookCommandContext } from "../../../../extensibility/hooks/types";
 import reviewRequestTemplate from "../../../../prompts/review-request.md" with { type: "text" };
+import * as git from "../../../../utils/git";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -208,7 +209,7 @@ function buildReviewPrompt(mode: string, stats: DiffStats, rawDiff: string): str
 		hunksPreview: skipDiff ? getDiffPreview(f.hunks, linesPerFile) : "",
 	}));
 
-	return renderPromptTemplate(reviewRequestTemplate, {
+	return prompt.render(reviewRequestTemplate, {
 		mode,
 		files: filesWithExt,
 		excluded: stats.excluded,
@@ -258,20 +259,20 @@ export class ReviewCommand implements CustomCommand {
 				if (!baseBranch) return undefined;
 
 				const currentBranch = await getCurrentBranch(this.api);
-				const diffResult = await this.api.exec("git", ["diff", `${baseBranch}...${currentBranch}`], {
-					timeout: 30000,
-				});
-				if (diffResult.code !== 0) {
-					ctx.ui.notify(`Failed to get diff: ${diffResult.stderr}`, "error");
+				let diffText: string;
+				try {
+					diffText = await git.diff(this.api.cwd, { base: `${baseBranch}...${currentBranch}` });
+				} catch (err) {
+					ctx.ui.notify(`Failed to get diff: ${err instanceof Error ? err.message : String(err)}`, "error");
 					return undefined;
 				}
 
-				if (!diffResult.stdout.trim()) {
+				if (!diffText.trim()) {
 					ctx.ui.notify(`No changes between ${baseBranch} and ${currentBranch}`, "warning");
 					return undefined;
 				}
 
-				const stats = parseDiff(diffResult.stdout);
+				const stats = parseDiff(diffText);
 				if (stats.files.length === 0) {
 					ctx.ui.notify("No reviewable files (all changes filtered out)", "warning");
 					return undefined;
@@ -280,7 +281,7 @@ export class ReviewCommand implements CustomCommand {
 				return buildReviewPrompt(
 					`Reviewing changes between \`${baseBranch}\` and \`${currentBranch}\` (PR-style)`,
 					stats,
-					diffResult.stdout,
+					diffText,
 				);
 			}
 
@@ -292,12 +293,19 @@ export class ReviewCommand implements CustomCommand {
 					return undefined;
 				}
 
-				const [unstagedResult, stagedResult] = await Promise.all([
-					this.api.exec("git", ["diff"], { timeout: 30000 }),
-					this.api.exec("git", ["diff", "--cached"], { timeout: 30000 }),
-				]);
+				let unstagedDiff: string;
+				let stagedDiff: string;
+				try {
+					[unstagedDiff, stagedDiff] = await Promise.all([
+						git.diff(this.api.cwd),
+						git.diff(this.api.cwd, { cached: true }),
+					]);
+				} catch (err) {
+					ctx.ui.notify(`Failed to get diff: ${err instanceof Error ? err.message : String(err)}`, "error");
+					return undefined;
+				}
 
-				const combinedDiff = [unstagedResult.stdout, stagedResult.stdout].filter(Boolean).join("\n");
+				const combinedDiff = [unstagedDiff, stagedDiff].filter(Boolean).join("\n");
 
 				if (!combinedDiff.trim()) {
 					ctx.ui.notify("No diff content found", "warning");
@@ -327,25 +335,26 @@ export class ReviewCommand implements CustomCommand {
 				// Extract commit hash from selection (format: "abc1234 message")
 				const hash = selected.split(" ")[0];
 
-				// Get the commit diff (with timeout)
-				const showResult = await this.api.exec("git", ["show", "--format=", hash], { timeout: 30000 });
-				if (showResult.code !== 0) {
-					ctx.ui.notify(`Failed to get commit: ${showResult.stderr}`, "error");
+				let diffText: string;
+				try {
+					diffText = await git.show(this.api.cwd, hash, { format: "" });
+				} catch (err) {
+					ctx.ui.notify(`Failed to get commit: ${err instanceof Error ? err.message : String(err)}`, "error");
 					return undefined;
 				}
 
-				if (!showResult.stdout.trim()) {
+				if (!diffText.trim()) {
 					ctx.ui.notify("Commit has no diff content", "warning");
 					return undefined;
 				}
 
-				const stats = parseDiff(showResult.stdout);
+				const stats = parseDiff(diffText);
 				if (stats.files.length === 0) {
 					ctx.ui.notify("No reviewable files in commit (all changes filtered out)", "warning");
 					return undefined;
 				}
 
-				return buildReviewPrompt(`Reviewing commit \`${hash}\``, stats, showResult.stdout);
+				return buildReviewPrompt(`Reviewing commit \`${hash}\``, stats, diffText);
 			}
 
 			case 4: {
@@ -354,16 +363,21 @@ export class ReviewCommand implements CustomCommand {
 				if (!instructions?.trim()) return undefined;
 
 				// For custom, we still try to get current diff for context
-				const diffResult = await this.api.exec("git", ["diff", "HEAD"], { timeout: 30000 });
-				const hasDiff = diffResult.code === 0 && diffResult.stdout.trim();
+				let diffText: string | undefined;
+				try {
+					diffText = await git.diff(this.api.cwd, { base: "HEAD" });
+				} catch {
+					diffText = undefined;
+				}
+				const reviewDiff = diffText?.trim();
 
-				if (hasDiff) {
-					const stats = parseDiff(diffResult.stdout);
+				if (reviewDiff) {
+					const stats = parseDiff(reviewDiff);
 					// Even if all files filtered, include the custom instructions
 					return `${buildReviewPrompt(
 						`Custom review: ${instructions.split("\n")[0].slice(0, 60)}…`,
 						stats,
-						diffResult.stdout,
+						reviewDiff,
 					)}\n\n### Additional Instructions\n\n${instructions}`;
 				}
 
@@ -388,12 +402,7 @@ Use the Task tool with \`agent: "reviewer"\` to execute this review.`;
 
 async function getGitBranches(api: CustomCommandAPI): Promise<string[]> {
 	try {
-		const result = await api.exec("git", ["branch", "-a", "--format=%(refname:short)"]);
-		if (result.code !== 0) return [];
-		return result.stdout
-			.split("\n")
-			.map(b => b.trim())
-			.filter(Boolean);
+		return await git.branch.list(api.cwd, { all: true });
 	} catch {
 		return [];
 	}
@@ -401,8 +410,7 @@ async function getGitBranches(api: CustomCommandAPI): Promise<string[]> {
 
 async function getCurrentBranch(api: CustomCommandAPI): Promise<string> {
 	try {
-		const result = await api.exec("git", ["branch", "--show-current"]);
-		return result.stdout.trim() || "HEAD";
+		return (await git.branch.current(api.cwd)) ?? "HEAD";
 	} catch {
 		return "HEAD";
 	}
@@ -410,8 +418,7 @@ async function getCurrentBranch(api: CustomCommandAPI): Promise<string> {
 
 async function getGitStatus(api: CustomCommandAPI): Promise<string> {
 	try {
-		const result = await api.exec("git", ["status", "--porcelain"]);
-		return result.stdout;
+		return await git.status(api.cwd);
 	} catch {
 		return "";
 	}
@@ -419,12 +426,7 @@ async function getGitStatus(api: CustomCommandAPI): Promise<string> {
 
 async function getRecentCommits(api: CustomCommandAPI, count: number): Promise<string[]> {
 	try {
-		const result = await api.exec("git", ["log", `-${count}`, "--oneline", "--no-decorate"]);
-		if (result.code !== 0) return [];
-		return result.stdout
-			.split("\n")
-			.map(c => c.trim())
-			.filter(Boolean);
+		return await git.log.onelines(api.cwd, count);
 	} catch {
 		return [];
 	}

package/src/extensibility/custom-commands/loader.ts

@@ -6,7 +6,6 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import { getAgentDir, getProjectDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import * as typebox from "@sinclair/typebox";
 import { getConfigDirs } from "../../config";
@@ -184,7 +183,7 @@ export async function loadCustomCommands(options: LoadCustomCommandsOptions = {}
 		exec: (command: string, args: string[], execOptions) =>
 			execCommand(command, args, execOptions?.cwd ?? cwd, execOptions),
 		typebox,
-		pi: piCodingAgent,
+		pi: await import("@oh-my-pi/pi-coding-agent"),
 	};
 
 	// 1. Load bundled commands first (lowest priority - can be overridden)

package/src/extensibility/custom-tools/loader.ts

@@ -5,7 +5,7 @@
  * to avoid import resolution issues with custom tools loaded from user directories.
  */
 import * as path from "node:path";
-import * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger } from "@oh-my-pi/pi-utils";
 import * as typebox from "@sinclair/typebox";
 import { toolCapability } from "../../capability/tool";
@@ -14,7 +14,6 @@ import type { ExecOptions } from "../../exec/exec";
 import { execCommand } from "../../exec/exec";
 import type { HookUIContext } from "../../extensibility/hooks/types";
 import { getAllPluginToolPaths } from "../../extensibility/plugins/loader";
-import type { PendingActionStore } from "../../tools/pending-action";
 import { createNoOpUIContext, resolvePath } from "../utils";
 import type { CustomToolAPI, CustomToolFactory, LoadedCustomTool, ToolLoadError } from "./types";
 
@@ -85,7 +84,17 @@ export class CustomToolLoader {
 	#sharedApi: CustomToolAPI;
 	#seenNames: Set<string>;
 
-	constructor(cwd: string, builtInToolNames: string[], pendingActionStore?: PendingActionStore) {
+	constructor(
+		pi: typeof import("@oh-my-pi/pi-coding-agent"),
+		cwd: string,
+		builtInToolNames: string[],
+		pushPendingAction?: (action: {
+			label: string;
+			sourceToolName: string;
+			apply(reason: string): Promise<AgentToolResult<unknown>>;
+			reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+		}) => void,
+	) {
 		this.#sharedApi = {
 			cwd,
 			exec: (command: string, args: string[], options?: ExecOptions) =>
@@ -94,17 +103,16 @@ export class CustomToolLoader {
 			hasUI: false,
 			logger,
 			typebox,
-			pi: piCodingAgent,
+			pi,
 			pushPendingAction: action => {
-				if (!pendingActionStore) {
+				if (!pushPendingAction) {
 					throw new Error("Pending action store unavailable for custom tools in this runtime.");
 				}
-				pendingActionStore.push({
+				pushPendingAction({
 					label: action.label,
 					sourceToolName: action.sourceToolName ?? "custom_tool",
 					apply: action.apply,
 					reject: action.reject,
-					details: action.details,
 				});
 			},
 		};
@@ -155,9 +163,19 @@ export async function loadCustomTools(
 	pathsWithSources: ToolPathWithSource[],
 	cwd: string,
 	builtInToolNames: string[],
-	pendingActionStore?: PendingActionStore,
+	pushPendingAction?: (action: {
+		label: string;
+		sourceToolName: string;
+		apply(reason: string): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+	}) => void,
 ) {
-	const loader = new CustomToolLoader(cwd, builtInToolNames, pendingActionStore);
+	const loader = new CustomToolLoader(
+		await import("@oh-my-pi/pi-coding-agent"),
+		cwd,
+		builtInToolNames,
+		pushPendingAction,
+	);
 	await loader.load(pathsWithSources);
 	return {
 		tools: loader.tools,
@@ -182,7 +200,12 @@ export async function discoverAndLoadCustomTools(
 	configuredPaths: string[],
 	cwd: string,
 	builtInToolNames: string[],
-	pendingActionStore?: PendingActionStore,
+	pushPendingAction?: (action: {
+		label: string;
+		sourceToolName: string;
+		apply(reason: string): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+	}) => void,
 ) {
 	const allPathsWithSources: ToolPathWithSource[] = [];
 	const seen = new Set<string>();
@@ -216,5 +239,5 @@ export async function discoverAndLoadCustomTools(
 		addPath(resolvePath(configPath, cwd), { provider: "config", providerName: "Config", level: "project" });
 	}
 
-	return loadCustomTools(allPathsWithSources, cwd, builtInToolNames, pendingActionStore);
+	return loadCustomTools(allPathsWithSources, cwd, builtInToolNames, pushPendingAction);
 }

package/src/extensibility/custom-tools/types.ts

@@ -94,7 +94,7 @@ export type CustomToolSessionEvent =
 	  }
 	| {
 			reason: "auto_compaction_start";
-			trigger: "threshold" | "overflow";
+			trigger: "threshold" | "overflow" | "idle";
 			action: "context-full" | "handoff";
 	  }
 	| {

package/src/extensibility/extensions/loader.ts

@@ -6,7 +6,6 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model, TextContent } from "@oh-my-pi/pi-ai";
-import * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
@@ -102,7 +101,6 @@ export class ExtensionRuntime implements IExtensionRuntime {
 class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	readonly logger = logger;
 	readonly typebox = TypeBox;
-	readonly pi = piCodingAgent;
 	readonly flagValues = new Map<string, boolean | string>();
 	readonly pendingProviderRegistrations: Array<{
 		name: string;
@@ -111,6 +109,7 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	}> = [];
 
 	constructor(
+		public readonly pi: typeof import("@oh-my-pi/pi-coding-agent"),
 		private readonly extension: Extension,
 		private readonly runtime: IExtensionRuntime,
 		private readonly cwd: string,
@@ -265,7 +264,13 @@ async function loadExtension(
 		}
 
 		const extension = createExtension(extensionPath, resolvedPath);
-		const api = new ConcreteExtensionAPI(extension, runtime, cwd, eventBus);
+		const api = new ConcreteExtensionAPI(
+			await import("@oh-my-pi/pi-coding-agent"),
+			extension,
+			runtime,
+			cwd,
+			eventBus,
+		);
 		await factory(api);
 
 		return { extension, error: null };
@@ -286,7 +291,7 @@ export async function loadExtensionFromFactory(
 	name = "<inline>",
 ): Promise<Extension> {
 	const extension = createExtension(name, name);
-	const api = new ConcreteExtensionAPI(extension, runtime, cwd, eventBus);
+	const api = new ConcreteExtensionAPI(await import("@oh-my-pi/pi-coding-agent"), extension, runtime, cwd, eventBus);
 	await factory(api);
 	return extension;
 }

package/src/extensibility/extensions/runner.ts

@@ -262,6 +262,10 @@ export class ExtensionRunner {
 		return allFlags;
 	}
 
+	getFlagValues(): Map<string, boolean | string> {
+		return new Map(this.runtime.flagValues);
+	}
+
 	setFlagValue(name: string, value: boolean | string): void {
 		this.runtime.flagValues.set(name, value);
 	}
@@ -695,7 +699,26 @@ export class ExtensionRunner {
 
 	async emitContext(messages: AgentMessage[]): Promise<AgentMessage[]> {
 		const ctx = this.createContext();
-		let currentMessages = structuredClone(messages);
+
+		// Check if any extensions actually have context handlers before cloning
+		let hasContextHandlers = false;
+		for (const ext of this.extensions) {
+			if (ext.handlers.get("context")?.length) {
+				hasContextHandlers = true;
+				break;
+			}
+		}
+		if (!hasContextHandlers) return messages;
+
+		let currentMessages: AgentMessage[];
+		try {
+			currentMessages = structuredClone(messages);
+		} catch {
+			// Messages may contain non-cloneable objects (e.g. in ToolResultMessage.details
+			// or ProviderPayload). Fall back to a shallow array clone — extensions should
+			// return new message arrays rather than mutating in place.
+			currentMessages = [...messages];
+		}
 
 		for (const ext of this.extensions) {
 			const handlers = ext.handlers.get("context");

package/src/extensibility/extensions/types.ts

@@ -28,11 +28,11 @@ import type { Static, TSchema } from "@sinclair/typebox";
 import type { Rule } from "../../capability/rule";
 import type { KeybindingsManager } from "../../config/keybindings";
 import type { ModelRegistry } from "../../config/model-registry";
+import type { EditToolDetails } from "../../edit";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { PythonResult } from "../../ipy/executor";
 import type { Theme } from "../../modes/theme/theme";
-import type { EditToolDetails } from "../../patch";
 import type { CompactionPreparation, CompactionResult } from "../../session/compaction";
 import type { CustomMessage } from "../../session/messages";
 import type {
@@ -81,6 +81,8 @@ export interface ExtensionUIDialogOptions {
 	onLeft?: () => void;
 	/** Invoked when user presses right arrow in select dialogs */
 	onRight?: () => void;
+	/** Invoked when user presses the external editor shortcut in select dialogs */
+	onExternalEditor?: () => void;
 	/** Optional footer hint text rendered by interactive selector */
 	helpText?: string;
 }
@@ -566,7 +568,7 @@ export interface ToolExecutionEndEvent {
 /** Fired when auto-compaction starts */
 export interface AutoCompactionStartEvent {
 	type: "auto_compaction_start";
-	reason: "threshold" | "overflow";
+	reason: "threshold" | "overflow" | "idle";
 	action: "context-full" | "handoff";
 }
 

package/src/extensibility/hooks/loader.ts

@@ -2,7 +2,6 @@
  * Hook loader - loads TypeScript hook modules using native Bun import.
  */
 import * as path from "node:path";
-import * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import { logger } from "@oh-my-pi/pi-utils";
 import * as typebox from "@sinclair/typebox";
 import { hookCapability } from "../../capability/hook";
@@ -87,16 +86,16 @@ export interface LoadHooksResult {
  * Create a HookAPI instance that collects handlers, renderers, and commands.
  * Returns the API, maps, and functions to set handlers later.
  */
-function createHookAPI(
+async function createHookAPI(
 	handlers: Map<string, HandlerFn[]>,
 	cwd: string,
-): {
+): Promise<{
 	api: HookAPI;
 	messageRenderers: Map<string, HookMessageRenderer>;
 	commands: Map<string, RegisteredCommand>;
 	setSendMessageHandler: (handler: SendMessageHandler) => void;
 	setAppendEntryHandler: (handler: AppendEntryHandler) => void;
-} {
+}> {
 	let sendMessageHandler: SendMessageHandler | null = null;
 	let appendEntryHandler: AppendEntryHandler | null = null;
 	const messageRenderers = new Map<string, HookMessageRenderer>();
@@ -137,7 +136,7 @@ function createHookAPI(
 		},
 		logger,
 		typebox,
-		pi: piCodingAgent,
+		pi: await import("@oh-my-pi/pi-coding-agent"),
 	} as HookAPI;
 
 	return {
@@ -170,7 +169,7 @@ async function loadHook(hookPath: string, cwd: string): Promise<{ hook: LoadedHo
 
 		// Create handlers map and API
 		const handlers = new Map<string, HandlerFn[]>();
-		const { api, messageRenderers, commands, setSendMessageHandler, setAppendEntryHandler } = createHookAPI(
+		const { api, messageRenderers, commands, setSendMessageHandler, setAppendEntryHandler } = await createHookAPI(
 			handlers,
 			cwd,
 		);