pi-prompt-template-model 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+## 2025-01-12
+
+**Print Mode Support**
+
+- Commands now work with `pi -p "/command args"` for scripting
+- Handler waits for agent to complete before returning
+
+**Thinking Level Control**
+
+- Added `thinking` frontmatter field to set thinking level per prompt
+- Valid levels: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`
+- Previous thinking level restored after response (when `restore: true`)
+- Thinking level shown in autocomplete: `[sonnet high]`
+
+**Skill Injection**
+
+- Added `skill` frontmatter field to inject skill content into system prompt
+- Skills resolved from project (`.pi/skills/`) first, then user (`~/.pi/agent/skills/`)
+- Skill content wrapped in `<skill name="...">` tags for clear context
+- Fancy TUI display: expandable box shows skill name, path, and truncated content preview
+
+**Subdirectory Support**
+
+- Prompts directory now scanned recursively
+- Subdirectories create namespaced commands shown as `(user:subdir)` or `(project:subdir)`
+- Example: `~/.pi/agent/prompts/frontend/component.md` → `/component (user:frontend)`
+
+**Documentation**
+
+- Expanded Model Format section with explicit provider selection examples
+- Added OpenAI vs OpenAI-Codex distinction (API key vs OAuth)
+- Documented auto-selection priority for models on multiple providers
+- Updated examples to use latest frontier models
+
+**Initial Release**
+
+- Model switching via `model` frontmatter in prompt templates
+- Auto-restore previous model after response (configurable via `restore: false`)
+- Provider resolution with priority fallback (anthropic → github-copilot → openrouter)
+- Support for explicit `provider/model-id` format

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nico Bailon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# Prompt Template Model Extension
+
+**Pi prompt templates on steroids.** Adds `model`, `skill`, and `thinking` frontmatter support. Create specialized agent modes that switch to the right model, set thinking level, and inject the right skill, then auto-restore when done.
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                                                                             │
+│  You're using Opus                                                          │
+│       │                                                                     │
+│       ▼                                                                     │
+│  /debug-python  ──►  Extension detects model + skill                        │
+│       │                                                                     │
+│       ▼                                                                     │
+│  Switches to Sonnet  ──►  Injects tmux skill into system prompt             │
+│       │                                                                     │
+│       ▼                                                                     │
+│  Agent responds with Sonnet + tmux expertise                                │
+│       │                                                                     │
+│       ▼                                                                     │
+│  agent_end fires  ──►  Restores Opus                                        │
+│       │                                                                     │
+│       ▼                                                                     │
+│  You're back on Opus                                                        │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+## Why?
+
+Create switchable agent "modes" with a single slash command. Each mode bundles:
+
+- **The right model** for the task complexity and cost tradeoff
+- **The right skill** so the agent knows exactly how to approach it
+- **Auto-restore** to your daily driver when done
+
+Instead of manually switching models and hoping the agent picks up on the right skill, you define prompt templates that configure both. `/quick-debug` spins up a cheap fast agent with REPL skills. `/deep-analysis` brings in the heavy hitter with refactoring expertise. Then you're back to your normal setup.
+
+## Installation
+
+```bash
+git clone https://github.com/nicobailon/pi-prompt-template-model.git ~/.pi/agent/extensions/pi-prompt-template-model
+```
+
+Pi auto-discovers extensions from `~/.pi/agent/extensions/*/index.ts`. Just restart pi.
+
+## Quick Start
+
+Add `model` and optionally `skill` to any prompt template:
+
+```markdown
+---
+description: Debug Python in tmux REPL
+model: claude-sonnet-4-20250514
+skill: tmux
+---
+Start a Python REPL session and help me debug: $@
+```
+
+Run `/debug-python some issue` and the agent has:
+- Sonnet as the active model
+- Full tmux skill instructions already loaded
+- Your task ready to go
+
+## Skills as a Cheat Code
+
+Normally, skills work like this: pi lists available skills in the system prompt, the agent sees your task, decides it needs a skill, and uses the read tool to load it. That's an extra round-trip, and the agent might not always pick the right one.
+
+With the `skill` field, you're forcing it:
+
+```markdown
+---
+description: Browser testing mode
+model: claude-sonnet-4-20250514
+skill: surf
+---
+$@
+```
+
+Here `skill: surf` loads `~/.pi/agent/skills/surf/SKILL.md` and injects its content directly into the system prompt before the agent even sees your task. No decision-making, no read tool, just immediate expertise. It's a forcing function for when you know exactly what workflow the agent needs.
+
+## Frontmatter Fields
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| `model` | Yes | - | Model ID or `provider/model-id` |
+| `skill` | No | - | Skill name to inject into system prompt |
+| `thinking` | No | - | Thinking level: `off`, `minimal`, `low`, `medium`, `high`, `xhigh` |
+| `description` | No | - | Shown in autocomplete |
+| `restore` | No | `true` | Restore previous model and thinking level after response |
+
+## Model Format
+
+```yaml
+model: claude-sonnet-4-20250514            # Model ID only - auto-selects provider
+model: anthropic/claude-sonnet-4-20250514  # Explicit provider/model
+```
+
+When you specify just the model ID, the extension picks a provider automatically based on where you have auth configured, preferring: `anthropic` → `github-copilot` → `openrouter`.
+
+For explicit control:
+
+```yaml
+model: anthropic/claude-opus-4-5        # Direct Anthropic API
+model: github-copilot/claude-opus-4-5   # Via Copilot subscription
+model: openrouter/claude-opus-4-5       # Via OpenRouter
+model: openai/gpt-5.2                   # Direct OpenAI API
+model: openai-codex/gpt-5.2             # Via Codex subscription (OAuth)
+```
+
+## Skill Resolution
+
+The `skill` field matches the skill's directory name:
+
+```yaml
+skill: tmux
+```
+
+Resolves to (checked in order):
+1. `<cwd>/.pi/skills/tmux/SKILL.md` (project)
+2. `~/.pi/agent/skills/tmux/SKILL.md` (user)
+
+This matches pi's precedence - project skills override user skills.
+
+## Subdirectories
+
+Organize prompts in subdirectories for namespacing:
+
+```
+~/.pi/agent/prompts/
+├── quick.md                    → /quick (user)
+├── debug-python.md             → /debug-python (user)
+└── frontend/
+    ├── component.md            → /component (user:frontend)
+    └── hook.md                 → /hook (user:frontend)
+```
+
+The subdirectory shows in autocomplete as the source label. Note: command names are based on filename only, so avoid duplicate filenames across subdirectories (e.g., `quick.md` and `frontend/quick.md` would collide).
+
+## Examples
+
+**Cost optimization** - use Haiku for simple summarization:
+
+```markdown
+---
+description: Save progress doc for handoff
+model: claude-haiku-4-5
+---
+Create a progress document that captures everything needed for another 
+engineer to continue this work. Save to ~/Documents/docs/...
+```
+
+**Skill injection** - guarantee the agent has REPL expertise:
+
+```markdown
+---
+description: Python debugging session
+model: claude-sonnet-4-20250514
+skill: tmux
+---
+Start a Python REPL and help me debug: $@
+```
+
+**Browser automation** - pair surf skill with a capable model:
+
+```markdown
+---
+description: Test user flow in browser
+model: claude-sonnet-4-20250514
+skill: surf
+---
+Test this user flow: $@
+```
+
+**Deep thinking** - max thinking for complex analysis:
+
+```markdown
+---
+description: Deep code analysis with extended thinking
+model: claude-sonnet-4-20250514
+thinking: high
+---
+Analyze this code thoroughly, considering edge cases and potential issues: $@
+```
+
+**Mode switching** - stay on the new model:
+
+```markdown
+---
+description: Switch to Haiku for this session
+model: claude-haiku-4-5
+restore: false
+---
+Switched to Haiku. How can I help?
+```
+
+## Autocomplete Display
+
+Commands show model, thinking level, and skill in the description:
+
+```
+/debug-python    Debug Python session [sonnet +tmux] (user)
+/deep-analysis   Deep code analysis [sonnet high] (user)
+/component       Create React component [sonnet] (user:frontend)
+/quick           Quick answer [haiku] (user)
+```
+
+## Print Mode (`pi -p`)
+
+These commands work in print mode too:
+
+```bash
+pi -p "/debug-python my code crashes on line 42"
+```
+
+The model switches, skill injects, agent responds, and output prints to stdout. Useful for scripting or piping to other tools.
+
+## Limitations
+
+- Templates discovered at startup. Restart pi after adding/modifying.
+- Model restore state is in-memory. Closing pi mid-response loses restore state.

package/index.ts

@@ -0,0 +1,598 @@
+/**
+ * Prompt Model Extension
+ *
+ * Adds support for `model`, `skill`, and `thinking` frontmatter in prompt template .md files.
+ * Create specialized agent modes that switch to the right model, set thinking level,
+ * and inject the right skill, then auto-restore when done.
+ *
+ * ┌─────────────────────────────────────────────────────────────────────────────┐
+ * │                                                                             │
+ * │  You're using Opus                                                          │
+ * │       │                                                                     │
+ * │       ▼                                                                     │
+ * │  /debug-python  ──►  Extension detects model + skill frontmatter            │
+ * │       │                                                                     │
+ * │       ▼                                                                     │
+ * │  Switches to Sonnet  ──►  Stores "Opus" as previous model                   │
+ * │       │                                                                     │
+ * │       ▼                                                                     │
+ * │  before_agent_start  ──►  Injects tmux skill into system prompt             │
+ * │       │                                                                     │
+ * │       ▼                                                                     │
+ * │  Agent responds with Sonnet + tmux expertise                                │
+ * │       │                                                                     │
+ * │       ▼                                                                     │
+ * │  agent_end fires  ──►  Restores Opus  ──►  Shows "Restored to opus" notif   │
+ * │       │                                                                     │
+ * │       ▼                                                                     │
+ * │  You're back on Opus                                                        │
+ * │                                                                             │
+ * └─────────────────────────────────────────────────────────────────────────────┘
+ *
+ * Prompt template locations:
+ * - ~/.pi/agent/prompts/**\/*.md (global, recursive)
+ * - <cwd>/.pi/prompts/**\/*.md (project-local, recursive)
+ *
+ * Skill locations (checked in order):
+ * - <cwd>/.pi/skills/{name}/SKILL.md (project)
+ * - ~/.pi/agent/skills/{name}/SKILL.md (user)
+ *
+ * Example prompt file (e.g., ~/.pi/agent/prompts/debug-python.md):
+ * ```markdown
+ * ---
+ * description: Debug Python in tmux REPL
+ * model: claude-sonnet-4-20250514
+ * skill: tmux
+ * ---
+ * Start a Python REPL session and help me debug: $@
+ * ```
+ *
+ * Frontmatter fields:
+ * - `description`: Description shown in autocomplete (standard)
+ * - `model`: Model ID (e.g., "claude-sonnet-4-20250514") or full "provider/model-id"
+ * - `skill`: Skill name to inject into system prompt (e.g., "tmux")
+ * - `thinking`: Thinking level (off, minimal, low, medium, high, xhigh)
+ * - `restore`: Whether to restore the previous model/thinking after response (default: true)
+ *
+ * Usage:
+ * - `/debug-python my code is broken` - switches model, injects skill, runs prompt
+ *
+ * Notes:
+ * - Templates without `model` frontmatter work normally (handled by pi core)
+ * - Skills are injected via the before_agent_start hook into the system prompt
+ * - Subdirectories create namespaced commands shown as (user:subdir) or (project:subdir)
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import type { Model } from "@mariozechner/pi-ai";
+import type { ExtensionAPI, ExtensionContext, MessageRenderOptions } from "@mariozechner/pi-coding-agent";
+import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
+import { Box, Text, Spacer, Container } from "@mariozechner/pi-tui";
+import type { Theme } from "@mariozechner/pi-coding-agent";
+
+const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+interface PromptWithModel {
+	name: string;
+	description: string;
+	content: string;
+	model: string;
+	restore: boolean;
+	skill?: string;
+	thinking?: ThinkingLevel;
+	source: "user" | "project";
+	subdir?: string;
+}
+
+/**
+ * Parse YAML frontmatter from markdown content.
+ */
+function parseFrontmatter(content: string): { frontmatter: Record<string, string>; content: string } {
+	const frontmatter: Record<string, string> = {};
+	const normalized = content.replace(/\r\n/g, "\n");
+
+	if (!normalized.startsWith("---")) {
+		return { frontmatter, content: normalized };
+	}
+
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) {
+		return { frontmatter, content: normalized };
+	}
+
+	const frontmatterBlock = normalized.slice(4, endIndex);
+	const body = normalized.slice(endIndex + 4).trim();
+
+	for (const line of frontmatterBlock.split("\n")) {
+		const match = line.match(/^([\w-]+):\s*(.*)$/);
+		if (match) {
+			let value = match[2].trim();
+			if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+				value = value.slice(1, -1);
+			}
+			frontmatter[match[1]] = value;
+		}
+	}
+
+	return { frontmatter, content: body };
+}
+
+/**
+ * Parse command arguments respecting quoted strings.
+ */
+function parseCommandArgs(argsString: string): string[] {
+	const args: string[] = [];
+	let current = "";
+	let inQuote: string | null = null;
+
+	for (let i = 0; i < argsString.length; i++) {
+		const char = argsString[i];
+
+		if (inQuote) {
+			if (char === inQuote) {
+				inQuote = null;
+			} else {
+				current += char;
+			}
+		} else if (char === '"' || char === "'") {
+			inQuote = char;
+		} else if (char === " " || char === "\t") {
+			if (current) {
+				args.push(current);
+				current = "";
+			}
+		} else {
+			current += char;
+		}
+	}
+
+	if (current) {
+		args.push(current);
+	}
+
+	return args;
+}
+
+/**
+ * Substitute argument placeholders in template content.
+ */
+function substituteArgs(content: string, args: string[]): string {
+	let result = content;
+
+	// Replace $1, $2, etc. with positional args
+	result = result.replace(/\$(\d+)/g, (_, num) => {
+		const index = parseInt(num, 10) - 1;
+		return args[index] ?? "";
+	});
+
+	const allArgs = args.join(" ");
+
+	// Replace $ARGUMENTS and $@ with all args
+	result = result.replace(/\$ARGUMENTS/g, allArgs);
+	result = result.replace(/\$@/g, allArgs);
+
+	return result;
+}
+
+/**
+ * Resolve skill path from name. Checks project first, then user.
+ */
+function resolveSkillPath(skillName: string, cwd: string): string | undefined {
+	// Project skills first
+	const projectPath = resolve(cwd, ".pi", "skills", skillName, "SKILL.md");
+	if (existsSync(projectPath)) return projectPath;
+
+	// Fall back to user skills
+	const userPath = join(homedir(), ".pi", "agent", "skills", skillName, "SKILL.md");
+	if (existsSync(userPath)) return userPath;
+
+	return undefined;
+}
+
+/**
+ * Read skill content, stripping frontmatter.
+ */
+function readSkillContent(skillPath: string): string | undefined {
+	try {
+		const raw = readFileSync(skillPath, "utf-8");
+		const { content } = parseFrontmatter(raw);
+		return content;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Load prompt templates that have model frontmatter from a directory.
+ * Recursively scans subdirectories.
+ */
+function loadPromptsWithModelFromDir(
+	dir: string,
+	source: "user" | "project",
+	subdir = ""
+): PromptWithModel[] {
+	const prompts: PromptWithModel[] = [];
+
+	if (!existsSync(dir)) {
+		return prompts;
+	}
+
+	try {
+		const entries = readdirSync(dir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+
+			// Handle symlinks
+			let isFile = entry.isFile();
+			let isDirectory = entry.isDirectory();
+			if (entry.isSymbolicLink()) {
+				try {
+					const stats = statSync(fullPath);
+					isFile = stats.isFile();
+					isDirectory = stats.isDirectory();
+				} catch {
+					continue;
+				}
+			}
+
+			// Recurse into subdirectories
+			if (isDirectory) {
+				const newSubdir = subdir ? `${subdir}:${entry.name}` : entry.name;
+				prompts.push(...loadPromptsWithModelFromDir(fullPath, source, newSubdir));
+				continue;
+			}
+
+			if (!isFile || !entry.name.endsWith(".md")) continue;
+
+			try {
+				const rawContent = readFileSync(fullPath, "utf-8");
+				const { frontmatter, content: body } = parseFrontmatter(rawContent);
+
+				// Only include templates that have a model field
+				if (!frontmatter.model) continue;
+
+				const name = entry.name.slice(0, -3); // Remove .md
+
+				// Parse restore field (default: true)
+				const restore = frontmatter.restore?.toLowerCase() !== "false";
+
+				// Parse thinking level if valid
+				const thinkingRaw = frontmatter.thinking?.toLowerCase();
+				const validThinking = thinkingRaw && (VALID_THINKING_LEVELS as readonly string[]).includes(thinkingRaw)
+					? thinkingRaw as ThinkingLevel
+					: undefined;
+
+				prompts.push({
+					name,
+					description: frontmatter.description || "",
+					content: body,
+					model: frontmatter.model,
+					restore,
+					skill: frontmatter.skill || undefined,
+					thinking: validThinking,
+					source,
+					subdir: subdir || undefined,
+				});
+			} catch {
+				// Skip files that can't be read or parsed
+			}
+		}
+	} catch {
+		// Skip directories that can't be read
+	}
+
+	return prompts;
+}
+
+/**
+ * Load all prompt templates with model frontmatter.
+ * Project templates override global templates with the same name.
+ */
+function loadPromptsWithModel(cwd: string): Map<string, PromptWithModel> {
+	const globalDir = join(homedir(), ".pi", "agent", "prompts");
+	const projectDir = resolve(cwd, ".pi", "prompts");
+
+	const promptMap = new Map<string, PromptWithModel>();
+
+	// Load global first
+	for (const prompt of loadPromptsWithModelFromDir(globalDir, "user")) {
+		promptMap.set(prompt.name, prompt);
+	}
+
+	// Project overrides global
+	for (const prompt of loadPromptsWithModelFromDir(projectDir, "project")) {
+		promptMap.set(prompt.name, prompt);
+	}
+
+	return promptMap;
+}
+
+/** Details for skill-loaded custom message */
+interface SkillLoadedDetails {
+	skillName: string;
+	skillContent: string;
+	skillPath: string;
+}
+
+/** Max lines to show when collapsed */
+const SKILL_PREVIEW_LINES = 5;
+
+/**
+ * Render the skill-loaded message with expandable content
+ */
+function renderSkillLoaded(
+	message: { details?: SkillLoadedDetails },
+	options: MessageRenderOptions,
+	theme: Theme
+) {
+	const { skillName, skillContent, skillPath } = message.details!;
+	const container = new Container();
+	
+	container.addChild(new Spacer(1));
+	
+	const box = new Box(1, 1, (t: string) => theme.bg("toolSuccessBg", t));
+	
+	// Header with skill name
+	const header = theme.fg("toolTitle", theme.bold(`⚡ Skill loaded: ${skillName}`));
+	box.addChild(new Text(header, 0, 0));
+	
+	// Show path in muted color
+	const pathLine = theme.fg("toolOutput", `   ${skillPath}`);
+	box.addChild(new Text(pathLine, 0, 0));
+	box.addChild(new Spacer(1));
+	
+	// Content preview or full content
+	const lines = skillContent.split("\n");
+	
+	if (options.expanded) {
+		// Show full content
+		const content = lines.map(line => theme.fg("toolOutput", line)).join("\n");
+		box.addChild(new Text(content, 0, 0));
+	} else {
+		// Show truncated preview
+		const previewLines = lines.slice(0, SKILL_PREVIEW_LINES);
+		const remaining = lines.length - SKILL_PREVIEW_LINES;
+		
+		const preview = previewLines.map(line => theme.fg("toolOutput", line)).join("\n");
+		box.addChild(new Text(preview, 0, 0));
+		
+		if (remaining > 0) {
+			box.addChild(new Text(theme.fg("warning", `\n... (${remaining} more lines)`), 0, 0));
+		}
+	}
+	
+	container.addChild(box);
+	return container;
+}
+
+export default function promptModelExtension(pi: ExtensionAPI) {
+	let prompts = new Map<string, PromptWithModel>();
+	let previousModel: Model<any> | undefined;
+	let previousThinking: ThinkingLevel | undefined;
+	let pendingSkill: { name: string; cwd: string } | undefined;
+	
+	// Register custom message renderer for skill-loaded messages
+	pi.registerMessageRenderer<SkillLoadedDetails>("skill-loaded", renderSkillLoaded);
+
+	/**
+	 * Find and resolve a model from "provider/model-id" or just "model-id".
+	 * If no provider is specified, searches all models by ID.
+	 * Prefers models with auth, then by provider priority: anthropic > github-copilot > openrouter.
+	 */
+	function resolveModel(modelSpec: string, ctx: ExtensionContext): Model<any> | undefined {
+		const slashIndex = modelSpec.indexOf("/");
+
+		if (slashIndex !== -1) {
+			// Has provider: use exact match
+			const provider = modelSpec.slice(0, slashIndex);
+			const modelId = modelSpec.slice(slashIndex + 1);
+
+			if (!provider || !modelId) {
+				ctx.ui.notify(`Invalid model format "${modelSpec}". Expected "provider/model-id"`, "error");
+				return undefined;
+			}
+
+			const model = ctx.modelRegistry.find(provider, modelId);
+			if (!model) {
+				ctx.ui.notify(`Model "${modelSpec}" not found`, "error");
+				return undefined;
+			}
+			return model;
+		}
+
+		// No provider: search all models by ID
+		const allMatches = ctx.modelRegistry.getAll().filter((m) => m.id === modelSpec);
+
+		if (allMatches.length === 0) {
+			ctx.ui.notify(`Model "${modelSpec}" not found`, "error");
+			return undefined;
+		}
+
+		if (allMatches.length === 1) {
+			return allMatches[0];
+		}
+
+		// Multiple matches - prefer models with auth configured
+		const availableMatches = ctx.modelRegistry.getAvailable().filter((m) => m.id === modelSpec);
+
+		if (availableMatches.length === 1) {
+			return availableMatches[0];
+		}
+
+		if (availableMatches.length > 1) {
+			// Multiple with auth - prefer by provider priority
+			const preferredProviders = ["anthropic", "github-copilot", "openrouter"];
+			for (const provider of preferredProviders) {
+				const preferred = availableMatches.find((m) => m.provider === provider);
+				if (preferred) {
+					return preferred;
+				}
+			}
+			// No preferred provider found, use first available
+			return availableMatches[0];
+		}
+
+		// No matches with auth - show all options
+		const options = allMatches.map((m) => `${m.provider}/${m.id}`).join(", ");
+		ctx.ui.notify(`Ambiguous model "${modelSpec}". Options: ${options}`, "error");
+		return undefined;
+	}
+
+	// Reload prompts on session start (in case cwd changed)
+	pi.on("session_start", async (_event, ctx) => {
+		prompts = loadPromptsWithModel(ctx.cwd);
+	});
+
+	// Inject skill into system prompt before agent starts
+	pi.on("before_agent_start", async (event, ctx) => {
+		if (!pendingSkill) {
+			return;
+		}
+
+		const { name: skillName, cwd } = pendingSkill;
+		pendingSkill = undefined;
+
+		const skillPath = resolveSkillPath(skillName, cwd);
+		if (!skillPath) {
+			ctx.ui.notify(`Skill "${skillName}" not found`, "error");
+			return;
+		}
+
+		const skillContent = readSkillContent(skillPath);
+		if (skillContent === undefined) {
+			ctx.ui.notify(`Failed to read skill "${skillName}"`, "error");
+			return;
+		}
+
+		// Send a custom message to display the skill loaded notification
+		pi.sendMessage<SkillLoadedDetails>({
+			customType: "skill-loaded",
+			content: `Loaded skill: ${skillName}`,
+			display: true,
+			details: {
+				skillName,
+				skillContent,
+				skillPath,
+			},
+		});
+
+		// Append skill to system prompt wrapped in <skill> tags
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n<skill name="${skillName}">\n${skillContent}\n</skill>`,
+		};
+	});
+
+	// Restore model and thinking level after the agent finishes responding
+	pi.on("agent_end", async (_event, ctx) => {
+		const restoredParts: string[] = [];
+
+		if (previousModel) {
+			restoredParts.push(previousModel.id);
+			await pi.setModel(previousModel);
+			previousModel = undefined;
+		}
+
+		if (previousThinking !== undefined) {
+			restoredParts.push(`thinking:${previousThinking}`);
+			pi.setThinkingLevel(previousThinking);
+			previousThinking = undefined;
+		}
+
+		if (restoredParts.length > 0) {
+			ctx.ui.notify(`Restored to ${restoredParts.join(", ")}`, "info");
+		}
+	});
+
+	// Initialize: register commands for prompts with model frontmatter
+	const initialCwd = process.cwd();
+	const initialPrompts = loadPromptsWithModel(initialCwd);
+
+	for (const [name, prompt] of initialPrompts) {
+		// Build source label with subdir namespace
+		let sourceLabel: string;
+		if (prompt.subdir) {
+			sourceLabel = `(${prompt.source}:${prompt.subdir})`;
+		} else {
+			sourceLabel = `(${prompt.source})`;
+		}
+
+		// Build model label (short form)
+		const modelLabel = prompt.model.split("/").pop() || prompt.model;
+
+		// Build skill label if present
+		const skillLabel = prompt.skill ? ` +${prompt.skill}` : "";
+
+		// Build thinking label if present
+		const thinkingLabel = prompt.thinking ? ` ${prompt.thinking}` : "";
+
+		pi.registerCommand(name, {
+			description: prompt.description
+				? `${prompt.description} [${modelLabel}${thinkingLabel}${skillLabel}] ${sourceLabel}`
+				: `[${modelLabel}${thinkingLabel}${skillLabel}] ${sourceLabel}`,
+
+			handler: async (args, ctx) => {
+				// Re-fetch the prompt in case it was updated
+				const currentPrompt = prompts.get(name);
+				if (!currentPrompt) {
+					ctx.ui.notify(`Prompt "${name}" no longer exists`, "error");
+					return;
+				}
+
+				// Resolve the model
+				const model = resolveModel(currentPrompt.model, ctx);
+				if (!model) return;
+
+				// Check if we're already on the target model (skip switch)
+				const alreadyOnTargetModel = ctx.model?.provider === model.provider && ctx.model?.id === model.id;
+
+				if (!alreadyOnTargetModel) {
+					// Store previous model to restore after response (only if restore is enabled)
+					if (currentPrompt.restore) {
+						previousModel = ctx.model;
+					}
+
+					// Switch to the specified model
+					const success = await pi.setModel(model);
+					if (!success) {
+						ctx.ui.notify(`No API key for model "${currentPrompt.model}"`, "error");
+						previousModel = undefined;
+						return;
+					}
+				}
+
+				// Set thinking level if specified
+				if (currentPrompt.thinking) {
+					const currentThinking = pi.getThinkingLevel();
+					if (currentThinking !== currentPrompt.thinking) {
+						if (currentPrompt.restore) {
+							previousThinking = currentThinking;
+						}
+						pi.setThinkingLevel(currentPrompt.thinking);
+					}
+				}
+
+				// Set pending skill for before_agent_start handler
+				if (currentPrompt.skill) {
+					pendingSkill = { name: currentPrompt.skill, cwd: ctx.cwd };
+				}
+
+				// Expand the template with arguments
+				const parsedArgs = parseCommandArgs(args);
+				const expandedContent = substituteArgs(currentPrompt.content, parsedArgs);
+
+				// Send the expanded prompt as a user message
+				pi.sendUserMessage(expandedContent);
+
+				// Wait for agent to start processing, then wait for it to finish
+				// (required for print mode, harmless in interactive)
+				while (ctx.isIdle()) {
+					await new Promise(resolve => setTimeout(resolve, 10));
+				}
+				await ctx.waitForIdle();
+			},
+		});
+	}
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "pi-prompt-template-model",
+  "version": "0.1.0",
+  "description": "Prompt template model selector extension for pi coding agent",
+  "author": "Nico Bailon",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nicobailon/pi-prompt-template-model.git"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "coding-agent",
+    "prompt-template",
+    "model-selector",
+    "extension"
+  ],
+  "files": [
+    "index.ts",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}