my-pi 0.0.6 → 0.0.7

package/dist/{api-S06lPaJV.js → api-DtthDVIa.js}

@@ -1,5 +1,5 @@
 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 { cpSync, existsSync, globSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Type } from "@sinclair/typebox";
@@ -388,6 +388,17 @@ const BUILTIN_EXTENSIONS = [
 		description: "Past session recall guidance and /recall command",
 		cli_flag: "--no-recall",
 		aliases: ["recall"]
+	},
+	{
+		key: "prompt-presets",
+		label: "Prompt presets",
+		description: "Runtime prompt preset selection and /preset command",
+		cli_flag: "--no-prompt-presets",
+		aliases: [
+			"prompt-presets",
+			"preset",
+			"presets"
+		]
 	}
 ];
 function get_builtin_extensions_config_path() {
@@ -452,8 +463,8 @@ function find_builtin_extension(query) {
 }
 //#endregion
 //#region src/extensions/extensions.ts
-const ENABLED$1 = "[x]";
-const DISABLED$1 = "[ ]";
+const ENABLED$2 = "[x]";
+const DISABLED$2 = "[ ]";
 function to_force_disabled_set(force_disabled) {
 	return new Set(force_disabled ?? []);
 }
@@ -469,7 +480,7 @@ function format_extension_lines(states, options) {
 	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(`${state.saved_enabled ? ENABLED$2 : DISABLED$2} ${state.label}`);
 		lines.push(`    key: ${state.key}`);
 		lines.push(`    saved config: ${state.saved_enabled ? "enabled" : "disabled"}`);
 		lines.push(`    current process: ${format_effective_state(state)}`);
@@ -488,11 +499,11 @@ function to_setting_item$1(state) {
 		id: state.key,
 		label: state.label,
 		description: detail_lines.join("\n"),
-		currentValue: state.saved_enabled ? ENABLED$1 : DISABLED$1,
-		values: [ENABLED$1, DISABLED$1]
+		currentValue: state.saved_enabled ? ENABLED$2 : DISABLED$2,
+		values: [ENABLED$2, DISABLED$2]
 	};
 }
-function sets_equal$1(a, b) {
+function sets_equal$2(a, b) {
 	if (a.size !== b.size) return false;
 	for (const value of a) if (!b.has(value)) return false;
 	return true;
@@ -538,7 +549,7 @@ function create_extensions_extension(options = {}) {
 					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}`
+						label: `${state.key} ${state.saved_enabled ? ENABLED$2 : DISABLED$2}`
 					}));
 				}
 				return null;
@@ -570,7 +581,7 @@ function create_extensions_extension(options = {}) {
 							cursor: theme.fg("accent", "›"),
 							label: (text, selected) => selected ? theme.fg("accent", text) : text,
 							value: (text, selected) => {
-								const color = text === ENABLED$1 ? "success" : "dim";
+								const color = text === ENABLED$2 ? "success" : "dim";
 								const rendered = theme.fg(color, text);
 								return selected ? theme.bold(theme.fg("accent", rendered)) : rendered;
 							},
@@ -578,7 +589,7 @@ function create_extensions_extension(options = {}) {
 							hint: (text) => theme.fg("dim", text)
 						}, (id, new_value) => {
 							const key = id;
-							const enabled = new_value === ENABLED$1;
+							const enabled = new_value === ENABLED$2;
 							if (enabled) current_enabled.add(key);
 							else current_enabled.delete(key);
 							save_extension_enabled(key, enabled);
@@ -598,7 +609,7 @@ function create_extensions_extension(options = {}) {
 							}
 						};
 					});
-					if (!sets_equal$1(initial_enabled, current_enabled)) {
+					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;
@@ -1051,6 +1062,649 @@ async function mcp(pi) {
 	});
 }
 //#endregion
+//#region src/extensions/prompt-presets.ts
+const PRESET_STATE_TYPE = "prompt-preset-state";
+const ENABLED$1 = "[x]";
+const DISABLED$1 = "[ ]";
+const SELECTED = "(x)";
+const UNSELECTED = "( )";
+const NONE_BASE_ID = "__base_none__";
+const DEFAULT_PROMPT_PRESETS = {
+	terse: {
+		kind: "base",
+		description: "Short, direct, no fluff",
+		instructions: "Be concise and direct. Default to the shortest response that fully solves the user's request. No purple prose, no filler, no repetitive caveats. Prefer a short paragraph or a few bullets. Only include extra detail when it materially affects the decision, implementation, or next step."
+	},
+	standard: {
+		kind: "base",
+		description: "Clear and concise with key context",
+		instructions: "Be clear, direct, and concise. Include only the reasoning and implementation details that matter. Avoid filler, grandstanding, and ornamental language. Use bullets when they improve scanability."
+	},
+	detailed: {
+		kind: "base",
+		description: "More explanation when nuance matters",
+		instructions: "Be thorough when the task is complex or tradeoffs matter, but stay practical. Explain only the details that help the user decide, verify, or implement. Avoid purple prose and unnecessary scene-setting."
+	},
+	"no-purple-prose": {
+		kind: "layer",
+		description: "Strip out ornamental language",
+		instructions: "Do not use purple prose, flourish, motivational filler, or theatrical transitions. Prefer plain language and concrete statements."
+	},
+	bullets: {
+		kind: "layer",
+		description: "Prefer short bullets when useful",
+		instructions: "When presenting options, findings, or steps, prefer short bullet lists over long paragraphs."
+	},
+	"clarify-first": {
+		kind: "layer",
+		description: "Ask brief clarifying questions when requirements are ambiguous",
+		instructions: "If the request is materially ambiguous, ask the minimum clarifying question(s) needed before proceeding. Do not ask unnecessary questions."
+	},
+	"include-risks": {
+		kind: "layer",
+		description: "Call out notable risks or tradeoffs",
+		instructions: "When making a recommendation or implementation plan, briefly mention the key risk, tradeoff, or caveat if one materially matters."
+	}
+};
+function normalize_prompt_presets(input) {
+	if (!input || typeof input !== "object") return {};
+	const normalized = {};
+	for (const [raw_name, raw_value] of Object.entries(input)) {
+		const name = raw_name.trim();
+		if (!name) continue;
+		if (typeof raw_value === "string") {
+			normalized[name] = {
+				kind: "base",
+				instructions: raw_value
+			};
+			continue;
+		}
+		if (!raw_value || typeof raw_value !== "object") continue;
+		const candidate = raw_value;
+		if (typeof candidate.instructions !== "string") continue;
+		normalized[name] = {
+			instructions: candidate.instructions,
+			...candidate.kind === "layer" ? { kind: "layer" } : {},
+			...typeof candidate.description === "string" ? { description: candidate.description } : {}
+		};
+	}
+	return normalized;
+}
+function to_loaded_prompt_presets(presets, source) {
+	return Object.fromEntries(Object.entries(presets).map(([name, preset]) => [name, {
+		name,
+		kind: preset.kind === "layer" ? "layer" : "base",
+		source,
+		...preset
+	}]));
+}
+function get_global_presets_path() {
+	return join(getAgentDir(), "presets.json");
+}
+function get_project_presets_path(cwd) {
+	return join(cwd, ".pi", "presets.json");
+}
+function read_prompt_presets_file(path) {
+	if (!existsSync(path)) return {};
+	try {
+		return normalize_prompt_presets(JSON.parse(readFileSync(path, "utf-8")));
+	} catch {
+		return {};
+	}
+}
+function load_prompt_presets(cwd) {
+	return Object.assign({}, to_loaded_prompt_presets(DEFAULT_PROMPT_PRESETS, "builtin"), to_loaded_prompt_presets(read_prompt_presets_file(get_global_presets_path()), "user"), to_loaded_prompt_presets(read_prompt_presets_file(get_project_presets_path(cwd)), "project"));
+}
+function sort_prompt_presets(presets) {
+	return Object.fromEntries(Object.entries(presets).sort(([a], [b]) => a.localeCompare(b)));
+}
+function save_project_prompt_presets(cwd, presets) {
+	const path = get_project_presets_path(cwd);
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${path}.tmp-${Date.now()}`;
+	writeFileSync(tmp, JSON.stringify(sort_prompt_presets(presets), null, "	") + "\n", { mode: 384 });
+	renameSync(tmp, path);
+	return path;
+}
+function remove_project_prompt_preset(cwd, name) {
+	const path = get_project_presets_path(cwd);
+	const project_presets = read_prompt_presets_file(path);
+	if (!(name in project_presets)) return {
+		removed: false,
+		path,
+		remaining: Object.keys(project_presets).length
+	};
+	delete project_presets[name];
+	const remaining = Object.keys(project_presets).length;
+	if (remaining === 0) {
+		if (existsSync(path)) unlinkSync(path);
+		return {
+			removed: true,
+			path,
+			remaining
+		};
+	}
+	save_project_prompt_presets(cwd, project_presets);
+	return {
+		removed: true,
+		path,
+		remaining
+	};
+}
+function get_last_preset_state(ctx) {
+	const entries = ctx.sessionManager.getEntries();
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry.type === "custom" && entry.customType === PRESET_STATE_TYPE && entry.data) return entry.data;
+	}
+}
+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 get_prompt_source_label(source) {
+	switch (source) {
+		case "builtin": return "built-in";
+		case "user": return "user";
+		case "project": return "project";
+	}
+}
+function list_base_presets(presets) {
+	return Object.values(presets).filter((preset) => preset.kind === "base").sort((a, b) => a.name.localeCompare(b.name));
+}
+function list_layer_presets(presets) {
+	return Object.values(presets).filter((preset) => preset.kind === "layer").sort((a, b) => a.name.localeCompare(b.name));
+}
+function format_summary(active_base_name, active_layers, presets) {
+	const lines = [`Base: ${active_base_name ?? "(none)"}`];
+	const layer_names = [...active_layers].sort();
+	if (layer_names.length === 0) lines.push("Layers: (none)");
+	else {
+		lines.push("Layers:");
+		for (const name of layer_names) {
+			const preset = presets[name];
+			const description = preset?.description ? ` — ${preset.description}` : "";
+			lines.push(`- ${name}${description}`);
+		}
+	}
+	return lines.join("\n");
+}
+function format_active_details(active_base_name, active_layers, presets) {
+	const parts = [];
+	if (active_base_name) {
+		const base = presets[active_base_name];
+		if (base) {
+			parts.push(`Base: ${base.name}`);
+			if (base.description) parts.push(`Description: ${base.description}`);
+			parts.push(`Source: ${get_prompt_source_label(base.source)}`);
+			parts.push("", base.instructions.trim());
+		}
+	}
+	const layer_names = [...active_layers].sort();
+	if (layer_names.length > 0) {
+		if (parts.length > 0) parts.push("", "---", "");
+		parts.push("Layers:");
+		for (const name of layer_names) {
+			const layer = presets[name];
+			if (!layer) continue;
+			parts.push(`- ${layer.name} (${get_prompt_source_label(layer.source)})`);
+			if (layer.description) parts.push(`  ${layer.description}`);
+		}
+	}
+	return parts.join("\n") || "No preset or layers active";
+}
+function set_status(ctx, active_base_name, active_layers) {
+	const label = active_base_name ?? "none";
+	const layer_suffix = active_layers.size > 0 ? ` +${active_layers.size}` : "";
+	ctx.ui.setStatus("preset", `prompt:${label}${layer_suffix}`);
+}
+function persist_state(pi, active_base_name, active_layers) {
+	pi.appendEntry(PRESET_STATE_TYPE, {
+		base_name: active_base_name ?? null,
+		layer_names: [...active_layers].sort()
+	});
+}
+function normalize_active_state(presets, active_base_name, active_layers) {
+	return {
+		active_base_name: active_base_name && presets[active_base_name]?.kind === "base" ? active_base_name : void 0,
+		active_layers: new Set([...active_layers].filter((name) => presets[name]?.kind === "layer"))
+	};
+}
+function parse_preset_flag(flag) {
+	return flag.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function is_subcommand(command) {
+	return [
+		"list",
+		"show",
+		"clear",
+		"edit",
+		"delete",
+		"reset",
+		"reload",
+		"base",
+		"enable",
+		"disable",
+		"toggle"
+	].includes(command);
+}
+async function prompt_presets(pi) {
+	let presets = {};
+	let active_base_name;
+	let active_layers = /* @__PURE__ */ new Set();
+	function get_base(name) {
+		return name ? presets[name] : void 0;
+	}
+	function get_layer(name) {
+		const preset = presets[name];
+		return preset?.kind === "layer" ? preset : void 0;
+	}
+	function commit_state(ctx, next_base_name, next_layers, options) {
+		active_base_name = next_base_name;
+		active_layers = new Set(next_layers);
+		set_status(ctx, active_base_name, active_layers);
+		if (options?.persist !== false) persist_state(pi, active_base_name, active_layers);
+		if (options?.notify) ctx.ui.notify(options.notify, "info");
+	}
+	function activate_base(name, ctx, options) {
+		if (!name) {
+			commit_state(ctx, void 0, active_layers, {
+				persist: options?.persist,
+				notify: "Base preset cleared"
+			});
+			return true;
+		}
+		const preset = get_base(name);
+		if (!preset) {
+			ctx.ui.notify(`Unknown base preset: ${name}`, "warning");
+			return false;
+		}
+		commit_state(ctx, preset.name, active_layers, {
+			persist: options?.persist,
+			notify: `Base preset "${preset.name}" activated`
+		});
+		return true;
+	}
+	function set_layer_enabled(name, enabled, ctx, options) {
+		const preset = get_layer(name);
+		if (!preset) {
+			ctx.ui.notify(`Unknown prompt layer: ${name}`, "warning");
+			return false;
+		}
+		const next_layers = new Set(active_layers);
+		if (enabled) next_layers.add(preset.name);
+		else next_layers.delete(preset.name);
+		commit_state(ctx, active_base_name, next_layers, {
+			persist: options?.persist,
+			notify: enabled ? `Layer "${preset.name}" enabled` : `Layer "${preset.name}" disabled`
+		});
+		return true;
+	}
+	function toggle_layer(name, ctx, options) {
+		return set_layer_enabled(name, !active_layers.has(name), ctx, options);
+	}
+	async function edit_preset(name, ctx) {
+		const existing = presets[name];
+		const kind_choice = await ctx.ui.select("Preset kind", [existing?.kind === "layer" ? "layer (current)" : "base (current)", existing?.kind === "layer" ? "base" : "layer"]);
+		if (!kind_choice) return;
+		const kind = kind_choice.startsWith("layer") ? "layer" : "base";
+		const description = await ctx.ui.input(`Description for ${name}`, existing?.description ?? "");
+		if (description === void 0) return;
+		const instructions = await ctx.ui.editor(`Edit ${kind} preset: ${name}`, existing?.instructions ?? "");
+		if (instructions === void 0) return;
+		save_project_prompt_presets(ctx.cwd, {
+			...read_prompt_presets_file(get_project_presets_path(ctx.cwd)),
+			[name]: {
+				kind,
+				instructions,
+				...description.trim() ? { description: description.trim() } : {}
+			}
+		});
+		presets = load_prompt_presets(ctx.cwd);
+		const normalized = normalize_active_state(presets, active_base_name, active_layers);
+		active_base_name = normalized.active_base_name;
+		active_layers = normalized.active_layers;
+		if (kind === "base") activate_base(name, ctx);
+		else set_layer_enabled(name, true, ctx);
+		ctx.ui.notify(`Saved preset "${name}" to ${get_project_presets_path(ctx.cwd)}`, "info");
+	}
+	function remove_custom_preset(name, ctx, mode) {
+		const result = remove_project_prompt_preset(ctx.cwd, name);
+		if (!result.removed) {
+			ctx.ui.notify(`No project-local preset named "${name}" to ${mode}`, "warning");
+			return;
+		}
+		presets = load_prompt_presets(ctx.cwd);
+		const normalized = normalize_active_state(presets, active_base_name, active_layers);
+		active_base_name = normalized.active_base_name;
+		active_layers = normalized.active_layers;
+		set_status(ctx, active_base_name, active_layers);
+		persist_state(pi, active_base_name, active_layers);
+		const fallback = presets[name];
+		if (mode === "reset" && fallback) {
+			ctx.ui.notify(`Reset "${name}" to ${get_prompt_source_label(fallback.source)} preset`, "info");
+			return;
+		}
+		ctx.ui.notify(result.remaining === 0 ? `Removed "${name}" and deleted ${result.path}` : `Removed "${name}" from ${result.path}`, "info");
+	}
+	async function show_manager(ctx) {
+		const base_presets = list_base_presets(presets);
+		const layer_presets = list_layer_presets(presets);
+		if (base_presets.length === 0 && layer_presets.length === 0) {
+			ctx.ui.notify("No prompt presets available", "warning");
+			return;
+		}
+		const initial_base = active_base_name;
+		const initial_layers = new Set(active_layers);
+		let selected_base = active_base_name;
+		const enabled_layers = new Set(active_layers);
+		const items = [];
+		const base_ids = /* @__PURE__ */ new Set();
+		const layer_ids = /* @__PURE__ */ new Set();
+		items.push({
+			id: "__header_base__",
+			label: `── Base presets (${base_presets.length + 1}) ──`,
+			description: "",
+			currentValue: ""
+		});
+		items.push({
+			id: NONE_BASE_ID,
+			label: "(none)",
+			description: "No active base preset",
+			currentValue: UNSELECTED,
+			values: [SELECTED, UNSELECTED]
+		});
+		base_ids.add(NONE_BASE_ID);
+		for (const preset of base_presets) {
+			items.push({
+				id: preset.name,
+				label: preset.name,
+				description: [`${get_prompt_source_label(preset.source)} • ${preset.description ?? "base preset"}`].join("\n"),
+				currentValue: UNSELECTED,
+				values: [SELECTED, UNSELECTED]
+			});
+			base_ids.add(preset.name);
+		}
+		items.push({
+			id: "__header_layers__",
+			label: `── Prompt layers (${layer_presets.length}) ──`,
+			description: "",
+			currentValue: ""
+		});
+		for (const preset of layer_presets) {
+			items.push({
+				id: preset.name,
+				label: preset.name,
+				description: [`${get_prompt_source_label(preset.source)} • ${preset.description ?? "layer"}`].join("\n"),
+				currentValue: DISABLED$1,
+				values: [ENABLED$1, DISABLED$1]
+			});
+			layer_ids.add(preset.name);
+		}
+		function sync_values() {
+			for (const item of items) if (base_ids.has(item.id)) item.currentValue = item.id === NONE_BASE_ID && !selected_base || item.id === selected_base ? SELECTED : UNSELECTED;
+			else if (layer_ids.has(item.id)) item.currentValue = enabled_layers.has(item.id) ? ENABLED$1 : DISABLED$1;
+		}
+		sync_values();
+		await ctx.ui.custom((tui, theme, _kb, done) => {
+			const list = new SettingsList(items, Math.min(Math.max(items.length + 4, 8), 24), {
+				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$1 || text === SELECTED ? "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 (base_ids.has(id)) {
+					selected_base = new_value === SELECTED && id !== NONE_BASE_ID ? id : void 0;
+					sync_values();
+					return;
+				}
+				if (layer_ids.has(id)) {
+					if (new_value === ENABLED$1) enabled_layers.add(id);
+					else enabled_layers.delete(id);
+					sync_values();
+				}
+			}, () => done(void 0), { enableSearch: true });
+			const container = new Container();
+			container.addChild({
+				render: () => [
+					theme.fg("accent", theme.bold("Prompt presets")),
+					theme.fg("muted", `base: ${selected_base ?? "(none)"} • ${enabled_layers.size} layer(s) enabled`),
+					""
+				],
+				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 (selected_base !== initial_base || !sets_equal$1(initial_layers, enabled_layers)) commit_state(ctx, selected_base, enabled_layers, { notify: "Updated prompt preset selection" });
+	}
+	pi.registerFlag("preset", {
+		description: "Activate prompt config on startup. Accepts a base preset or comma-separated preset/layer names.",
+		type: "string"
+	});
+	pi.registerCommand("preset", {
+		description: "Manage base prompt presets and prompt layers",
+		getArgumentCompletions: (prefix) => {
+			const trimmed = prefix.trim();
+			const parts = trimmed ? trimmed.split(/\s+/) : [];
+			const base_names = list_base_presets(presets).map((preset) => preset.name);
+			const layer_names = list_layer_presets(presets).map((preset) => preset.name);
+			const all_names = [...base_names, ...layer_names];
+			if (parts.length <= 1) {
+				const query = parts[0] ?? "";
+				return [...[
+					"list",
+					"show",
+					"clear",
+					"edit",
+					"delete",
+					"reset",
+					"reload",
+					"base",
+					"enable",
+					"disable",
+					"toggle"
+				].filter((item) => item.startsWith(query)).map((item) => ({
+					value: item,
+					label: item
+				})), ...all_names.filter((item) => item.startsWith(query)).map((item) => ({
+					value: item,
+					label: item
+				}))];
+			}
+			const command = parts[0];
+			const query = parts.slice(1).join(" ");
+			if (command === "base") return base_names.filter((item) => item.startsWith(query)).map((item) => ({
+				value: `base ${item}`,
+				label: item
+			}));
+			if ([
+				"enable",
+				"disable",
+				"toggle"
+			].includes(command)) return layer_names.filter((item) => item.startsWith(query)).map((item) => ({
+				value: `${command} ${item}`,
+				label: item
+			}));
+			if (command === "edit") return all_names.filter((item) => item.startsWith(query)).map((item) => ({
+				value: `edit ${item}`,
+				label: item
+			}));
+			if (["delete", "reset"].includes(command)) return all_names.filter((item) => item.startsWith(query)).map((item) => ({
+				value: `${command} ${item}`,
+				label: item
+			}));
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const trimmed = args.trim();
+			if (!trimmed) {
+				if (ctx.hasUI) {
+					await show_manager(ctx);
+					return;
+				}
+				ctx.ui.notify(format_summary(active_base_name, active_layers, presets), "info");
+				return;
+			}
+			const [first, ...rest] = trimmed.split(/\s+/);
+			const arg = rest.join(" ").trim();
+			switch (first) {
+				case "list":
+					ctx.ui.notify(format_summary(active_base_name, active_layers, presets), "info");
+					return;
+				case "show":
+					ctx.ui.notify(format_active_details(active_base_name, active_layers, presets), "info");
+					return;
+				case "clear":
+					commit_state(ctx, void 0, /* @__PURE__ */ new Set(), { notify: "Cleared base preset and prompt layers" });
+					return;
+				case "reload": {
+					presets = load_prompt_presets(ctx.cwd);
+					const normalized = normalize_active_state(presets, active_base_name, active_layers);
+					active_base_name = normalized.active_base_name;
+					active_layers = normalized.active_layers;
+					set_status(ctx, active_base_name, active_layers);
+					ctx.ui.notify("Reloaded prompt presets", "info");
+					return;
+				}
+				case "base":
+					if (!arg) {
+						ctx.ui.notify("Usage: /preset base <name>", "warning");
+						return;
+					}
+					activate_base(arg, ctx);
+					return;
+				case "enable":
+					if (!arg) {
+						ctx.ui.notify("Usage: /preset enable <layer>", "warning");
+						return;
+					}
+					set_layer_enabled(arg, true, ctx);
+					return;
+				case "disable":
+					if (!arg) {
+						ctx.ui.notify("Usage: /preset disable <layer>", "warning");
+						return;
+					}
+					set_layer_enabled(arg, false, ctx);
+					return;
+				case "toggle":
+					if (!arg) {
+						ctx.ui.notify("Usage: /preset toggle <layer>", "warning");
+						return;
+					}
+					toggle_layer(arg, ctx);
+					return;
+				case "edit":
+					if (!arg) {
+						ctx.ui.notify("Usage: /preset edit <name>", "warning");
+						return;
+					}
+					await edit_preset(arg, ctx);
+					return;
+				case "delete":
+					if (!arg) {
+						ctx.ui.notify("Usage: /preset delete <name>", "warning");
+						return;
+					}
+					remove_custom_preset(arg, ctx, "delete");
+					return;
+				case "reset":
+					if (!arg) {
+						ctx.ui.notify("Usage: /preset reset <name>", "warning");
+						return;
+					}
+					remove_custom_preset(arg, ctx, "reset");
+					return;
+			}
+			if (is_subcommand(first)) {
+				ctx.ui.notify(`Unsupported preset command: ${first}`, "warning");
+				return;
+			}
+			const preset = presets[trimmed];
+			if (!preset) {
+				ctx.ui.notify(`Unknown preset or layer: ${trimmed}`, "warning");
+				return;
+			}
+			if (preset.kind === "base") activate_base(preset.name, ctx);
+			else toggle_layer(preset.name, ctx);
+		}
+	});
+	pi.on("session_start", async (_event, ctx) => {
+		presets = load_prompt_presets(ctx.cwd);
+		active_base_name = void 0;
+		active_layers = /* @__PURE__ */ new Set();
+		const preset_flag = pi.getFlag("preset");
+		if (typeof preset_flag === "string" && preset_flag.trim()) {
+			for (const name of parse_preset_flag(preset_flag)) {
+				const preset = presets[name];
+				if (!preset) continue;
+				if (preset.kind === "base") active_base_name = name;
+				else active_layers.add(name);
+			}
+			const normalized = normalize_active_state(presets, active_base_name, active_layers);
+			active_base_name = normalized.active_base_name;
+			active_layers = normalized.active_layers;
+			set_status(ctx, active_base_name, active_layers);
+			return;
+		}
+		const restored = get_last_preset_state(ctx);
+		if (restored) {
+			active_base_name = restored.base_name ?? void 0;
+			active_layers = new Set(restored.layer_names ?? []);
+		}
+		const normalized = normalize_active_state(presets, active_base_name, active_layers);
+		active_base_name = normalized.active_base_name;
+		active_layers = normalized.active_layers;
+		set_status(ctx, active_base_name, active_layers);
+	});
+	pi.on("before_agent_start", async (event) => {
+		const blocks = [];
+		const base = get_base(active_base_name);
+		if (base?.instructions.trim()) blocks.push(`## Active Base Prompt: ${base.name}\n${base.instructions.trim()}`);
+		const layer_blocks = [...active_layers].sort().map((name) => presets[name]).filter((preset) => Boolean(preset?.instructions.trim())).map((preset) => `### ${preset.name}\n${preset.instructions.trim()}`);
+		if (layer_blocks.length > 0) blocks.push(`## Active Prompt Layers\n\n${layer_blocks.join("\n\n")}`);
+		if (blocks.length === 0) return;
+		return { systemPrompt: `${event.systemPrompt}\n\n${blocks.join("\n\n")}` };
+	});
+	pi.on("session_shutdown", async (_event, ctx) => {
+		ctx.ui.setStatus("preset", void 0);
+	});
+}
+//#endregion
 //#region src/extensions/recall.ts
 const DEFAULT_DB_PATH = join(process.env.HOME, ".pi", "pirecall.db");
 async function recall(pi) {
@@ -1845,7 +2499,8 @@ const BUILTIN_EXTENSION_FACTORIES = {
 	chain,
 	"filter-output": filter_output,
 	handoff,
-	recall
+	recall,
+	"prompt-presets": prompt_presets
 };
 const PACKAGE_THEME_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "themes");
 function get_force_disabled_builtins(options) {
@@ -1856,6 +2511,7 @@ function get_force_disabled_builtins(options) {
 	if (!options.filter_output) force_disabled.add("filter-output");
 	if (!options.handoff) force_disabled.add("handoff");
 	if (!options.recall) force_disabled.add("recall");
+	if (!options.prompt_presets) force_disabled.add("prompt-presets");
 	return force_disabled;
 }
 function create_builtin_extension_factory(key, extension, force_disabled) {
@@ -1877,7 +2533,7 @@ function create_extensions_override(managed_inline_paths) {
 	};
 }
 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 { cwd = process.cwd(), extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, model, system_prompt, append_system_prompt } = options;
 	const resolved_extensions = extensions.map((p) => resolve(cwd, p));
 	const force_disabled = get_force_disabled_builtins({
 		mcp,
@@ -1885,7 +2541,8 @@ async function create_my_pi(options = {}) {
 		chain,
 		filter_output,
 		handoff,
-		recall
+		recall,
+		prompt_presets
 	});
 	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}>`);
@@ -1899,6 +2556,8 @@ async function create_my_pi(options = {}) {
 			cwd: runtime_cwd,
 			...settings_manager ? { settingsManager: settings_manager } : {},
 			resourceLoaderOptions: {
+				...system_prompt !== void 0 ? { systemPromptOverride: () => system_prompt } : {},
+				...append_system_prompt !== void 0 ? { appendSystemPromptOverride: (base) => [...base, append_system_prompt] } : {},
 				additionalExtensionPaths: [...resolved_extensions],
 				additionalThemePaths: [PACKAGE_THEME_DIR],
 				extensionFactories: [...managed_extension_factories, ...user_factories],
@@ -1932,4 +2591,4 @@ async function create_my_pi(options = {}) {
 //#endregion
 export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
 
-//# sourceMappingURL=api-S06lPaJV.js.map
+//# sourceMappingURL=api-DtthDVIa.js.map