my-pi 0.0.3 → 0.0.4

package/dist/api-B6KnhtN9.js

@@ -0,0 +1,1893 @@
+import { InteractiveMode as InteractiveMode$1, SessionManager, SettingsManager, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, defineTool, getAgentDir, parseFrontmatter, runPrintMode as runPrintMode$1 } from "@mariozechner/pi-coding-agent";
+import { cpSync, existsSync, globSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { execFileSync, spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { Container, SettingsList, Text } from "@mariozechner/pi-tui";
+import { createHash } from "node:crypto";
+//#region src/extensions/chain.ts
+function parse_chain_yaml(raw) {
+	const chains = [];
+	let current = null;
+	let current_step = null;
+	for (const line of raw.split("\n")) {
+		const chain_match = line.match(/^(\S[^:]*):$/);
+		if (chain_match) {
+			if (current && current_step) {
+				current.steps.push(current_step);
+				current_step = null;
+			}
+			current = {
+				name: chain_match[1].trim(),
+				description: "",
+				steps: []
+			};
+			chains.push(current);
+			continue;
+		}
+		const desc_match = line.match(/^\s+description:\s+(.+)$/);
+		if (desc_match && current && !current_step) {
+			let desc = desc_match[1].trim();
+			if (desc.startsWith("\"") && desc.endsWith("\"") || desc.startsWith("'") && desc.endsWith("'")) desc = desc.slice(1, -1);
+			current.description = desc;
+			continue;
+		}
+		if (line.match(/^\s+steps:\s*$/) && current) continue;
+		const agent_match = line.match(/^\s+-\s+agent:\s+(.+)$/);
+		if (agent_match && current) {
+			if (current_step) current.steps.push(current_step);
+			current_step = {
+				agent: agent_match[1].trim(),
+				prompt: ""
+			};
+			continue;
+		}
+		const prompt_match = line.match(/^\s+prompt:\s+(.+)$/);
+		if (prompt_match && current_step) {
+			let prompt = prompt_match[1].trim();
+			if (prompt.startsWith("\"") && prompt.endsWith("\"") || prompt.startsWith("'") && prompt.endsWith("'")) prompt = prompt.slice(1, -1);
+			prompt = prompt.replace(/\\n/g, "\n");
+			current_step.prompt = prompt;
+			continue;
+		}
+	}
+	if (current && current_step) current.steps.push(current_step);
+	return chains;
+}
+function parse_agent_file(filePath) {
+	try {
+		const { frontmatter, body } = parseFrontmatter(readFileSync(filePath, "utf-8"));
+		if (!frontmatter?.name) return null;
+		return {
+			name: frontmatter.name,
+			description: frontmatter.description || "",
+			tools: frontmatter.tools || "read,grep,find,ls",
+			systemPrompt: body.trim()
+		};
+	} catch {
+		return null;
+	}
+}
+function scan_agent_dirs(cwd) {
+	const dirs = [
+		join(cwd, "agents"),
+		join(cwd, ".claude", "agents"),
+		join(cwd, ".pi", "agents")
+	];
+	const agents = /* @__PURE__ */ new Map();
+	for (const dir of dirs) {
+		if (!existsSync(dir)) continue;
+		try {
+			for (const file of readdirSync(dir)) {
+				if (!file.endsWith(".md")) continue;
+				const def = parse_agent_file(resolve(dir, file));
+				if (def && !agents.has(def.name.toLowerCase())) agents.set(def.name.toLowerCase(), def);
+			}
+		} catch {}
+	}
+	return agents;
+}
+function run_agent_step(agent_def, task) {
+	const bin = process.argv[1];
+	const args = [
+		"--no-builtin",
+		"-P",
+		task
+	];
+	const chunks = [];
+	return new Promise((res) => {
+		const proc = spawn(process.execPath, [bin, ...args], {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				MY_PI_AGENT_SYSTEM_PROMPT: agent_def.systemPrompt
+			}
+		});
+		proc.stdout.setEncoding("utf-8");
+		proc.stdout.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		proc.stderr.setEncoding("utf-8");
+		proc.stderr.on("data", () => {});
+		proc.on("close", (code) => {
+			res({
+				output: chunks.join("").trim(),
+				exitCode: code ?? 1
+			});
+		});
+		proc.on("error", (err) => {
+			res({
+				output: `Error spawning agent: ${err.message}`,
+				exitCode: 1
+			});
+		});
+	});
+}
+async function chain(pi) {
+	const cwd = process.cwd();
+	const agents = scan_agent_dirs(cwd);
+	let chains = [];
+	let active_chain = null;
+	const chain_paths = [
+		join(cwd, ".pi", "agents", "agent-chain.yaml"),
+		join(cwd, ".pi", "agents", "chains.yaml"),
+		join(cwd, ".claude", "agents", "chains.yaml")
+	];
+	for (const path of chain_paths) if (existsSync(path)) try {
+		chains = parse_chain_yaml(readFileSync(path, "utf-8"));
+		break;
+	} catch {}
+	if (chains.length > 0) active_chain = chains[0];
+	pi.registerTool(defineTool({
+		name: "run_chain",
+		label: "Run Chain",
+		description: "Execute the active agent chain pipeline. Each step runs sequentially — output from one step feeds into the next as $INPUT. $ORIGINAL is always the user's initial prompt.",
+		parameters: Type.Object({ task: Type.String({ description: "The task/prompt for the chain to process" }) }),
+		execute: async (_id, params) => {
+			const { task } = params;
+			if (!active_chain) return {
+				content: [{
+					type: "text",
+					text: "No chain active. Use /chain to select one."
+				}],
+				details: {
+					chain: "",
+					steps: 0
+				}
+			};
+			let input = task;
+			const original = task;
+			const results = [];
+			for (let i = 0; i < active_chain.steps.length; i++) {
+				const step = active_chain.steps[i];
+				const agent_def = agents.get(step.agent.toLowerCase());
+				if (!agent_def) {
+					const msg = `Step ${i + 1}: agent "${step.agent}" not found. Available: ${Array.from(agents.keys()).join(", ")}`;
+					results.push(msg);
+					return {
+						content: [{
+							type: "text",
+							text: msg
+						}],
+						details: {
+							chain: active_chain.name,
+							steps: i
+						}
+					};
+				}
+				const result = await run_agent_step(agent_def, step.prompt.replace(/\$INPUT/g, input).replace(/\$ORIGINAL/g, original));
+				if (result.exitCode !== 0) {
+					const msg = `Step ${i + 1} (${step.agent}) failed:\n${result.output}`;
+					results.push(msg);
+					return {
+						content: [{
+							type: "text",
+							text: msg
+						}],
+						details: {
+							chain: active_chain.name,
+							steps: i + 1
+						}
+					};
+				}
+				results.push(`## Step ${i + 1}: ${step.agent}\n${result.output}`);
+				input = result.output;
+			}
+			return {
+				content: [{
+					type: "text",
+					text: results.join("\n\n---\n\n")
+				}],
+				details: {
+					chain: active_chain.name,
+					steps: active_chain.steps.length
+				}
+			};
+		}
+	}));
+	pi.registerCommand("chain", {
+		description: "Switch active chain or list chains (chain list)",
+		getArgumentCompletions: (prefix) => {
+			const parts = prefix.trim().split(/\s+/);
+			if (parts.length <= 1) return ["list", ...chains.map((c) => c.name)].filter((s) => s.startsWith(parts[0] || "")).map((s) => ({
+				value: s,
+				label: s
+			}));
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const sub = args.trim();
+			if (!sub || sub === "list") {
+				if (chains.length === 0) {
+					ctx.ui.notify("No chains found. Add chains to .pi/agents/agent-chain.yaml", "warning");
+					return;
+				}
+				const lines = chains.map((c) => {
+					const active = c.name === active_chain?.name ? " *" : "";
+					const steps = c.steps.map((s) => s.agent).join(" -> ");
+					return `${c.name}${active}: ${c.description || steps}`;
+				});
+				ctx.ui.notify(lines.join("\n"));
+				return;
+			}
+			const found_chain = chains.find((c) => c.name.toLowerCase() === sub.toLowerCase());
+			if (!found_chain) {
+				ctx.ui.notify(`Unknown chain: ${sub}. Use /chain list.`, "warning");
+				return;
+			}
+			active_chain = found_chain;
+			const flow = found_chain.steps.map((s) => s.agent).join(" -> ");
+			ctx.ui.notify(`Active chain: ${found_chain.name} (${flow})`);
+		}
+	});
+	pi.on("before_agent_start", async (event) => {
+		if (!active_chain || chains.length === 0) 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";
+			return `${i + 1}. **${s.agent}** — ${desc}`;
+		}).join("\n");
+		const chain_list = chains.map((c) => {
+			const active = c.name === active_chain?.name ? " (active)" : "";
+			return `- ${c.name}${active}: ${c.description}`;
+		}).join("\n");
+		return { systemPrompt: event.systemPrompt + `
+
+## Agent Chains
+
+You have a run_chain tool that executes sequential agent pipelines.
+
+### Active Chain: ${active_chain.name}
+${active_chain.description}
+Flow: ${flow}
+
+${step_list}
+
+### Available Chains
+${chain_list}
+
+### When to use run_chain
+- Non-trivial work: features, refactors, multi-file changes
+- Tasks that benefit from planning then building then reviewing
+- When structured multi-agent collaboration helps
+
+### When to work directly
+- Simple reads, quick lookups, small edits
+- Answering questions about the codebase
+- Anything you can handle in one step
+
+Switch chains with /chain <name>.` };
+	});
+	pi.registerCommand("agents", {
+		description: "List discovered agent definitions",
+		handler: async (_args, ctx) => {
+			if (agents.size === 0) {
+				ctx.ui.notify("No agents found in agents/, .pi/agents/, or .claude/agents/", "warning");
+				return;
+			}
+			const lines = Array.from(agents.values()).map((a) => `${a.name}: ${a.description || "(no description)"} [${a.tools}]`);
+			ctx.ui.notify(lines.join("\n"));
+		}
+	});
+}
+//#endregion
+//#region src/extensions/config.ts
+const DEFAULT_CONFIG$1 = {
+	version: 1,
+	enabled: {}
+};
+const BUILTIN_EXTENSIONS = [
+	{
+		key: "mcp",
+		label: "MCP",
+		description: "MCP server integration and /mcp command",
+		cli_flag: "--no-mcp",
+		aliases: ["mcp"]
+	},
+	{
+		key: "skills",
+		label: "Skills",
+		description: "Managed pi-native skills and /skills command",
+		cli_flag: "--no-skills",
+		aliases: ["skills", "skill"]
+	},
+	{
+		key: "chain",
+		label: "Chain",
+		description: "Agent chain orchestration and /chain command",
+		cli_flag: "--no-chain",
+		aliases: ["chain", "chains"]
+	},
+	{
+		key: "filter-output",
+		label: "Filter output",
+		description: "Secret redaction for tool output",
+		cli_flag: "--no-filter",
+		aliases: [
+			"filter-output",
+			"filter_output",
+			"filter",
+			"redaction"
+		]
+	},
+	{
+		key: "handoff",
+		label: "Handoff",
+		description: "Session handoff export and /handoff command",
+		cli_flag: "--no-handoff",
+		aliases: ["handoff"]
+	},
+	{
+		key: "recall",
+		label: "Recall",
+		description: "Past session recall guidance and /recall command",
+		cli_flag: "--no-recall",
+		aliases: ["recall"]
+	}
+];
+function get_builtin_extensions_config_path() {
+	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "my-pi", "extensions.json");
+}
+function load_builtin_extensions_config() {
+	const path = get_builtin_extensions_config_path();
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG$1 };
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		const enabled = {};
+		for (const extension of BUILTIN_EXTENSIONS) {
+			const value = parsed.enabled?.[extension.key];
+			if (typeof value === "boolean") enabled[extension.key] = value;
+		}
+		return {
+			version: parsed.version ?? 1,
+			enabled
+		};
+	} catch {
+		return { ...DEFAULT_CONFIG$1 };
+	}
+}
+function save_builtin_extensions_config(config) {
+	const path = get_builtin_extensions_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_builtin_extension_enabled(config, key) {
+	return config.enabled[key] ?? true;
+}
+function is_builtin_extension_active(config, key, force_disabled = /* @__PURE__ */ new Set()) {
+	return is_builtin_extension_enabled(config, key) && !force_disabled.has(key);
+}
+function resolve_builtin_extension_states(force_disabled = /* @__PURE__ */ new Set(), config = load_builtin_extensions_config()) {
+	return BUILTIN_EXTENSIONS.map((extension) => {
+		const saved_enabled = is_builtin_extension_enabled(config, extension.key);
+		const forced = force_disabled.has(extension.key);
+		return {
+			...extension,
+			saved_enabled,
+			effective_enabled: saved_enabled && !forced,
+			forced_disabled: forced
+		};
+	});
+}
+function find_builtin_extension(query) {
+	const normalized = query.trim().toLowerCase();
+	if (!normalized) return void 0;
+	return BUILTIN_EXTENSIONS.find((extension) => [
+		extension.key,
+		extension.label,
+		...extension.aliases
+	].some((value) => value.toLowerCase() === normalized));
+}
+//#endregion
+//#region src/extensions/extensions.ts
+const ENABLED$1 = "[x]";
+const DISABLED$1 = "[ ]";
+function to_force_disabled_set(force_disabled) {
+	return new Set(force_disabled ?? []);
+}
+function format_effective_state(state) {
+	if (state.effective_enabled) return "enabled";
+	if (state.forced_disabled) return `disabled in this process by ${state.cli_flag}`;
+	return "disabled";
+}
+function format_extension_lines(states, options) {
+	const lines = [];
+	if (options?.heading) lines.push(options.heading, "");
+	const enabled_now = states.filter((state) => state.effective_enabled).length;
+	const disabled_now = states.length - enabled_now;
+	lines.push(`${states.length} built-in extensions (${enabled_now} enabled now, ${disabled_now} disabled now)`, "");
+	for (const state of states) {
+		lines.push(`${state.saved_enabled ? ENABLED$1 : DISABLED$1} ${state.label}`);
+		lines.push(`    key: ${state.key}`);
+		lines.push(`    saved config: ${state.saved_enabled ? "enabled" : "disabled"}`);
+		lines.push(`    current process: ${format_effective_state(state)}`);
+		lines.push(`    ${state.description}`);
+	}
+	return lines.join("\n");
+}
+function to_setting_item$1(state) {
+	const detail_lines = [
+		state.key,
+		state.description,
+		`current process: ${format_effective_state(state)}`,
+		`startup override: ${state.cli_flag}`
+	];
+	return {
+		id: state.key,
+		label: state.label,
+		description: detail_lines.join("\n"),
+		currentValue: state.saved_enabled ? ENABLED$1 : DISABLED$1,
+		values: [ENABLED$1, DISABLED$1]
+	};
+}
+function sets_equal$1(a, b) {
+	if (a.size !== b.size) return false;
+	for (const value of a) if (!b.has(value)) return false;
+	return true;
+}
+function search_states(states, query) {
+	const normalized = query.trim().toLowerCase();
+	if (!normalized) return states;
+	return states.filter((state) => [
+		state.key,
+		state.label,
+		state.description,
+		...state.aliases
+	].some((value) => value.toLowerCase().includes(normalized)));
+}
+function save_extension_enabled(key, enabled) {
+	const config = load_builtin_extensions_config();
+	config.enabled[key] = enabled;
+	save_builtin_extensions_config(config);
+}
+function create_extensions_extension(options = {}) {
+	const force_disabled = to_force_disabled_set(options.force_disabled);
+	return async function extensions(pi) {
+		const subs = [
+			"list",
+			"enable",
+			"disable",
+			"toggle",
+			"search"
+		];
+		pi.registerCommand("extensions", {
+			description: "Manage built-in my-pi extensions",
+			getArgumentCompletions: (prefix) => {
+				const parts = prefix.trim().split(/\s+/);
+				if (parts.length <= 1) return subs.filter((sub) => sub.startsWith(parts[0] || "")).map((sub) => ({
+					value: sub,
+					label: sub
+				}));
+				if ([
+					"enable",
+					"disable",
+					"toggle"
+				].includes(parts[0])) {
+					const q = parts.slice(1).join(" ").toLowerCase();
+					return resolve_builtin_extension_states(force_disabled).filter((state) => state.key.toLowerCase().includes(q) || state.label.toLowerCase().includes(q)).slice(0, 20).map((state) => ({
+						value: `${parts[0]} ${state.key}`,
+						label: `${state.key} ${state.saved_enabled ? ENABLED$1 : DISABLED$1}`
+					}));
+				}
+				return null;
+			},
+			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$1 ? "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$1;
+							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$1(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;
+				}
+				const [sub, ...rest] = (trimmed || "list").split(/\s+/);
+				const arg = rest.join(" ");
+				const states = resolve_builtin_extension_states(force_disabled);
+				switch (sub) {
+					case "list":
+						ctx.ui.notify(format_extension_lines(states, { heading: "Built-in extensions" }));
+						break;
+					case "enable":
+					case "disable":
+					case "toggle": {
+						if (!arg) {
+							ctx.ui.notify(`Usage: /extensions ${sub} <key>`, "warning");
+							return;
+						}
+						const extension = find_builtin_extension(arg);
+						if (!extension) {
+							ctx.ui.notify(`Unknown extension: ${arg}. Use: ${BUILTIN_EXTENSIONS.map((item) => item.key).join(", ")}`, "warning");
+							return;
+						}
+						const current_state = states.find((state) => state.key === extension.key);
+						const next_enabled = sub === "enable" ? true : sub === "disable" ? false : !current_state?.saved_enabled;
+						save_extension_enabled(extension.key, next_enabled);
+						ctx.ui.notify(next_enabled && force_disabled.has(extension.key) ? `Enabled ${extension.key} in saved config. Still disabled in this process by ${extension.cli_flag}. /reload or restart without that flag to apply.` : `${extension.key} ${next_enabled ? "enabled" : "disabled"}. /reload to apply.`);
+						break;
+					}
+					case "search": {
+						if (!arg) {
+							ctx.ui.notify("Usage: /extensions search <query>", "warning");
+							return;
+						}
+						const results = search_states(states, arg);
+						if (results.length === 0) {
+							ctx.ui.notify(`No built-in extensions matching "${arg}"`);
+							return;
+						}
+						ctx.ui.notify(format_extension_lines(results, { heading: `Built-in extensions matching "${arg}"` }));
+						break;
+					}
+					default: ctx.ui.notify(`Unknown: ${sub}. Use: ${subs.join(", ")}`, "warning");
+				}
+			}
+		});
+	};
+}
+create_extensions_extension();
+//#endregion
+//#region src/extensions/filter-output.ts
+const SECRET_PATTERNS = [
+	{
+		name: "AWS Access Key",
+		pattern: /AKIA[A-Z0-9]{16}/g
+	},
+	{
+		name: "AWS Secret Key",
+		pattern: /(?:SecretAccessKey|aws_secret_access_key)\s*[:=]\s*[A-Za-z0-9/+=]{40}/g
+	},
+	{
+		name: "Bearer Token",
+		pattern: /Bearer\s+[a-zA-Z0-9._-]{20,}/g
+	},
+	{
+		name: "OpenAI/Anthropic API Key",
+		pattern: /sk-[a-zA-Z0-9._-]{20,}/g
+	},
+	{
+		name: "Stripe Live Key",
+		pattern: /sk_live_[a-zA-Z0-9]{20,}/g
+	},
+	{
+		name: "Stripe Test Key",
+		pattern: /sk_test_[a-zA-Z0-9]{20,}/g
+	},
+	{
+		name: "Hetzner Token",
+		pattern: /(?:HCLOUD_TOKEN|hcloud_token|token)\s*[:=]\s*["']?[a-f0-9]{64}\b/g
+	},
+	{
+		name: "Private Key",
+		pattern: /-----BEGIN\s+[\w\s]*PRIVATE\s+KEY-----/g
+	},
+	{
+		name: "Connection String with Password",
+		pattern: /:\/\/[^:]+:[^@]+@/g
+	},
+	{
+		name: "Generic Password Field",
+		pattern: /(?:password|passwd|secret|token)\s*[:=]\s*["']?[^\s"']{8,}/gi
+	},
+	{
+		name: "Tavily API Key",
+		pattern: /tvly-[a-zA-Z0-9_-]{20,}/g
+	},
+	{
+		name: "Kagi API Key",
+		pattern: /[a-zA-Z0-9_-]{40,}\.[a-zA-Z0-9_-]{40,}/g
+	},
+	{
+		name: "Brave API Key",
+		pattern: /BSA[A-Z0-9]{20,}/g
+	},
+	{
+		name: "Firecrawl API Key",
+		pattern: /fc-[a-f0-9]{32}/g
+	},
+	{
+		name: "GitHub Token",
+		pattern: /gh[pousr]_[a-zA-Z0-9]{36,}/g
+	}
+];
+function redact(text) {
+	let count = 0;
+	let result = text;
+	for (const sp of SECRET_PATTERNS) {
+		sp.pattern.lastIndex = 0;
+		result = result.replace(sp.pattern, (match) => {
+			count++;
+			return `${match.slice(0, 4)}${"*".repeat(Math.min(match.length - 4, 20))}[REDACTED:${sp.name}]`;
+		});
+	}
+	return {
+		redacted: result,
+		count
+	};
+}
+async function filter_output(pi) {
+	let totalRedacted = 0;
+	pi.on("tool_result", async (event) => {
+		if (!event.content) return;
+		let modified = false;
+		const newContent = event.content.map((item) => {
+			if (item.type !== "text" || !item.text) return item;
+			const { redacted, count } = redact(item.text);
+			if (count > 0) {
+				modified = true;
+				totalRedacted += count;
+			}
+			return {
+				...item,
+				text: redacted
+			};
+		});
+		if (modified) return { content: newContent };
+	});
+	pi.registerCommand("redact-stats", {
+		description: "Show how many secrets have been redacted",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(`Secrets redacted this session: ${totalRedacted}`);
+		}
+	});
+}
+//#endregion
+//#region src/extensions/handoff.ts
+async function handoff(pi) {
+	const history = [];
+	pi.on("message_end", async (event) => {
+		const msg = event.message;
+		if (!msg) return;
+		const content = msg.content;
+		if (!Array.isArray(content)) return;
+		const text = content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+		if (!text) return;
+		const summary = text.length > 200 ? text.slice(0, 200) + "..." : text;
+		history.push({
+			role: msg.role || "unknown",
+			summary,
+			timestamp: Date.now()
+		});
+	});
+	pi.registerCommand("handoff", {
+		description: "Export session context as a handoff prompt for a new session",
+		handler: async (args, ctx) => {
+			const task = args.trim();
+			if (history.length === 0) {
+				ctx.ui.notify("No conversation history to hand off", "warning");
+				return;
+			}
+			const handoff = `## Handoff from Previous Session
+
+### Context
+The previous session covered the following:
+
+${history.map((h) => `[${h.role}] ${h.summary}`).join("\n\n")}
+
+### Task
+${task || "Continue from where the previous session left off."}
+
+### Instructions
+- Review the context above to understand what was done
+- Do NOT repeat work that was already completed
+- Focus on the task described above
+`;
+			const filename = `handoff-${Date.now()}.md`;
+			writeFileSync(join(ctx.cwd, filename), handoff, "utf-8");
+			ctx.ui.notify(`Handoff written to ${filename}\n\nUse: my-pi < ${filename}`);
+		}
+	});
+}
+//#endregion
+//#region src/mcp/client.ts
+var McpClient = class {
+	#proc = null;
+	#config;
+	#nextId = 1;
+	#pending = /* @__PURE__ */ new Map();
+	#buffer = "";
+	constructor(config) {
+		this.#config = config;
+	}
+	async connect() {
+		const { command, args = [], env } = this.#config;
+		this.#proc = spawn(command, args, {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				...env
+			}
+		});
+		this.#proc.stdout.setEncoding("utf8");
+		this.#proc.stdout.on("data", (chunk) => {
+			this.#buffer += chunk;
+			const lines = this.#buffer.split("\n");
+			this.#buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const msg = JSON.parse(line);
+					if (msg.id != null && this.#pending.has(msg.id)) {
+						const p = this.#pending.get(msg.id);
+						this.#pending.delete(msg.id);
+						if (msg.error) p.reject(/* @__PURE__ */ new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+						else p.resolve(msg.result);
+					}
+				} catch {}
+			}
+		});
+		await this.#request("initialize", {
+			protocolVersion: "2024-11-05",
+			capabilities: {},
+			clientInfo: {
+				name: "my-pi",
+				version: "0.0.1"
+			}
+		});
+		this.#send({
+			jsonrpc: "2.0",
+			method: "notifications/initialized"
+		});
+	}
+	async listTools() {
+		return (await this.#request("tools/list", {})).tools;
+	}
+	async callTool(name, args) {
+		return this.#request("tools/call", {
+			name,
+			arguments: args
+		});
+	}
+	async disconnect() {
+		if (this.#proc) {
+			this.#proc.kill();
+			this.#proc = null;
+		}
+		this.#pending.clear();
+	}
+	#request(method, params) {
+		return new Promise((resolve, reject) => {
+			const id = this.#nextId++;
+			this.#pending.set(id, {
+				resolve,
+				reject
+			});
+			this.#send({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			});
+			setTimeout(() => {
+				if (this.#pending.has(id)) {
+					this.#pending.delete(id);
+					reject(/* @__PURE__ */ new Error(`MCP request ${method} timed out`));
+				}
+			}, 3e4);
+		});
+	}
+	#send(msg) {
+		if (!this.#proc?.stdin?.writable) throw new Error("MCP server not connected");
+		this.#proc.stdin.write(JSON.stringify(msg) + "\n");
+	}
+};
+//#endregion
+//#region src/mcp/config.ts
+function read_config(path) {
+	if (!existsSync(path)) return {};
+	const raw = readFileSync(path, "utf-8");
+	return JSON.parse(raw).mcpServers || {};
+}
+function load_mcp_config(cwd) {
+	const global_servers = read_config(join(homedir(), ".pi", "agent", "mcp.json"));
+	const project_servers = read_config(join(cwd, "mcp.json"));
+	const merged = {
+		...global_servers,
+		...project_servers
+	};
+	return Object.entries(merged).map(([name, server]) => ({
+		name,
+		command: server.command,
+		args: server.args,
+		env: server.env
+	}));
+}
+//#endregion
+//#region src/extensions/mcp.ts
+async function mcp(pi) {
+	const cwd = process.cwd();
+	const servers = /* @__PURE__ */ new Map();
+	const configs = load_mcp_config(cwd);
+	const results = await Promise.allSettled(configs.map(async (config) => {
+		const client = new McpClient(config);
+		await client.connect();
+		return {
+			config,
+			client,
+			mcp_tools: await client.listTools()
+		};
+	}));
+	for (const result of results) {
+		if (result.status === "rejected") {
+			console.error(`MCP server failed: ${result.reason}`);
+			continue;
+		}
+		const { config, client, mcp_tools } = result.value;
+		const tool_names = [];
+		for (const mcp_tool of mcp_tools) {
+			const tool_name = `mcp__${config.name}__${mcp_tool.name}`;
+			tool_names.push(tool_name);
+			pi.registerTool(defineTool({
+				name: tool_name,
+				label: `${config.name}: ${mcp_tool.name}`,
+				description: mcp_tool.description || mcp_tool.name,
+				parameters: mcp_tool.inputSchema || {
+					type: "object",
+					properties: {}
+				},
+				execute: async (_id, params) => {
+					const result = await client.callTool(mcp_tool.name, params);
+					return {
+						content: [{
+							type: "text",
+							text: result?.content?.map((c) => c.text || "").join("\n") || JSON.stringify(result)
+						}],
+						details: {}
+					};
+				}
+			}));
+		}
+		servers.set(config.name, {
+			config,
+			client,
+			tool_names,
+			enabled: true
+		});
+	}
+	pi.registerCommand("mcp", {
+		description: "Manage MCP servers (list, enable, disable)",
+		getArgumentCompletions: (prefix) => {
+			const parts = prefix.split(" ");
+			if (parts.length <= 1) return [
+				"list",
+				"enable",
+				"disable"
+			].filter((s) => s.startsWith(prefix)).map((s) => ({
+				value: s,
+				label: s
+			}));
+			if (parts[0] === "enable" || parts[0] === "disable") {
+				const name_prefix = parts[1] || "";
+				return Array.from(servers.keys()).filter((n) => n.startsWith(name_prefix)).map((n) => ({
+					value: `${parts[0]} ${n}`,
+					label: n
+				}));
+			}
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const [sub, ...rest] = args.trim().split(/\s+/);
+			const name = rest.join(" ");
+			switch (sub || "list") {
+				case "list": {
+					if (servers.size === 0) {
+						ctx.ui.notify("No MCP servers configured");
+						return;
+					}
+					const lines = [];
+					for (const [sname, state] of servers.entries()) {
+						const status = state.enabled ? "enabled" : "disabled";
+						lines.push(`${sname} (${status}) — ${state.tool_names.length} tools`);
+					}
+					ctx.ui.notify(lines.join("\n"));
+					break;
+				}
+				case "enable": {
+					const server = servers.get(name);
+					if (!server) {
+						ctx.ui.notify(`Unknown server: ${name}`, "warning");
+						return;
+					}
+					if (server.enabled) {
+						ctx.ui.notify(`${name} already enabled`);
+						return;
+					}
+					server.enabled = true;
+					const active = pi.getActiveTools();
+					pi.setActiveTools([...active, ...server.tool_names]);
+					ctx.ui.notify(`Enabled ${name}`);
+					break;
+				}
+				case "disable": {
+					const server = servers.get(name);
+					if (!server) {
+						ctx.ui.notify(`Unknown server: ${name}`, "warning");
+						return;
+					}
+					if (!server.enabled) {
+						ctx.ui.notify(`${name} already disabled`);
+						return;
+					}
+					server.enabled = false;
+					const tool_set = new Set(server.tool_names);
+					pi.setActiveTools(pi.getActiveTools().filter((t) => !tool_set.has(t)));
+					ctx.ui.notify(`Disabled ${name}`);
+					break;
+				}
+				default: ctx.ui.notify(`Unknown subcommand: ${sub}. Use list, enable, or disable.`, "warning");
+			}
+		}
+	});
+	pi.on("session_shutdown", async () => {
+		for (const server of servers.values()) await server.client.disconnect();
+	});
+}
+//#endregion
+//#region src/extensions/recall.ts
+const DEFAULT_DB_PATH = join(process.env.HOME, ".pi", "pirecall.db");
+async function recall(pi) {
+	if (existsSync(DEFAULT_DB_PATH)) try {
+		execFileSync("npx", [
+			"pirecall",
+			"sync",
+			"--json"
+		], {
+			encoding: "utf-8",
+			timeout: 3e4,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch {}
+	pi.on("before_agent_start", async (event) => {
+		return { systemPrompt: event.systemPrompt + `
+
+## Session Recall
+
+You have access to past Pi session history via \`npx pirecall\`. Use it when:
+- The user references prior work ("what did we do", "last time", "remember when")
+- You need context from a previous session about this project
+- You want to avoid repeating work already done
+
+Quick reference:
+- \`npx pirecall recall "<query>" --json\` — LLM-optimised context retrieval with surrounding messages
+- \`npx pirecall search "<query>" --json\` — full-text search (supports FTS5: AND, OR, NOT, "phrase", prefix*)
+- \`npx pirecall search "<query>" --json --project my-pi\` — filter by project
+- \`npx pirecall search "<query>" --json --after 2026-04-10\` — filter by date
+- \`npx pirecall sessions --json\` — list recent sessions
+- \`npx pirecall stats --json\` — database statistics
+
+Always pass \`--json\` for structured output.` };
+	});
+}
+//#endregion
+//#region src/skills/config.ts
+const DEFAULT_CONFIG = {
+	version: 1,
+	enabled: {},
+	defaults: "all-disabled"
+};
+function get_config_path() {
+	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "my-pi", "skills.json");
+}
+function load_skills_config() {
+	const path = get_config_path();
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG };
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		return {
+			version: parsed.version ?? 1,
+			enabled: parsed.enabled ?? {},
+			defaults: parsed.defaults ?? "all-enabled"
+		};
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}
+function save_skills_config(config) {
+	const path = get_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 make_skill_key(name, source) {
+	return `${name}@${source}`;
+}
+function is_skill_enabled(config, key) {
+	if (key in config.enabled) return config.enabled[key];
+	return config.defaults === "all-enabled";
+}
+//#endregion
+//#region src/skills/scanner.ts
+const IMPORT_METADATA_FILE = ".my-pi-source.json";
+function read_installed_plugins() {
+	const path = join(homedir(), ".claude", "plugins", "installed_plugins.json");
+	if (!existsSync(path)) return null;
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function parse_skill_md(skill_path) {
+	try {
+		const { frontmatter } = parseFrontmatter(readFileSync(skill_path, "utf-8"));
+		const description = frontmatter?.description;
+		if (!description) return null;
+		return {
+			name: frontmatter?.name || basename(dirname(skill_path)),
+			description: description.trim()
+		};
+	} catch {
+		return null;
+	}
+}
+function read_import_metadata(base_dir) {
+	const metadata_path = join(base_dir, IMPORT_METADATA_FILE);
+	if (!existsSync(metadata_path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(metadata_path, "utf-8"));
+	} catch {
+		return;
+	}
+}
+function scan_dir_for_skills(dir, options) {
+	if (!existsSync(dir)) return [];
+	const results = [];
+	const direct = join(dir, "SKILL.md");
+	if ((options.include_direct_root_skill ?? true) && existsSync(direct)) {
+		const parsed = parse_skill_md(direct);
+		if (parsed) results.push({
+			...parsed,
+			skillPath: direct,
+			baseDir: dir,
+			source: options.source,
+			kind: options.kind,
+			plugin: options.plugin,
+			import_meta: options.kind === "managed" ? read_import_metadata(dir) : void 0
+		});
+		return results;
+	}
+	try {
+		const matches = globSync("*/SKILL.md", { cwd: dir });
+		for (const match of matches) {
+			const full_path = resolve(dir, match);
+			const parsed = parse_skill_md(full_path);
+			if (parsed) {
+				const base_dir = dirname(full_path);
+				results.push({
+					...parsed,
+					skillPath: full_path,
+					baseDir: base_dir,
+					source: options.source,
+					kind: options.kind,
+					plugin: options.plugin,
+					import_meta: options.kind === "managed" ? read_import_metadata(base_dir) : void 0
+				});
+			}
+		}
+	} catch {}
+	return results;
+}
+function dedupe_by_skill_path(skills) {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const skill of skills) {
+		if (seen.has(skill.skillPath)) continue;
+		seen.add(skill.skillPath);
+		deduped.push(skill);
+	}
+	return deduped;
+}
+function scan_managed_skills() {
+	const skills = [];
+	for (const skill of scan_dir_for_skills(join(homedir(), ".claude", "skills"), {
+		source: "user-local",
+		kind: "managed"
+	})) skills.push(skill);
+	for (const skill of scan_dir_for_skills(join(homedir(), ".pi", "agent", "skills"), {
+		source: "pi-native",
+		kind: "managed",
+		include_direct_root_skill: false
+	})) skills.push(skill);
+	return dedupe_by_skill_path(skills);
+}
+function scan_importable_skills() {
+	const skills = [];
+	const plugins = read_installed_plugins();
+	if (!plugins?.plugins) return skills;
+	for (const [plugin_id, entries] of Object.entries(plugins.plugins)) {
+		const entry = entries[0];
+		if (!entry?.installPath || !existsSync(entry.installPath)) continue;
+		const source = `plugin:${plugin_id}`;
+		const plugin = {
+			pluginId: plugin_id,
+			installPath: entry.installPath,
+			version: entry.version,
+			gitCommitSha: entry.gitCommitSha
+		};
+		for (const skill of scan_dir_for_skills(join(entry.installPath, "skills"), {
+			source,
+			kind: "external",
+			plugin
+		})) skills.push(skill);
+		for (const skill of scan_dir_for_skills(join(entry.installPath, ".pi", "skills"), {
+			source,
+			kind: "external",
+			plugin
+		})) skills.push(skill);
+		const direct_root_skill = join(entry.installPath, "SKILL.md");
+		if (existsSync(direct_root_skill)) {
+			const parsed = parse_skill_md(direct_root_skill);
+			if (parsed) skills.push({
+				...parsed,
+				skillPath: direct_root_skill,
+				baseDir: entry.installPath,
+				source,
+				kind: "external",
+				plugin
+			});
+		}
+	}
+	return dedupe_by_skill_path(skills);
+}
+//#endregion
+//#region src/skills/importer.ts
+const IMPORT_METADATA_VERSION = 1;
+function get_managed_skills_dir() {
+	return join(homedir(), ".pi", "agent", "skills");
+}
+function ensure_dir(path) {
+	mkdirSync(path, {
+		recursive: true,
+		mode: 448
+	});
+}
+function list_files_recursively(dir) {
+	const files = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const full_path = join(dir, entry.name);
+		if (entry.name === ".my-pi-source.json") continue;
+		if (entry.isDirectory()) {
+			files.push(...list_files_recursively(full_path));
+			continue;
+		}
+		if (entry.isFile()) files.push(full_path);
+	}
+	return files.sort((a, b) => a.localeCompare(b));
+}
+function hash_directory(dir) {
+	const hash = createHash("sha256");
+	for (const file of list_files_recursively(dir)) {
+		hash.update(relative(dir, file));
+		hash.update("\0");
+		hash.update(readFileSync(file));
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+function read_metadata(base_dir) {
+	const path = join(base_dir, IMPORT_METADATA_FILE);
+	if (!existsSync(path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return;
+	}
+}
+function write_metadata(base_dir, metadata) {
+	writeFileSync(join(base_dir, IMPORT_METADATA_FILE), JSON.stringify(metadata, null, "	") + "\n", { mode: 384 });
+}
+function replace_directory(source_dir, dest_dir) {
+	const parent_dir = dirname(dest_dir);
+	ensure_dir(parent_dir);
+	const tmp_dir = join(parent_dir, `.${resolve(dest_dir).split("/").pop()}.tmp-${Date.now()}`);
+	rmSync(tmp_dir, {
+		recursive: true,
+		force: true
+	});
+	cpSync(source_dir, tmp_dir, {
+		recursive: true,
+		preserveTimestamps: true,
+		verbatimSymlinks: false
+	});
+	rmSync(dest_dir, {
+		recursive: true,
+		force: true
+	});
+	cpSync(tmp_dir, dest_dir, {
+		recursive: true,
+		preserveTimestamps: true,
+		verbatimSymlinks: false
+	});
+	rmSync(tmp_dir, {
+		recursive: true,
+		force: true
+	});
+}
+function import_external_skill(skill) {
+	if (skill.kind !== "external") throw new Error(`Skill ${skill.name} is not importable`);
+	const managed_root = get_managed_skills_dir();
+	ensure_dir(managed_root);
+	const skill_dir = join(managed_root, skill.name);
+	if (existsSync(skill_dir)) {
+		if (!statSync(skill_dir).isDirectory()) throw new Error(`${skill_dir} exists and is not a directory`);
+		if (!read_metadata(skill_dir)) throw new Error(`Refusing to overwrite existing unmanaged skill at ${skill_dir}`);
+	}
+	replace_directory(skill.baseDir, skill_dir);
+	const upstream_hash = hash_directory(skill.baseDir);
+	const imported_hash = hash_directory(skill_dir);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const metadata = {
+		version: IMPORT_METADATA_VERSION,
+		source: skill.source,
+		upstream_skill_path: skill.skillPath,
+		upstream_base_dir: skill.baseDir,
+		upstream_install_path: skill.plugin?.installPath,
+		upstream_version: skill.plugin?.version,
+		upstream_git_commit_sha: skill.plugin?.gitCommitSha,
+		imported_at: now,
+		last_synced_at: now,
+		imported_hash,
+		upstream_hash
+	};
+	write_metadata(skill_dir, metadata);
+	return {
+		skillDir: skill_dir,
+		metadata
+	};
+}
+function sync_imported_skill(skill) {
+	if (skill.kind !== "managed" || !skill.import_meta) throw new Error(`Skill ${skill.name} is not managed by my-pi sync`);
+	const metadata = skill.import_meta;
+	if (!existsSync(metadata.upstream_base_dir)) throw new Error(`Upstream source no longer exists: ${metadata.upstream_base_dir}`);
+	if (hash_directory(skill.baseDir) !== metadata.imported_hash) throw new Error(`Refusing to sync ${skill.name}; local changes detected in ${skill.baseDir}`);
+	const upstream_hash = hash_directory(metadata.upstream_base_dir);
+	if (upstream_hash === metadata.upstream_hash) return {
+		skillDir: skill.baseDir,
+		metadata,
+		changed: false
+	};
+	replace_directory(metadata.upstream_base_dir, skill.baseDir);
+	const imported_hash = hash_directory(skill.baseDir);
+	const updated = {
+		...metadata,
+		last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+		imported_hash,
+		upstream_hash
+	};
+	write_metadata(skill.baseDir, updated);
+	return {
+		skillDir: skill.baseDir,
+		metadata: updated,
+		changed: true
+	};
+}
+//#endregion
+//#region src/skills/manager.ts
+function resolve_skill_key(skill) {
+	return make_skill_key(skill.name, skill.source);
+}
+function match_skill_by_key_or_name(skills, key_or_name) {
+	const exact_key = skills.find((skill) => resolve_skill_key(skill) === key_or_name);
+	if (exact_key) return exact_key;
+	const by_name = skills.filter((skill) => skill.name === key_or_name);
+	if (by_name.length === 1) return by_name[0];
+	if (by_name.length > 1) throw new Error(`Multiple skills named ${key_or_name}. Use an exact key instead.`);
+	throw new Error(`Unknown skill: ${key_or_name}`);
+}
+function create_skills_manager() {
+	let config = load_skills_config();
+	let managed_cache = null;
+	let importable_cache = null;
+	function get_managed() {
+		if (!managed_cache) managed_cache = scan_managed_skills();
+		return managed_cache;
+	}
+	function get_importable() {
+		if (!importable_cache) importable_cache = scan_importable_skills();
+		return importable_cache;
+	}
+	function to_managed(skill) {
+		const key = resolve_skill_key(skill);
+		return {
+			...skill,
+			key,
+			enabled: skill.kind === "managed" ? is_skill_enabled(config, key) : false
+		};
+	}
+	function get_enabled_managed_skills() {
+		return get_managed().filter((skill) => is_skill_enabled(config, resolve_skill_key(skill))).map(to_managed);
+	}
+	return {
+		discover() {
+			return get_managed().map(to_managed);
+		},
+		discover_importable() {
+			return get_importable().map(to_managed);
+		},
+		is_enabled_by_skill(name, filePath) {
+			const discovered = get_managed();
+			const match = discovered.find((s) => s.skillPath === filePath);
+			if (match) return is_skill_enabled(config, resolve_skill_key(match));
+			const by_name = discovered.find((s) => s.name === name);
+			if (by_name) return is_skill_enabled(config, resolve_skill_key(by_name));
+			return true;
+		},
+		get_enabled_skill_paths() {
+			return get_enabled_managed_skills().map((skill) => skill.baseDir);
+		},
+		enable(key) {
+			config.enabled[key] = true;
+			save_skills_config(config);
+			return true;
+		},
+		disable(key) {
+			config.enabled[key] = false;
+			save_skills_config(config);
+			return false;
+		},
+		toggle(key) {
+			const current = is_skill_enabled(config, key);
+			config.enabled[key] = !current;
+			save_skills_config(config);
+			return !current;
+		},
+		search(query) {
+			const q = query.toLowerCase();
+			return this.discover().filter((s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.source.toLowerCase().includes(q));
+		},
+		search_importable(query) {
+			const q = query.toLowerCase();
+			return this.discover_importable().filter((s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.source.toLowerCase().includes(q));
+		},
+		set_defaults(policy) {
+			config.defaults = policy;
+			save_skills_config(config);
+		},
+		import_skill(key_or_name) {
+			const skill = match_skill_by_key_or_name(get_importable(), key_or_name);
+			const result = import_external_skill(skill);
+			const managed_key = make_skill_key(skill.name, "pi-native");
+			config.enabled[managed_key] = true;
+			save_skills_config(config);
+			this.refresh();
+			return {
+				...result,
+				key: managed_key
+			};
+		},
+		sync_skill(key_or_name) {
+			const skill = match_skill_by_key_or_name(get_managed(), key_or_name);
+			const result = sync_imported_skill(skill);
+			this.refresh();
+			return {
+				...result,
+				key: resolve_skill_key(skill)
+			};
+		},
+		refresh() {
+			managed_cache = null;
+			importable_cache = null;
+			config = load_skills_config();
+		}
+	};
+}
+//#endregion
+//#region src/extensions/skills.ts
+const ENABLED = "[x]";
+const DISABLED = "[ ]";
+const SYNC = "[~]";
+const IMPORTED_LABEL = "[=]";
+function sort_skills(skills) {
+	return [...skills].sort((a, b) => {
+		const by_name = a.name.localeCompare(b.name);
+		if (by_name !== 0) return by_name;
+		const by_source = a.source.localeCompare(b.source);
+		if (by_source !== 0) return by_source;
+		return a.key.localeCompare(b.key);
+	});
+}
+function find_matching_imported_skill(managed_skills, skill) {
+	const exact_match = managed_skills.find((candidate) => candidate.import_meta?.source === skill.source && (candidate.import_meta.upstream_skill_path === skill.skillPath || candidate.import_meta.upstream_base_dir === skill.baseDir));
+	if (exact_match) return exact_match;
+	return managed_skills.find((candidate) => candidate.import_meta?.source === skill.source && candidate.name === skill.name);
+}
+function get_importable_state(managed_skills, skill) {
+	const imported = find_matching_imported_skill(managed_skills, skill);
+	if (imported?.import_meta) {
+		const version_changed = Boolean(skill.plugin?.version && imported.import_meta.upstream_version && skill.plugin.version !== imported.import_meta.upstream_version);
+		const sha_changed = Boolean(skill.plugin?.gitCommitSha && imported.import_meta.upstream_git_commit_sha && skill.plugin.gitCommitSha !== imported.import_meta.upstream_git_commit_sha);
+		if (version_changed || sha_changed) return {
+			label: "sync",
+			detail: "Press Enter to sync the imported copy and reload",
+			action: "sync"
+		};
+		return {
+			label: "imported",
+			detail: `Already imported to ${imported.baseDir}`,
+			action: null
+		};
+	}
+	const managed_conflict = managed_skills.find((candidate) => candidate.name === skill.name);
+	if (managed_conflict) return {
+		label: "managed",
+		detail: `Already managed at ${managed_conflict.baseDir}`,
+		action: null
+	};
+	return {
+		label: "import",
+		detail: "Press Enter to import into pi-native skills and reload",
+		action: "import"
+	};
+}
+function to_setting_item(skill) {
+	const detail_lines = [
+		`${skill.source} • ${skill.key}`,
+		skill.description,
+		skill.baseDir
+	];
+	if (skill.import_meta?.upstream_version) detail_lines.push(`upstream: ${skill.import_meta.upstream_version}${skill.import_meta.upstream_git_commit_sha ? ` • ${skill.import_meta.upstream_git_commit_sha.slice(0, 12)}` : ""}`);
+	return {
+		id: skill.key,
+		label: skill.name,
+		description: detail_lines.join("\n"),
+		currentValue: skill.enabled ? ENABLED : DISABLED,
+		values: [ENABLED, DISABLED]
+	};
+}
+function to_importable_setting_item(managed_skills, skill) {
+	const state = get_importable_state(managed_skills, skill);
+	const detail_lines = [
+		`${skill.source} • ${skill.key}`,
+		skill.description,
+		skill.baseDir
+	];
+	if (skill.plugin?.version) detail_lines.push(`plugin: ${skill.plugin.version}${skill.plugin.gitCommitSha ? ` • ${skill.plugin.gitCommitSha.slice(0, 12)}` : ""}`);
+	if (state.action === "import") return {
+		id: skill.key,
+		label: skill.name,
+		description: detail_lines.join("\n"),
+		currentValue: DISABLED,
+		values: [ENABLED, DISABLED]
+	};
+	if (state.action === "sync") {
+		detail_lines.push("enter to sync");
+		return {
+			id: skill.key,
+			label: skill.name,
+			description: detail_lines.join("\n"),
+			currentValue: SYNC,
+			values: [SYNC]
+		};
+	}
+	detail_lines.push(state.detail);
+	return {
+		id: skill.key,
+		label: skill.name,
+		description: detail_lines.join("\n"),
+		currentValue: IMPORTED_LABEL
+	};
+}
+function sets_equal(a, b) {
+	if (a.size !== b.size) return false;
+	for (const value of a) if (!b.has(value)) return false;
+	return true;
+}
+async function skills(pi) {
+	const mgr = create_skills_manager();
+	const subs = [
+		"import",
+		"sync",
+		"refresh",
+		"defaults"
+	];
+	pi.registerCommand("skills", {
+		description: "Manage pi-native skills and import external skills",
+		getArgumentCompletions: (prefix) => {
+			const parts = prefix.trim().split(/\s+/);
+			if (parts.length <= 1) return subs.filter((s) => s.startsWith(parts[0] || "")).map((s) => ({
+				value: s,
+				label: s
+			}));
+			if (parts[0] === "import") {
+				const q = parts.slice(1).join(" ").toLowerCase();
+				return sort_skills(mgr.discover_importable()).filter((s) => s.key.toLowerCase().includes(q) || s.name.toLowerCase().includes(q)).slice(0, 20).map((s) => ({
+					value: `${parts[0]} ${s.key}`,
+					label: s.key
+				}));
+			}
+			if (parts[0] === "sync") {
+				const q = parts.slice(1).join(" ").toLowerCase();
+				return sort_skills(mgr.discover().filter((skill) => Boolean(skill.import_meta))).filter((s) => s.key.toLowerCase().includes(q) || s.name.toLowerCase().includes(q)).slice(0, 20).map((s) => ({
+					value: `${parts[0]} ${s.key}`,
+					label: s.key
+				}));
+			}
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const trimmed = args.trim();
+			if (!trimmed && ctx.hasUI) {
+				const discovered = sort_skills(mgr.discover());
+				const importable = sort_skills(mgr.discover_importable());
+				if (discovered.length === 0 && importable.length === 0) {
+					ctx.ui.notify("No managed or importable skills found");
+					return;
+				}
+				const initial_enabled = new Set(discovered.filter((skill) => skill.enabled).map((skill) => skill.key));
+				const current_enabled = new Set(initial_enabled);
+				const queued_imports = /* @__PURE__ */ new Set();
+				let reload_notice = null;
+				const managed_items = discovered.map(to_setting_item);
+				const importable_items = importable.map((skill) => to_importable_setting_item(discovered, skill));
+				const all_items = [];
+				if (managed_items.length > 0) {
+					all_items.push({
+						id: "__header_managed__",
+						label: `── Managed (${managed_items.length}) ──`,
+						description: "",
+						currentValue: ""
+					});
+					all_items.push(...managed_items);
+				}
+				if (importable_items.length > 0) {
+					all_items.push({
+						id: "__header_importable__",
+						label: `── Importable (${importable_items.length}) ──`,
+						description: "",
+						currentValue: ""
+					});
+					all_items.push(...importable_items);
+				}
+				const managed_keys = new Set(discovered.map((s) => s.key));
+				const importable_map = new Map(importable.map((s) => [s.key, s]));
+				await ctx.ui.custom((tui, theme, _kb, done) => {
+					const list = new SettingsList(all_items, Math.min(Math.max(all_items.length + 4, 8), 22), {
+						cursor: theme.fg("accent", "›"),
+						label: (text, selected) => {
+							if (text.startsWith("──") && text.endsWith("──")) return theme.fg("dim", theme.bold(text));
+							return selected ? theme.fg("accent", text) : text;
+						},
+						value: (text, selected) => {
+							const color = text === ENABLED ? "success" : text === SYNC ? "warning" : text === IMPORTED_LABEL ? "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) => {
+						if (id.startsWith("__header_")) return;
+						if (managed_keys.has(id)) {
+							if (new_value === ENABLED) {
+								current_enabled.add(id);
+								mgr.enable(id);
+							} else {
+								current_enabled.delete(id);
+								mgr.disable(id);
+							}
+							return;
+						}
+						const import_skill = importable_map.get(id);
+						if (!import_skill) return;
+						const state = get_importable_state(discovered, import_skill);
+						if (state.action === "import") {
+							if (new_value === ENABLED) queued_imports.add(id);
+							else queued_imports.delete(id);
+							return;
+						}
+						if (state.action === "sync") {
+							const imported_skill = find_matching_imported_skill(discovered, import_skill);
+							if (!imported_skill) {
+								ctx.ui.notify(`Imported copy for ${import_skill.name} was not found`, "warning");
+								return;
+							}
+							try {
+								if (mgr.sync_skill(imported_skill.key).changed) {
+									reload_notice = `Synced ${import_skill.name}. Reloading...`;
+									done(void 0);
+								} else ctx.ui.notify(`${import_skill.name} is already up to date.`, "info");
+							} catch (error) {
+								ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
+							}
+						}
+					}, () => done(void 0), { enableSearch: true });
+					const container = new Container();
+					container.addChild({
+						render: () => {
+							const enabled = current_enabled.size;
+							const disabled = discovered.length - enabled;
+							const queued = queued_imports.size;
+							const parts = [`${enabled} enabled`, `${disabled} disabled`];
+							if (importable.length > 0) parts.push(`${importable.length} importable`);
+							if (queued > 0) parts.push(`${queued} queued for import`);
+							return [
+								theme.fg("accent", theme.bold("Skills")),
+								theme.fg("muted", parts.join(" • ")),
+								""
+							];
+						},
+						invalidate: () => {}
+					});
+					container.addChild({
+						render(width) {
+							return list.render(width);
+						},
+						invalidate() {
+							list.invalidate();
+						}
+					});
+					container.addChild(new Text(theme.fg("dim", "search filters • enter toggles • esc close"), 0, 1));
+					return {
+						render(width) {
+							return container.render(width);
+						},
+						invalidate() {
+							container.invalidate();
+						},
+						handleInput(data) {
+							list.handleInput(data);
+							tui.requestRender();
+						}
+					};
+				});
+				if (queued_imports.size > 0) {
+					const imported_names = [];
+					for (const key of queued_imports) try {
+						mgr.import_skill(key);
+						imported_names.push(key);
+					} catch (error) {
+						ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
+					}
+					if (imported_names.length > 0) reload_notice = `Imported ${imported_names.length} skill(s). Reloading...`;
+				}
+				if (reload_notice) {
+					ctx.ui.notify(reload_notice, "info");
+					await ctx.reload();
+					return;
+				}
+				if (!sets_equal(initial_enabled, current_enabled)) {
+					ctx.ui.notify("Reloading to apply updated skills...", "info");
+					await ctx.reload();
+					return;
+				}
+				return;
+			}
+			const [sub, ...rest] = (trimmed || "list").split(/\s+/);
+			const arg = rest.join(" ");
+			switch (sub) {
+				case "import":
+					if (!arg) {
+						ctx.ui.notify("Usage: /skills import <key|name>", "warning");
+						return;
+					}
+					try {
+						const result = mgr.import_skill(arg);
+						ctx.ui.notify(`Imported ${arg} to ${result.skillDir}. Reloading...`, "info");
+						await ctx.reload();
+						return;
+					} catch (error) {
+						ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
+						return;
+					}
+				case "sync":
+					if (!arg) {
+						ctx.ui.notify("Usage: /skills sync <key|name>", "warning");
+						return;
+					}
+					try {
+						const result = mgr.sync_skill(arg);
+						ctx.ui.notify(result.changed ? `Synced ${arg}. Reloading...` : `${arg} is already up to date.`, "info");
+						if (result.changed) await ctx.reload();
+						return;
+					} catch (error) {
+						ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
+						return;
+					}
+				case "refresh":
+					mgr.refresh();
+					ctx.ui.notify(`Rescanned: ${mgr.discover().length} managed skills, ${mgr.discover_importable().length} importable skills found`);
+					break;
+				case "defaults":
+					if (arg !== "all-enabled" && arg !== "all-disabled") {
+						ctx.ui.notify("Usage: /skills defaults <all-enabled|all-disabled>", "warning");
+						return;
+					}
+					mgr.set_defaults(arg);
+					ctx.ui.notify(`Default policy: ${arg}`);
+					break;
+				default: ctx.ui.notify(`Unknown: ${sub}. Use: ${subs.join(", ")}`, "warning");
+			}
+		}
+	});
+}
+//#endregion
+//#region src/api.ts
+const BUILTIN_EXTENSION_FACTORIES = {
+	mcp,
+	skills,
+	chain,
+	"filter-output": filter_output,
+	handoff,
+	recall
+};
+function get_force_disabled_builtins(options) {
+	const force_disabled = /* @__PURE__ */ new Set();
+	if (!options.mcp) force_disabled.add("mcp");
+	if (!options.skills) force_disabled.add("skills");
+	if (!options.chain) force_disabled.add("chain");
+	if (!options.filter_output) force_disabled.add("filter-output");
+	if (!options.handoff) force_disabled.add("handoff");
+	if (!options.recall) force_disabled.add("recall");
+	return force_disabled;
+}
+function create_builtin_extension_factory(key, extension, force_disabled) {
+	return async (pi) => {
+		if (!is_builtin_extension_active(load_builtin_extensions_config(), key, force_disabled)) return;
+		await extension(pi);
+	};
+}
+function create_extensions_override(managed_inline_paths) {
+	const managed_paths = new Set(managed_inline_paths);
+	return (base) => {
+		const managed = new Map(base.extensions.map((extension) => [extension.path, extension]));
+		const ordered_managed = managed_inline_paths.map((path) => managed.get(path)).filter((extension) => Boolean(extension));
+		const others = base.extensions.filter((extension) => !managed_paths.has(extension.path));
+		return {
+			...base,
+			extensions: [...ordered_managed, ...others]
+		};
+	};
+}
+async function create_my_pi(options = {}) {
+	const { cwd = process.cwd(), extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, model } = options;
+	const resolved_extensions = extensions.map((p) => resolve(cwd, p));
+	const force_disabled = get_force_disabled_builtins({
+		mcp,
+		skills,
+		chain,
+		filter_output,
+		handoff,
+		recall
+	});
+	const managed_extension_factories = [create_extensions_extension({ force_disabled }), ...BUILTIN_EXTENSIONS.map((extension) => create_builtin_extension_factory(extension.key, BUILTIN_EXTENSION_FACTORIES[extension.key], force_disabled))];
+	const managed_inline_paths = managed_extension_factories.map((_, index) => `<inline:${index + 1}>`);
+	const create_runtime = async ({ cwd: runtime_cwd, sessionManager, sessionStartEvent }) => {
+		const settings_manager = model ? (() => {
+			const sm = SettingsManager.create(runtime_cwd);
+			sm.setDefaultModel(model);
+			return sm;
+		})() : void 0;
+		const services = await createAgentSessionServices({
+			cwd: runtime_cwd,
+			...settings_manager ? { settingsManager: settings_manager } : {},
+			resourceLoaderOptions: {
+				additionalExtensionPaths: [...resolved_extensions],
+				extensionFactories: [...managed_extension_factories, ...user_factories],
+				extensionsOverride: create_extensions_override(managed_inline_paths),
+				skillsOverride: (base) => {
+					if (!is_builtin_extension_active(load_builtin_extensions_config(), "skills", force_disabled)) return base;
+					const skills_manager = create_skills_manager();
+					return {
+						...base,
+						skills: base.skills.filter((skill) => skills_manager.is_enabled_by_skill(skill.name, skill.filePath))
+					};
+				}
+			}
+		});
+		return {
+			...await createAgentSessionFromServices({
+				services,
+				sessionManager,
+				sessionStartEvent
+			}),
+			services,
+			diagnostics: services.diagnostics
+		};
+	};
+	return createAgentSessionRuntime(create_runtime, {
+		cwd,
+		agentDir: getAgentDir(),
+		sessionManager: SessionManager.create(cwd)
+	});
+}
+//#endregion
+export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
+
+//# sourceMappingURL=api-B6KnhtN9.js.map