my-pi 0.1.0 → 0.1.2

package/dist/{api-1ZXLxSgP.js → api-BVS4nqfD.js}

@@ -60,6 +60,10 @@ function parse_chain_yaml(raw) {
 	if (current && current_step) current.steps.push(current_step);
 	return chains;
 }
+function should_inject_chain_prompt(event) {
+	const selected_tools = event.systemPromptOptions?.selectedTools;
+	return !selected_tools || selected_tools.includes("run_chain");
+}
 function parse_agent_file(filePath) {
 	try {
 		const { frontmatter, body } = parseFrontmatter(readFileSync(filePath, "utf-8"));
@@ -290,6 +294,7 @@ async function chain(pi) {
 	});
 	pi.on("before_agent_start", async (event) => {
 		if (!active_chain || chains.length === 0) return {};
+		if (!should_inject_chain_prompt(event)) return {};
 		const flow = active_chain.steps.map((s) => s.agent).join(" -> ");
 		const step_list = active_chain.steps.map((s, i) => {
 			const desc = agents.get(s.agent.toLowerCase())?.description || "unknown";
@@ -340,7 +345,7 @@ Switch chains with /chain <name>.` };
 }
 //#endregion
 //#region src/extensions/config.ts
-const DEFAULT_CONFIG$2 = {
+const DEFAULT_CONFIG$3 = {
 	version: 1,
 	enabled: {}
 };
@@ -420,6 +425,31 @@ const BUILTIN_EXTENSIONS = [
 			"session",
 			"auto-name"
 		]
+	},
+	{
+		key: "confirm-destructive",
+		label: "Confirm destructive",
+		description: "Prompt before destructive session actions like clear, switch, and fork",
+		cli_flag: "--no-confirm-destructive",
+		aliases: ["confirm-destructive", "confirm"]
+	},
+	{
+		key: "hooks-resolution",
+		label: "Hooks resolution",
+		description: "Claude Code style PostToolUse hook compatibility from .claude, .rulesync, and .pi configs",
+		cli_flag: "--no-hooks",
+		aliases: ["hooks-resolution", "hooks"]
+	},
+	{
+		key: "working-indicator",
+		label: "Working indicator",
+		description: "Customizable streaming working indicator with /working-indicator command",
+		cli_flag: "--no-working-indicator",
+		aliases: [
+			"working-indicator",
+			"indicator",
+			"spinner"
+		]
 	}
 ];
 function get_builtin_extensions_config_path() {
@@ -427,7 +457,7 @@ function get_builtin_extensions_config_path() {
 }
 function load_builtin_extensions_config() {
 	const path = get_builtin_extensions_config_path();
-	if (!existsSync(path)) return { ...DEFAULT_CONFIG$2 };
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG$3 };
 	try {
 		const raw = readFileSync(path, "utf-8");
 		const parsed = JSON.parse(raw);
@@ -441,7 +471,7 @@ function load_builtin_extensions_config() {
 			enabled
 		};
 	} catch {
-		return { ...DEFAULT_CONFIG$2 };
+		return { ...DEFAULT_CONFIG$3 };
 	}
 }
 function save_builtin_extensions_config(config) {
@@ -483,6 +513,33 @@ function find_builtin_extension(query) {
 	].some((value) => value.toLowerCase() === normalized));
 }
 //#endregion
+//#region src/extensions/confirm-destructive.ts
+async function confirm_destructive(pi) {
+	pi.on("session_before_switch", async (event, ctx) => {
+		if (!ctx.hasUI) return;
+		if (event.reason === "new") {
+			if (!await ctx.ui.confirm("Clear session?", "This will delete all messages in the current session.")) {
+				ctx.ui.notify("Clear cancelled", "info");
+				return { cancel: true };
+			}
+			return;
+		}
+		if (ctx.sessionManager.getEntries().some((e) => e.type === "message" && e.message.role === "user")) {
+			if (!await ctx.ui.confirm("Switch session?", "You have messages in the current session. Switch anyway?")) {
+				ctx.ui.notify("Switch cancelled", "info");
+				return { cancel: true };
+			}
+		}
+	});
+	pi.on("session_before_fork", async (event, ctx) => {
+		if (!ctx.hasUI) return;
+		if (await ctx.ui.select(`Fork from entry ${event.entryId.slice(0, 8)}?`, ["Yes, create fork", "No, stay in current session"]) !== "Yes, create fork") {
+			ctx.ui.notify("Fork cancelled", "info");
+			return { cancel: true };
+		}
+	});
+}
+//#endregion
 //#region src/extensions/extensions.ts
 const ENABLED$2 = "[x]";
 const DISABLED$2 = "[ ]";
@@ -546,6 +603,66 @@ function save_extension_enabled(key, enabled) {
 }
 function create_extensions_extension(options = {}) {
 	const force_disabled = to_force_disabled_set(options.force_disabled);
+	async function show_manager(ctx) {
+		if (!ctx.hasUI) return false;
+		const states = resolve_builtin_extension_states(force_disabled);
+		const initial_enabled = new Set(states.filter((state) => state.saved_enabled).map((state) => state.key));
+		const current_enabled = new Set(initial_enabled);
+		await ctx.ui.custom((tui, theme, _kb, done) => {
+			const items = states.map(to_setting_item$1);
+			const container = new Container();
+			container.addChild({
+				render: () => {
+					const saved_enabled = current_enabled.size;
+					const saved_disabled = states.length - saved_enabled;
+					const enabled_now = [...current_enabled].filter((key) => !force_disabled.has(key)).length;
+					const disabled_now = states.length - enabled_now;
+					return [
+						theme.fg("accent", theme.bold("Built-in extensions")),
+						theme.fg("muted", `${saved_enabled} saved enabled • ${saved_disabled} saved disabled • ${enabled_now} enabled now • ${disabled_now} disabled now`),
+						""
+					];
+				},
+				invalidate: () => {}
+			});
+			const settings_list = new SettingsList(items, Math.min(Math.max(items.length + 4, 8), 16), {
+				cursor: theme.fg("accent", "›"),
+				label: (text, selected) => selected ? theme.fg("accent", text) : text,
+				value: (text, selected) => {
+					const color = text === ENABLED$2 ? "success" : "dim";
+					const rendered = theme.fg(color, text);
+					return selected ? theme.bold(theme.fg("accent", rendered)) : rendered;
+				},
+				description: (text) => theme.fg("muted", text),
+				hint: (text) => theme.fg("dim", text)
+			}, (id, new_value) => {
+				const key = id;
+				const enabled = new_value === ENABLED$2;
+				if (enabled) current_enabled.add(key);
+				else current_enabled.delete(key);
+				save_extension_enabled(key, enabled);
+			}, () => done(void 0), { enableSearch: true });
+			container.addChild(settings_list);
+			container.addChild(new Text(theme.fg("dim", "esc close • search filters • changes save immediately • CLI --no-* flags still win in this process"), 0, 1));
+			return {
+				render(width) {
+					return container.render(width);
+				},
+				invalidate() {
+					container.invalidate();
+				},
+				handleInput(data) {
+					settings_list.handleInput(data);
+					tui.requestRender();
+				}
+			};
+		});
+		if (!sets_equal$2(initial_enabled, current_enabled)) {
+			ctx.ui.notify(force_disabled.size > 0 ? "Reloading to apply updated built-in extensions. CLI --no-* flags still force-disable some extensions in this process." : "Reloading to apply updated built-in extensions...", "info");
+			await ctx.reload();
+		}
+		return true;
+	}
 	return async function extensions(pi) {
 		const subs = [
 			"list",
@@ -577,65 +694,8 @@ function create_extensions_extension(options = {}) {
 			},
 			handler: async (args, ctx) => {
 				const trimmed = args.trim();
-				if (!trimmed && ctx.hasUI) {
-					const states = resolve_builtin_extension_states(force_disabled);
-					const initial_enabled = new Set(states.filter((state) => state.saved_enabled).map((state) => state.key));
-					const current_enabled = new Set(initial_enabled);
-					await ctx.ui.custom((tui, theme, _kb, done) => {
-						const items = states.map(to_setting_item$1);
-						const container = new Container();
-						container.addChild({
-							render: () => {
-								const saved_enabled = current_enabled.size;
-								const saved_disabled = states.length - saved_enabled;
-								const enabled_now = [...current_enabled].filter((key) => !force_disabled.has(key)).length;
-								const disabled_now = states.length - enabled_now;
-								return [
-									theme.fg("accent", theme.bold("Built-in extensions")),
-									theme.fg("muted", `${saved_enabled} saved enabled • ${saved_disabled} saved disabled • ${enabled_now} enabled now • ${disabled_now} disabled now`),
-									""
-								];
-							},
-							invalidate: () => {}
-						});
-						const settings_list = new SettingsList(items, Math.min(Math.max(items.length + 4, 8), 16), {
-							cursor: theme.fg("accent", "›"),
-							label: (text, selected) => selected ? theme.fg("accent", text) : text,
-							value: (text, selected) => {
-								const color = text === ENABLED$2 ? "success" : "dim";
-								const rendered = theme.fg(color, text);
-								return selected ? theme.bold(theme.fg("accent", rendered)) : rendered;
-							},
-							description: (text) => theme.fg("muted", text),
-							hint: (text) => theme.fg("dim", text)
-						}, (id, new_value) => {
-							const key = id;
-							const enabled = new_value === ENABLED$2;
-							if (enabled) current_enabled.add(key);
-							else current_enabled.delete(key);
-							save_extension_enabled(key, enabled);
-						}, () => done(void 0), { enableSearch: true });
-						container.addChild(settings_list);
-						container.addChild(new Text(theme.fg("dim", "esc close • search filters • changes save immediately • CLI --no-* flags still win in this process"), 0, 1));
-						return {
-							render(width) {
-								return container.render(width);
-							},
-							invalidate() {
-								container.invalidate();
-							},
-							handleInput(data) {
-								settings_list.handleInput(data);
-								tui.requestRender();
-							}
-						};
-					});
-					if (!sets_equal$2(initial_enabled, current_enabled)) {
-						ctx.ui.notify(force_disabled.size > 0 ? "Reloading to apply updated built-in extensions. CLI --no-* flags still force-disable some extensions in this process." : "Reloading to apply updated built-in extensions...", "info");
-						await ctx.reload();
-						return;
-					}
-					return;
+				if (!trimmed) {
+					if (await show_manager(ctx)) return;
 				}
 				const [sub, ...rest] = (trimmed || "list").split(/\s+/);
 				const arg = rest.join(" ");
@@ -648,6 +708,7 @@ function create_extensions_extension(options = {}) {
 					case "disable":
 					case "toggle": {
 						if (!arg) {
+							if (await show_manager(ctx)) return;
 							ctx.ui.notify(`Usage: /extensions ${sub} <key>`, "warning");
 							return;
 						}
@@ -896,6 +957,312 @@ async function handoff(pi) {
 	});
 }
 //#endregion
+//#region src/extensions/hooks-resolution.ts
+const HOOK_TIMEOUT_MS = 600 * 1e3;
+function is_file(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+function as_record(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	return value;
+}
+function walk_up_directories(start_dir, stop_dir) {
+	const directories = [];
+	const has_stop_dir = stop_dir !== void 0;
+	let current = resolve(start_dir);
+	let parent = dirname(current);
+	let reached_stop_dir = has_stop_dir && current === stop_dir;
+	let reached_filesystem_root = parent === current;
+	directories.push(current);
+	while (!reached_stop_dir && !reached_filesystem_root) {
+		current = parent;
+		parent = dirname(current);
+		reached_stop_dir = has_stop_dir && current === stop_dir;
+		reached_filesystem_root = parent === current;
+		directories.push(current);
+	}
+	return directories;
+}
+function find_nearest_git_root(start_dir) {
+	for (const directory of walk_up_directories(start_dir)) if (existsSync(join(directory, ".git"))) return directory;
+}
+function has_hooks_config(directory) {
+	return is_file(join(directory, ".claude", "settings.json")) || is_file(join(directory, ".rulesync", "hooks.json")) || is_file(join(directory, ".pi", "hooks.json"));
+}
+function find_project_dir(cwd) {
+	const git_root = find_nearest_git_root(cwd);
+	for (const directory of walk_up_directories(cwd, git_root)) if (has_hooks_config(directory)) return directory;
+	return git_root ?? resolve(cwd);
+}
+function read_json_file(path) {
+	if (!is_file(path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+function resolve_hook_command(command, project_dir) {
+	return command.replace(/\$CLAUDE_PROJECT_DIR\b/g, project_dir);
+}
+function compile_matcher(matcher_text) {
+	if (matcher_text === void 0) return void 0;
+	try {
+		return new RegExp(matcher_text);
+	} catch {
+		return;
+	}
+}
+function create_hook(event_name, matcher_text, command, source, project_dir) {
+	const matcher = compile_matcher(matcher_text);
+	if (matcher_text !== void 0 && matcher === void 0) return void 0;
+	return {
+		event_name,
+		matcher,
+		matcher_text,
+		command: resolve_hook_command(command, project_dir),
+		source
+	};
+}
+function get_hook_entries(hooks_record, event_name) {
+	const keys = event_name === "PostToolUse" ? ["PostToolUse", "postToolUse"] : ["PostToolUseFailure", "postToolUseFailure"];
+	for (const key of keys) {
+		const value = hooks_record[key];
+		if (Array.isArray(value)) return value;
+	}
+	return [];
+}
+function parse_claude_settings_hooks(config, source, project_dir) {
+	const root = as_record(config);
+	const hooks_root = root ? as_record(root.hooks) : void 0;
+	if (!hooks_root) return [];
+	const hooks = [];
+	for (const event_name of ["PostToolUse", "PostToolUseFailure"]) {
+		const entries = get_hook_entries(hooks_root, event_name);
+		for (const entry of entries) {
+			const entry_record = as_record(entry);
+			if (!entry_record || !Array.isArray(entry_record.hooks)) continue;
+			const matcher_text = typeof entry_record.matcher === "string" ? entry_record.matcher : void 0;
+			for (const nested_hook of entry_record.hooks) {
+				const nested_record = as_record(nested_hook);
+				if (!nested_record) continue;
+				if (nested_record.type !== "command") continue;
+				if (typeof nested_record.command !== "string") continue;
+				const hook = create_hook(event_name, matcher_text, nested_record.command, source, project_dir);
+				if (hook) hooks.push(hook);
+			}
+		}
+	}
+	return hooks;
+}
+function parse_simple_hooks_file(config, source, project_dir) {
+	const root = as_record(config);
+	const hooks_root = root ? as_record(root.hooks) : void 0;
+	if (!hooks_root) return [];
+	const hooks = [];
+	for (const event_name of ["PostToolUse", "PostToolUseFailure"]) {
+		const entries = get_hook_entries(hooks_root, event_name);
+		for (const entry of entries) {
+			const entry_record = as_record(entry);
+			if (!entry_record || typeof entry_record.command !== "string") continue;
+			const hook = create_hook(event_name, typeof entry_record.matcher === "string" ? entry_record.matcher : void 0, entry_record.command, source, project_dir);
+			if (hook) hooks.push(hook);
+		}
+	}
+	return hooks;
+}
+function load_hooks(cwd) {
+	const project_dir = find_project_dir(cwd);
+	const hooks = [];
+	const claude_settings_path = join(project_dir, ".claude", "settings.json");
+	const rulesync_hooks_path = join(project_dir, ".rulesync", "hooks.json");
+	const pi_hooks_path = join(project_dir, ".pi", "hooks.json");
+	const claude_settings = read_json_file(claude_settings_path);
+	if (claude_settings !== void 0) hooks.push(...parse_claude_settings_hooks(claude_settings, claude_settings_path, project_dir));
+	const rulesync_hooks = read_json_file(rulesync_hooks_path);
+	if (rulesync_hooks !== void 0) hooks.push(...parse_simple_hooks_file(rulesync_hooks, rulesync_hooks_path, project_dir));
+	const pi_hooks = read_json_file(pi_hooks_path);
+	if (pi_hooks !== void 0) hooks.push(...parse_simple_hooks_file(pi_hooks, pi_hooks_path, project_dir));
+	return {
+		project_dir,
+		hooks
+	};
+}
+function to_claude_tool_name(tool_name) {
+	if (tool_name === "ls") return "LS";
+	if (tool_name.length === 0) return tool_name;
+	return tool_name[0].toUpperCase() + tool_name.slice(1);
+}
+function matches_hook(hook, tool_name) {
+	if (!hook.matcher) return true;
+	const claude_tool_name = to_claude_tool_name(tool_name);
+	hook.matcher.lastIndex = 0;
+	if (hook.matcher.test(tool_name)) return true;
+	hook.matcher.lastIndex = 0;
+	return hook.matcher.test(claude_tool_name);
+}
+function extract_text_content(content) {
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const item_record = item;
+		if (item_record.type === "text" && typeof item_record.text === "string") parts.push(item_record.text);
+	}
+	return parts.join("\n");
+}
+function normalize_tool_input(input) {
+	const normalized = { ...input };
+	const path_value = typeof input.path === "string" ? input.path : void 0;
+	if (path_value !== void 0) {
+		normalized.file_path = path_value;
+		normalized.filePath = path_value;
+	}
+	return normalized;
+}
+function build_tool_response(event, normalized_input) {
+	const response = {
+		is_error: event.isError,
+		isError: event.isError,
+		content: event.content,
+		text: extract_text_content(event.content),
+		details: event.details ?? null
+	};
+	const file_path = typeof normalized_input.file_path === "string" ? normalized_input.file_path : void 0;
+	if (file_path !== void 0) {
+		response.file_path = file_path;
+		response.filePath = file_path;
+	}
+	return response;
+}
+function build_hook_payload(event, event_name, ctx, project_dir) {
+	const normalized_input = normalize_tool_input(event.input);
+	return {
+		session_id: ctx.sessionManager.getSessionFile() ?? "ephemeral",
+		cwd: ctx.cwd,
+		claude_project_dir: project_dir,
+		hook_event_name: event_name,
+		tool_name: to_claude_tool_name(event.toolName),
+		tool_call_id: event.toolCallId,
+		tool_input: normalized_input,
+		tool_response: build_tool_response(event, normalized_input)
+	};
+}
+async function run_command_hook(command, cwd, payload) {
+	return await new Promise((resolve) => {
+		const started_at = Date.now();
+		const child = spawn("bash", ["-lc", command], {
+			cwd,
+			env: {
+				...process.env,
+				CLAUDE_PROJECT_DIR: cwd
+			},
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		let timed_out = false;
+		let resolved = false;
+		const finish = (code) => {
+			if (resolved) return;
+			resolved = true;
+			resolve({
+				code,
+				stdout,
+				stderr,
+				elapsed_ms: Date.now() - started_at,
+				timed_out
+			});
+		};
+		const timeout = setTimeout(() => {
+			timed_out = true;
+			child.kill("SIGTERM");
+			setTimeout(() => {
+				child.kill("SIGKILL");
+			}, 1e3).unref?.();
+		}, HOOK_TIMEOUT_MS);
+		timeout.unref?.();
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString("utf8");
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString("utf8");
+		});
+		child.on("error", (error) => {
+			clearTimeout(timeout);
+			stderr += `${error.message}\n`;
+			finish(-1);
+		});
+		child.on("close", (code) => {
+			clearTimeout(timeout);
+			finish(code ?? -1);
+		});
+		try {
+			child.stdin.write(JSON.stringify(payload));
+			child.stdin.end();
+		} catch (error) {
+			stderr += `${error instanceof Error ? error.message : String(error)}\n`;
+		}
+	});
+}
+function hook_event_name_for_result(event) {
+	return event.isError ? "PostToolUseFailure" : "PostToolUse";
+}
+function format_duration$1(elapsed_ms) {
+	if (elapsed_ms < 1e3) return `${elapsed_ms}ms`;
+	return `${(elapsed_ms / 1e3).toFixed(1)}s`;
+}
+function hook_name(command) {
+	const sh_path_match = command.match(/[^\s|;&]+\.sh\b/);
+	if (sh_path_match) return basename(sh_path_match[0]);
+	return basename(command.trim().split(/\s+/)[0] ?? "hook");
+}
+function create_hooks_resolution_extension(options = {}) {
+	const load_hooks_impl = options.load_hooks ?? load_hooks;
+	const run_command_hook_impl = options.run_command_hook ?? run_command_hook;
+	return async function hooks_resolution(pi) {
+		let state = {
+			project_dir: process.cwd(),
+			hooks: []
+		};
+		const refresh_hooks = (cwd) => {
+			state = load_hooks_impl(cwd);
+		};
+		pi.on("session_start", (_event, ctx) => {
+			refresh_hooks(ctx.cwd);
+		});
+		pi.on("tool_result", async (event, ctx) => {
+			if (state.hooks.length === 0) return;
+			const event_name = hook_event_name_for_result(event);
+			const matching_hooks = state.hooks.filter((hook) => hook.event_name === event_name && matches_hook(hook, event.toolName));
+			if (matching_hooks.length === 0) return;
+			const payload = build_hook_payload(event, event_name, ctx, state.project_dir);
+			const executed_commands = /* @__PURE__ */ new Set();
+			for (const hook of matching_hooks) {
+				if (executed_commands.has(hook.command)) continue;
+				executed_commands.add(hook.command);
+				const result = await run_command_hook_impl(hook.command, state.project_dir, payload);
+				const name = hook_name(hook.command);
+				const duration = format_duration$1(result.elapsed_ms);
+				if (ctx.hasUI) if (result.code === 0) ctx.ui.notify(`Hook \`${name}\` ran (${duration})`, "info");
+				else {
+					const error_line = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+					ctx.ui.notify(`Hook \`${name}\` failed (${duration}): ${error_line}`, "warning");
+				}
+			}
+		});
+	};
+}
+var hooks_resolution_default = create_hooks_resolution_extension();
+//#endregion
 //#region src/lsp/client.ts
 var LspClientStartError = class extends Error {
 	command;
@@ -2164,6 +2531,14 @@ function load_mcp_config(cwd) {
 }
 //#endregion
 //#region src/extensions/mcp.ts
+function create_server_states(configs) {
+	return new Map(configs.map((config) => [config.name, {
+		config,
+		tool_names: [],
+		enabled: true,
+		status: "disconnected"
+	}]));
+}
 function remove_server_tools_from_active(pi, tool_names) {
 	const tool_set = new Set(tool_names);
 	pi.setActiveTools(pi.getActiveTools().filter((tool) => !tool_set.has(tool)));
@@ -2176,16 +2551,56 @@ function format_server_status(state) {
 		default: return state.enabled ? "not connected yet" : "disabled";
 	}
 }
+function count_pending_enabled_servers(servers) {
+	return Array.from(servers.values()).filter((state) => state.enabled && state.status !== "connected").length;
+}
+function update_mcp_status(ctx, servers) {
+	if (servers.size === 0) {
+		ctx.ui.setStatus("mcp", void 0);
+		return;
+	}
+	const states = Array.from(servers.values());
+	const enabled = states.filter((state) => state.enabled).length;
+	const connected = states.filter((state) => state.enabled && state.status === "connected").length;
+	const connecting = states.filter((state) => state.enabled && state.status === "connecting").length;
+	const failed = states.filter((state) => state.enabled && state.status === "failed").length;
+	const fragments = [`MCP ${connected}/${enabled} connected`];
+	if (connecting > 0) fragments.push(`${connecting} connecting`);
+	if (failed > 0) fragments.push(`${failed} failed`);
+	ctx.ui.setStatus("mcp", ctx.ui.theme.fg("dim", fragments.join(" · ")));
+}
+function set_connect_feedback(ctx, pending_server_count) {
+	const label = pending_server_count === 1 ? "Connecting 1 MCP server..." : `Connecting ${pending_server_count} MCP servers...`;
+	ctx.ui.setWorkingMessage(label);
+	ctx.ui.setWorkingIndicator({
+		frames: [
+			ctx.ui.theme.fg("dim", "·"),
+			ctx.ui.theme.fg("muted", "•"),
+			ctx.ui.theme.fg("accent", "●"),
+			ctx.ui.theme.fg("muted", "•")
+		],
+		intervalMs: 120
+	});
+	ctx.ui.setStatus("mcp", ctx.ui.theme.fg("dim", label));
+	return () => {
+		ctx.ui.setWorkingMessage();
+		ctx.ui.setWorkingIndicator();
+	};
+}
+function should_wait_for_mcp_connections(event) {
+	const selected_tools = event.systemPromptOptions?.selectedTools;
+	return !selected_tools || selected_tools.some((tool) => tool.startsWith("mcp__"));
+}
 async function mcp(pi) {
-	const configs = load_mcp_config(process.cwd());
-	const servers = new Map(configs.map((config) => [config.name, {
-		config,
-		tool_names: [],
-		enabled: true,
-		status: "disconnected"
-	}]));
+	let initialized_cwd = null;
+	let servers = /* @__PURE__ */ new Map();
 	const registered_tool_names = /* @__PURE__ */ new Set();
-	const connect_server = async (state) => {
+	const ensure_servers = (cwd) => {
+		if (initialized_cwd !== null) return;
+		servers = create_server_states(load_mcp_config(cwd));
+		initialized_cwd = cwd;
+	};
+	const connect_server = async (state, ctx) => {
 		if (state.status === "connected") return;
 		if (state.connect_promise) {
 			await state.connect_promise;
@@ -2194,6 +2609,7 @@ async function mcp(pi) {
 		state.connect_promise = (async () => {
 			state.status = "connecting";
 			state.error = void 0;
+			if (ctx) update_mcp_status(ctx, servers);
 			const client = new McpClient(state.config);
 			try {
 				await client.connect();
@@ -2237,19 +2653,39 @@ async function mcp(pi) {
 				throw error;
 			} finally {
 				state.connect_promise = void 0;
+				if (ctx) update_mcp_status(ctx, servers);
 			}
 		})();
 		await state.connect_promise;
 	};
 	const connect_all_servers = async (options = {}) => {
-		await Promise.allSettled(Array.from(servers.values()).filter((state) => state.enabled).filter((state) => options.include_failed || state.status !== "failed").map((state) => connect_server(state)));
+		await Promise.allSettled(Array.from(servers.values()).filter((state) => state.enabled).filter((state) => options.include_failed || state.status !== "failed").map((state) => connect_server(state, options.ctx)));
+		if (options.ctx) update_mcp_status(options.ctx, servers);
 	};
-	pi.on("session_start", async () => {
-		connect_all_servers();
+	pi.on("session_start", async (_event, ctx) => {
+		ensure_servers(ctx.cwd);
+		update_mcp_status(ctx, servers);
+		connect_all_servers({ ctx });
 	});
-	pi.on("before_agent_start", async (event) => {
-		await connect_all_servers();
-		return event;
+	pi.on("before_agent_start", async (event, ctx) => {
+		ensure_servers(ctx.cwd);
+		if (!should_wait_for_mcp_connections(event)) {
+			connect_all_servers({ ctx });
+			return event;
+		}
+		const pending_server_count = count_pending_enabled_servers(servers);
+		if (pending_server_count === 0) {
+			update_mcp_status(ctx, servers);
+			return event;
+		}
+		const restore_feedback = set_connect_feedback(ctx, pending_server_count);
+		try {
+			await connect_all_servers({ ctx });
+			return event;
+		} finally {
+			restore_feedback();
+			update_mcp_status(ctx, servers);
+		}
 	});
 	pi.registerCommand("mcp", {
 		description: "Manage MCP servers (list, enable, disable)",
@@ -2273,6 +2709,7 @@ async function mcp(pi) {
 			return null;
 		},
 		handler: async (args, ctx) => {
+			ensure_servers(ctx.cwd);
 			const [sub, ...rest] = args.trim().split(/\s+/);
 			const name = rest.join(" ");
 			switch (sub || "list") {
@@ -2283,6 +2720,7 @@ async function mcp(pi) {
 					}
 					const lines = [];
 					for (const [sname, state] of servers.entries()) lines.push(`${sname} (${format_server_status(state)}) — ${state.tool_names.length} tools${state.error ? ` — ${state.error}` : ""}`);
+					update_mcp_status(ctx, servers);
 					ctx.ui.notify(lines.join("\n"));
 					break;
 				}
@@ -2299,7 +2737,8 @@ async function mcp(pi) {
 					server.enabled = true;
 					if (server.status === "connected") {
 						const active = pi.getActiveTools();
-						pi.setActiveTools([...active, ...server.tool_names]);
+						pi.setActiveTools([...new Set([...active, ...server.tool_names])]);
+						update_mcp_status(ctx, servers);
 						ctx.ui.notify(`Enabled ${name}`);
 						return;
 					}
@@ -2307,7 +2746,8 @@ async function mcp(pi) {
 						server.status = "disconnected";
 						server.error = void 0;
 					}
-					connect_server(server);
+					update_mcp_status(ctx, servers);
+					connect_server(server, ctx);
 					ctx.ui.notify(`Enabling ${name} and connecting in background`);
 					break;
 				}
@@ -2323,6 +2763,7 @@ async function mcp(pi) {
 					}
 					server.enabled = false;
 					remove_server_tools_from_active(pi, server.tool_names);
+					update_mcp_status(ctx, servers);
 					ctx.ui.notify(`Disabled ${name}`);
 					break;
 				}
@@ -2330,13 +2771,14 @@ async function mcp(pi) {
 			}
 		}
 	});
-	pi.on("session_shutdown", async () => {
+	pi.on("session_shutdown", async (_event, ctx) => {
 		await Promise.allSettled(Array.from(servers.values()).map(async (server) => {
 			await server.connect_promise?.catch(() => {});
 			await server.client?.disconnect();
 			server.client = void 0;
 			if (server.status !== "failed") server.status = "disconnected";
 		}));
+		ctx.ui.setStatus("mcp", void 0);
 	});
 }
 //#endregion
@@ -2608,6 +3050,24 @@ function format_token_count(count) {
 	if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
 	return `${Math.round(count / 1e6)}M`;
 }
+function render_footer_status_line(theme, width, left_items, right_item) {
+	const left = sanitize_status_text(left_items.join(" "));
+	const right = right_item ? sanitize_status_text(right_item) : "";
+	if (!left && !right) return void 0;
+	if (!right) return truncateToWidth(theme.fg("dim", left), width, theme.fg("dim", "..."));
+	if (!left) {
+		const themed_right = theme.fg("dim", right);
+		const right_width = visibleWidth(themed_right);
+		return right_width >= width ? truncateToWidth(themed_right, width, theme.fg("dim", "...")) : `${" ".repeat(width - right_width)}${themed_right}`;
+	}
+	const right_width = visibleWidth(right);
+	if (right_width >= width) return truncateToWidth(theme.fg("dim", right), width, theme.fg("dim", "..."));
+	const min_gap = 1;
+	const truncated_left = truncateToWidth(left, Math.max(0, width - right_width - min_gap), "...");
+	const left_width = visibleWidth(truncated_left);
+	const gap = Math.max(min_gap, width - left_width - right_width);
+	return theme.fg("dim", truncated_left) + " ".repeat(gap) + theme.fg("dim", right);
+}
 function get_current_thinking_level(ctx) {
 	const entries = ctx.sessionManager.getEntries();
 	for (let i = entries.length - 1; i >= 0; i--) {
@@ -2687,14 +3147,8 @@ function render_footer_lines(ctx, theme, footer_data, width, active_base_name, a
 	const dim_remainder = theme.fg("dim", remainder);
 	const lines = [truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "...")), dim_stats_left + dim_remainder];
 	const prompt_status = get_footer_prompt_status(active_base_name, active_layers);
-	if (prompt_status) {
-		const themed_status = theme.fg("dim", prompt_status);
-		const status_width = visibleWidth(themed_status);
-		const aligned_status = status_width >= width ? truncateToWidth(themed_status, width, theme.fg("dim", "...")) : `${" ".repeat(width - status_width)}${themed_status}`;
-		lines.push(aligned_status);
-	}
-	const other_statuses = Array.from(footer_data.getExtensionStatuses().entries()).filter(([key]) => key !== "preset").sort(([a], [b]) => a.localeCompare(b)).map(([, text]) => sanitize_status_text(text));
-	if (other_statuses.length > 0) lines.push(truncateToWidth(other_statuses.join(" "), width, theme.fg("dim", "...")));
+	const combined_status_line = render_footer_status_line(theme, width, Array.from(footer_data.getExtensionStatuses().entries()).filter(([key]) => key !== "preset").sort(([a], [b]) => a.localeCompare(b)).map(([, text]) => sanitize_status_text(text)), prompt_status);
+	if (combined_status_line) lines.push(combined_status_line);
 	return lines;
 }
 function set_status(ctx, active_base_name, active_layers) {
@@ -3157,6 +3611,10 @@ async function prompt_presets(pi) {
 //#endregion
 //#region src/extensions/recall.ts
 const DEFAULT_DB_PATH = join(process.env.HOME, ".pi", "pirecall.db");
+function should_inject_recall_prompt(event) {
+	const selected_tools = event.systemPromptOptions?.selectedTools;
+	return !selected_tools || selected_tools.includes("bash");
+}
 function sync_recall_db_in_background() {
 	if (!existsSync(DEFAULT_DB_PATH)) return;
 	try {
@@ -3172,6 +3630,7 @@ async function recall(pi) {
 		sync_recall_db_in_background();
 	});
 	pi.on("before_agent_start", async (event) => {
+		if (!should_inject_recall_prompt(event)) return {};
 		return { systemPrompt: event.systemPrompt + `
 
 ## Session Recall
@@ -3310,7 +3769,7 @@ async function session_name(pi) {
 }
 //#endregion
 //#region src/skills/config.ts
-const DEFAULT_CONFIG$1 = {
+const DEFAULT_CONFIG$2 = {
 	version: 1,
 	enabled: {},
 	defaults: "all-disabled"
@@ -3320,7 +3779,7 @@ function get_config_path() {
 }
 function load_skills_config() {
 	const path = get_config_path();
-	if (!existsSync(path)) return { ...DEFAULT_CONFIG$1 };
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG$2 };
 	try {
 		const raw = readFileSync(path, "utf-8");
 		const parsed = JSON.parse(raw);
@@ -3330,7 +3789,7 @@ function load_skills_config() {
 			defaults: parsed.defaults ?? "all-enabled"
 		};
 	} catch {
-		return { ...DEFAULT_CONFIG$1 };
+		return { ...DEFAULT_CONFIG$2 };
 	}
 }
 function save_skills_config(config) {
@@ -4057,7 +4516,7 @@ async function skills(pi) {
 }
 //#endregion
 //#region src/extensions/telemetry-config.ts
-const DEFAULT_CONFIG = {
+const DEFAULT_CONFIG$1 = {
 	version: 1,
 	enabled: false
 };
@@ -4073,15 +4532,15 @@ function resolve_telemetry_db_path(cwd, override_path) {
 }
 function load_telemetry_config() {
 	const path = get_telemetry_config_path();
-	if (!existsSync(path)) return { ...DEFAULT_CONFIG };
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG$1 };
 	try {
 		const parsed = JSON.parse(readFileSync(path, "utf-8"));
 		return {
-			version: typeof parsed.version === "number" ? parsed.version : DEFAULT_CONFIG.version,
-			enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_CONFIG.enabled
+			version: typeof parsed.version === "number" ? parsed.version : DEFAULT_CONFIG$1.version,
+			enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_CONFIG$1.enabled
 		};
 	} catch {
-		return { ...DEFAULT_CONFIG };
+		return { ...DEFAULT_CONFIG$1 };
 	}
 }
 function save_telemetry_config(config) {
@@ -4240,6 +4699,10 @@ function infer_run_outcome(event) {
 		error_message: null
 	};
 }
+function describe_session_shutdown(event) {
+	const base = `session shutdown (${event.reason})`;
+	return event.targetSessionFile ? `${base} → ${event.targetSessionFile}` : base;
+}
 function format_telemetry_status(options) {
 	const override_label = options.override === void 0 ? "none" : options.override ? "--telemetry" : "--no-telemetry";
 	return [
@@ -4632,12 +5095,12 @@ function create_telemetry_extension(options = {}) {
 				headers_json: summarize_headers(event.headers)
 			});
 		});
-		pi.on("session_shutdown", async () => {
+		pi.on("session_shutdown", async (event) => {
 			if (store && active_run) store.finish_run({
 				id: active_run.id,
 				ended_at: now(),
 				success: null,
-				error_message: "session shutdown"
+				error_message: describe_session_shutdown(event)
 			});
 			close_store();
 			active_run = null;
@@ -4648,6 +5111,137 @@ function create_telemetry_extension(options = {}) {
 }
 create_telemetry_extension();
 //#endregion
+//#region src/extensions/working-indicator-config.ts
+const DEFAULT_CONFIG = {
+	version: 1,
+	mode: "spinner"
+};
+function get_working_indicator_config_path() {
+	return join(getAgentDir(), "working-indicator.json");
+}
+function load_working_indicator_config() {
+	const path = get_working_indicator_config_path();
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG };
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		return {
+			version: typeof parsed.version === "number" ? parsed.version : DEFAULT_CONFIG.version,
+			mode: is_working_indicator_mode(parsed.mode) ? parsed.mode : DEFAULT_CONFIG.mode
+		};
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}
+function save_working_indicator_config(config) {
+	const path = get_working_indicator_config_path();
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${path}.tmp-${Date.now()}`;
+	writeFileSync(tmp, JSON.stringify(config, null, "	") + "\n", { mode: 384 });
+	renameSync(tmp, path);
+}
+function is_working_indicator_mode(value) {
+	return value === "default" || value === "dot" || value === "none" || value === "pulse" || value === "spinner";
+}
+//#endregion
+//#region src/extensions/working-indicator.ts
+const COMMAND_MODES = [
+	"dot",
+	"none",
+	"pulse",
+	"spinner",
+	"reset"
+];
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+function get_working_indicator(ctx, mode) {
+	switch (mode) {
+		case "dot": return { frames: [ctx.ui.theme.fg("accent", "●")] };
+		case "none": return { frames: [] };
+		case "pulse": return {
+			frames: [
+				ctx.ui.theme.fg("dim", "·"),
+				ctx.ui.theme.fg("muted", "•"),
+				ctx.ui.theme.fg("accent", "●"),
+				ctx.ui.theme.fg("muted", "•")
+			],
+			intervalMs: 120
+		};
+		case "spinner": return {
+			frames: SPINNER_FRAMES.map((frame, index) => ctx.ui.theme.fg(index % 2 === 0 ? "accent" : "muted", frame)),
+			intervalMs: 80
+		};
+		case "default": return;
+	}
+}
+function describe_working_indicator_mode(mode) {
+	switch (mode) {
+		case "dot": return "static dot";
+		case "none": return "hidden";
+		case "pulse": return "pulse";
+		case "spinner": return "custom spinner";
+		case "default": return "pi default spinner";
+	}
+}
+function parse_working_indicator_mode(input) {
+	const normalized = input.trim().toLowerCase();
+	if (!normalized) return null;
+	if (normalized === "reset" || normalized === "default") return "default";
+	if (normalized === "dot" || normalized === "none" || normalized === "pulse" || normalized === "spinner") return normalized;
+	return null;
+}
+function apply_working_indicator(ctx, mode) {
+	ctx.ui.setWorkingIndicator(get_working_indicator(ctx, mode));
+}
+async function working_indicator(pi) {
+	let mode = load_working_indicator_config().mode;
+	pi.on("session_start", async (_event, ctx) => {
+		mode = load_working_indicator_config().mode;
+		apply_working_indicator(ctx, mode);
+	});
+	pi.registerCommand("working-indicator", {
+		description: "Set the streaming working indicator: dot, pulse, none, spinner, or reset",
+		getArgumentCompletions: (prefix) => {
+			const value = prefix.trim().toLowerCase();
+			return COMMAND_MODES.filter((entry) => entry.startsWith(value)).map((entry) => ({
+				value: entry,
+				label: entry
+			}));
+		},
+		handler: async (args, ctx) => {
+			const next = parse_working_indicator_mode(args);
+			if (next === null) {
+				if (!args.trim()) {
+					ctx.ui.notify(`Working indicator: ${describe_working_indicator_mode(mode)}`, "info");
+					return;
+				}
+				ctx.ui.notify("Usage: /working-indicator [dot|pulse|none|spinner|reset]", "error");
+				return;
+			}
+			mode = next;
+			save_working_indicator_config({
+				version: 1,
+				mode
+			});
+			apply_working_indicator(ctx, mode);
+			ctx.ui.notify(`Working indicator set to: ${describe_working_indicator_mode(mode)}`, "info");
+		}
+	});
+}
+//#endregion
 //#region src/api.ts
 const BUILTIN_EXTENSION_FACTORIES = {
 	mcp,
@@ -4658,7 +5252,10 @@ const BUILTIN_EXTENSION_FACTORIES = {
 	recall,
 	"prompt-presets": prompt_presets,
 	lsp: lsp_default,
-	"session-name": session_name
+	"session-name": session_name,
+	"confirm-destructive": confirm_destructive,
+	"hooks-resolution": hooks_resolution_default,
+	"working-indicator": working_indicator
 };
 const PACKAGE_THEME_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "themes");
 const PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
@@ -4676,6 +5273,9 @@ function get_force_disabled_builtins(options) {
 	if (!options.prompt_presets) force_disabled.add("prompt-presets");
 	if (!options.lsp) force_disabled.add("lsp");
 	if (!options.session_name) force_disabled.add("session-name");
+	if (!options.confirm_destructive) force_disabled.add("confirm-destructive");
+	if (!options.hooks_resolution) force_disabled.add("hooks-resolution");
+	if (!options.working_indicator) force_disabled.add("working-indicator");
 	return force_disabled;
 }
 function create_builtin_extension_factory(key, extension, force_disabled) {
@@ -4697,7 +5297,7 @@ function create_extensions_override(managed_inline_paths) {
 	};
 }
 async function create_my_pi(options = {}) {
-	const { cwd = process.cwd(), agent_dir, extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, lsp = true, session_name = true, telemetry, telemetry_db_path, model, system_prompt, append_system_prompt } = options;
+	const { cwd = process.cwd(), agent_dir, extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, lsp = true, session_name = true, confirm_destructive = true, hooks_resolution = true, working_indicator = true, telemetry, telemetry_db_path, model, system_prompt, append_system_prompt } = options;
 	const effective_agent_dir = resolve_agent_dir(cwd, agent_dir);
 	if (agent_dir) process.env[PI_AGENT_DIR_ENV] = effective_agent_dir;
 	const resolved_extensions = extensions.map((p) => resolve(cwd, p));
@@ -4710,7 +5310,10 @@ async function create_my_pi(options = {}) {
 		recall,
 		prompt_presets,
 		lsp,
-		session_name
+		session_name,
+		confirm_destructive,
+		hooks_resolution,
+		working_indicator
 	});
 	const managed_extension_factories = [
 		create_telemetry_extension({
@@ -4768,4 +5371,4 @@ async function create_my_pi(options = {}) {
 //#endregion
 export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
 
-//# sourceMappingURL=api-1ZXLxSgP.js.map
+//# sourceMappingURL=api-BVS4nqfD.js.map