pi-prompt-template-model 0.9.3 → 0.10.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-07-01
+
+### Changed
+- Updated local Pi development dependencies to `@earendil-works/*` `0.80.3` and declared Pi core packages plus `typebox` as peer dependencies for package installs.
+
+### Fixed
+- Inline prompt templates with `restore: true` now restore the previous model and thinking level on the prompt turn's `agent_end`, instead of one unrelated user turn later.
+- Idle `agent_end` events now skip context/model reads when there is no pending restore state or queued `run-prompt` command.
+- Prompt commands now initialize from the active session cwd instead of `process.cwd()`, and extension-owned Pi paths use Pi's current config-directory helpers.
+- Delegated prompt execution now uses the loaded `pi-subagents` event bridge instead of importing `pi-subagents` internals for agent discovery.
+- Prompt templates listed in user or project `settings.json` `prompts` paths now receive this extension's frontmatter handling, including `model`, `thinking`, and `skill`.
+
 ## [0.9.3] - 2026-04-28
 
 ### Fixed

package/README.md

@@ -49,6 +49,19 @@ Start a Python REPL session and help me debug: $@
 
 Run `/debug-python some issue` and the agent switches to Sonnet, receives the tmux skill as context, and starts working. When it finishes, your previous model is restored.
 
+## Prompt Discovery
+
+The extension scans the default prompt directories and the same local prompt paths Pi loads from `settings.json`:
+
+- User defaults: `~/.pi/agent/prompts/`
+- Project defaults: `<cwd>/.pi/prompts/`
+- User settings: `~/.pi/agent/settings.json` `prompts` entries
+- Project settings: `<cwd>/.pi/settings.json` `prompts` entries
+
+Settings entries may point at directories or individual `.md` files. Absolute paths and `~/...` work. Relative user settings paths resolve from `~/.pi/agent`; relative project settings paths resolve from `<cwd>/.pi`. Pattern entries follow Pi's settings behavior: glob-style entries filter configured prompt paths, and `!`, `+`, or `-` entries exclude or force exact matches.
+
+Precedence follows Pi's local-resource order: project settings, project defaults, user settings, then user defaults. If the same file is reachable through both settings and a default directory, it is loaded once by canonical path. Malformed settings files or invalid configured paths produce warnings while the rest of discovery continues.
+
 ## Frontmatter Reference
 
 All fields are optional. Templates that don't use any extension features (no `model`, `skill`, `thinking`, etc.) are left to pi's default prompt loader.

package/chain-parser.ts

@@ -1,4 +1,4 @@
-import { parseCommandArgs } from "./args.js";
+import { parseCommandArgs } from "./args.ts";
 
 export interface ChainStep {
 	name: string;

package/deterministic-renderer.ts

@@ -1,6 +1,6 @@
-import type { MessageRenderOptions, Theme } from "@mariozechner/pi-coding-agent";
-import { Box, Container, Spacer, Text } from "@mariozechner/pi-tui";
-import { formatDeterministicExecution, type DeterministicExecutionResult } from "./deterministic-step.js";
+import type { MessageRenderOptions, Theme } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { formatDeterministicExecution, type DeterministicExecutionResult } from "./deterministic-step.ts";
 
 interface DeterministicMessage {
 	content?: unknown;

package/deterministic-step.ts

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
-import type { PromptWithModel, DeterministicStep, DeterministicExecution, DeterministicEnv } from "./prompt-loader.js";
+import type { PromptWithModel, DeterministicStep, DeterministicExecution, DeterministicEnv } from "./prompt-loader.ts";
 
 export const PROMPT_TEMPLATE_DETERMINISTIC_MESSAGE_TYPE = "prompt-template-deterministic";
 export const PROMPT_TEMPLATE_DETERMINISTIC_COMPLETION_MESSAGE_TYPE = "prompt-template-deterministic-complete";

package/index.ts

@@ -1,8 +1,8 @@
 import { existsSync } from "node:fs";
 import { resolve as resolvePath } from "node:path";
-import type { Model } from "@mariozechner/pi-ai";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import {
 	extractChainContextFlag,
 	extractLineupOverrides,
@@ -14,12 +14,12 @@ import {
 	substituteArgs,
 	type LineupOverrideAction,
 	type SubagentOverride,
-} from "./args.js";
-import { parseChainSteps, parseChainDeclaration, type ChainStep, type ChainStepOrParallel, type ParallelChainStep } from "./chain-parser.js";
-import { generateBoomerangSummary, generateChainStepSummary, generateIterationSummary, didIterationMakeChanges, getIterationEntries, wasIterationAborted } from "./loop-utils.js";
-import { selectModelCandidate } from "./model-selection.js";
-import { notify, summarizePromptDiagnostics, diagnosticsFingerprint } from "./notifications.js";
-import { preparePromptExecution, renderPromptForResolvedModel } from "./prompt-execution.js";
+} from "./args.ts";
+import { parseChainSteps, parseChainDeclaration, type ChainStep, type ChainStepOrParallel, type ParallelChainStep } from "./chain-parser.ts";
+import { generateBoomerangSummary, generateChainStepSummary, generateIterationSummary, didIterationMakeChanges, getIterationEntries, wasIterationAborted } from "./loop-utils.ts";
+import { selectModelCandidate } from "./model-selection.ts";
+import { notify, summarizePromptDiagnostics, diagnosticsFingerprint } from "./notifications.ts";
+import { preparePromptExecution, renderPromptForResolvedModel } from "./prompt-execution.ts";
 import {
 	buildPromptCommandDescription,
 	expandCwdPath,
@@ -28,20 +28,20 @@ import {
 	resolveSkillPath,
 	type DelegationLineupSlot,
 	type PromptWithModel,
-} from "./prompt-loader.js";
-import { renderSkillLoaded, type SkillLoadedDetails } from "./skill-loaded-renderer.js";
-import { createToolManager } from "./tool-manager.js";
-import { executeSubagentPromptStep, type DelegatedPromptParallelResult } from "./subagent-step.js";
-import { DEFAULT_SUBAGENT_NAME, PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE } from "./subagent-runtime.js";
-import { renderDelegatedSubagentResult } from "./subagent-renderer.js";
+} from "./prompt-loader.ts";
+import { renderSkillLoaded, type SkillLoadedDetails } from "./skill-loaded-renderer.ts";
+import { createToolManager } from "./tool-manager.ts";
+import { executeSubagentPromptStep, type DelegatedPromptParallelResult } from "./subagent-step.ts";
+import { DEFAULT_SUBAGENT_NAME, PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE } from "./subagent-runtime.ts";
+import { renderDelegatedSubagentResult } from "./subagent-renderer.ts";
 import {
 	PROMPT_TEMPLATE_DETERMINISTIC_COMPLETION_MESSAGE_TYPE,
 	PROMPT_TEMPLATE_DETERMINISTIC_MESSAGE_TYPE,
 	buildDeterministicPreamble,
 	runDeterministicStep,
 	shouldHandoffToLlm,
-} from "./deterministic-step.js";
-import { renderDeterministicCompletion, renderDeterministicResult } from "./deterministic-renderer.js";
+} from "./deterministic-step.ts";
+import { renderDeterministicCompletion, renderDeterministicResult } from "./deterministic-renderer.ts";
 
 interface LoopState {
 	currentIteration: number;
@@ -84,6 +84,11 @@ interface PromptStepResult {
 	text?: string;
 }
 
+interface PromptTurnRestore {
+	originalModel: Model<any> | undefined;
+	originalThinking: ThinkingLevel | undefined;
+}
+
 const DEFAULT_COMPARE_REVIEWER_TASK = [
 	"Review the worker variants and produce findings only.",
 	"Required output:",
@@ -264,6 +269,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		inheritedModel?: Model<any>,
 		taskPreamble?: string,
 		loopContext?: string,
+		promptTurnRestore?: PromptTurnRestore,
 	): Promise<PromptStepResult | "aborted"> {
 		let deterministicPreamble: string | undefined;
 		if (prompt.deterministic) {
@@ -377,6 +383,17 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		}
 		pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : undefined;
 
+		if (promptTurnRestore) {
+			const currentModel = getCurrentModel(ctx);
+			if (promptTurnRestore.originalModel && currentModel && !sameModel(promptTurnRestore.originalModel, currentModel)) {
+				previousModel = promptTurnRestore.originalModel;
+				previousThinking = promptTurnRestore.originalThinking;
+			}
+			if (prompt.thinking && previousThinking === undefined && prompt.thinking !== promptTurnRestore.originalThinking) {
+				previousThinking = promptTurnRestore.originalThinking;
+			}
+		}
+
 		const startId = ctx.sessionManager.getLeafId();
 		const effectiveContent = combinedTaskPreamble
 			? `${combinedTaskPreamble}\n\n${prepared.content}`
@@ -1587,6 +1604,10 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		};
 		const savedModel = getCurrentModel(ctx);
 		const savedThinking = pi.getThinkingLevel();
+		const isDelegatedPrompt = shouldDelegatePrompt(effectivePrompt, subagent.override);
+		const promptTurnRestore = !isDelegatedPrompt && prompt.restore
+			? { originalModel: savedModel, originalThinking: savedThinking }
+			: undefined;
 		const boomerangTargetId = effectivePrompt.boomerang ? ctx.sessionManager.getLeafId() : null;
 		const stepResult = await executePromptStep(
 			effectivePrompt,
@@ -1594,25 +1615,18 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			ctx,
 			savedModel,
 			subagent.override,
+			undefined,
+			undefined,
+			undefined,
+			promptTurnRestore,
 		);
 		if (stepResult === "aborted") return;
-		if (shouldDelegatePrompt(effectivePrompt, subagent.override) && stepResult.text) {
+		if (isDelegatedPrompt && stepResult.text) {
 			pi.sendUserMessage(`[Delegated result: ${name}]\n\n${stepResult.text}`);
 			await waitForTurnStart(ctx);
 			await ctx.waitForIdle();
 		}
 
-		if (!shouldDelegatePrompt(effectivePrompt, subagent.override) && prompt.restore) {
-			const currentModel = getCurrentModel(ctx);
-			if (savedModel && currentModel && !sameModel(savedModel, currentModel)) {
-				previousModel = savedModel;
-				previousThinking = savedThinking;
-			}
-			if (effectivePrompt.thinking && previousThinking === undefined && effectivePrompt.thinking !== savedThinking) {
-				previousThinking = savedThinking;
-			}
-		}
-
 		if (effectivePrompt.boomerang) {
 			await collapseBoomerangPrompt(ctx, name, boomerangTargetId);
 		}
@@ -1670,10 +1684,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		if (chainActive) return;
 		if (loopState) return;
 
-		runtimeModel = ctx.model;
-
 		const restoreModel = previousModel;
 		const restoreThinking = previousThinking;
+		if (!restoreModel && restoreThinking === undefined && !toolManager.hasQueuedCommand()) return;
+
+		runtimeModel = ctx.model;
+
 		previousModel = undefined;
 		previousThinking = undefined;
 
@@ -1756,7 +1772,6 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		);
 	}
 
-	refreshPrompts(process.cwd());
 	if (toolManager.isEnabled()) toolManager.ensureRegistered();
 
 	pi.registerCommand("chain-prompts", {

package/loop-utils.ts

@@ -1,6 +1,6 @@
-import type { AssistantMessage, Message } from "@mariozechner/pi-ai";
-import type { ExtensionContext, SessionEntry } from "@mariozechner/pi-coding-agent";
-import { PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE } from "./subagent-runtime.js";
+import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
+import type { ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import { PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE } from "./subagent-runtime.ts";
 
 interface DelegatedMessageDetails {
 	messages?: Message[];

package/model-selection.ts

@@ -1,5 +1,5 @@
-import type { Model } from "@mariozechner/pi-ai";
-import type { ResolvedModelRef } from "./template-conditionals.js";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ResolvedModelRef } from "./template-conditionals.ts";
 
 const PREFERRED_PROVIDERS = ["openai-codex", "anthropic", "github-copilot", "openrouter"];
 

package/notifications.ts

@@ -1,5 +1,5 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { PromptLoaderDiagnostic } from "./prompt-loader.js";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { PromptLoaderDiagnostic } from "./prompt-loader.ts";
 
 export function notify(
 	ctx: Pick<ExtensionContext, "hasUI" | "ui"> | undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-prompt-template-model",
-  "version": "0.9.3",
+  "version": "0.10.0",
   "type": "module",
   "description": "Prompt template model selector extension for pi coding agent",
   "author": "Nico Bailon",
@@ -49,15 +49,20 @@
   "scripts": {
     "test": "tsx --test test/**/*.test.ts"
   },
-  "dependencies": {
-    "typebox": "^1.1.24"
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "devDependencies": {
-    "@mariozechner/pi-agent-core": "^0.65.0",
-    "@mariozechner/pi-ai": "^0.65.0",
-    "@mariozechner/pi-coding-agent": "^0.65.0",
-    "@mariozechner/pi-tui": "^0.65.0",
-    "tsx": "^4.20.5"
+    "@earendil-works/pi-agent-core": "^0.80.3",
+    "@earendil-works/pi-ai": "^0.80.3",
+    "@earendil-works/pi-coding-agent": "^0.80.3",
+    "@earendil-works/pi-tui": "^0.80.3",
+    "tsx": "^4.22.4",
+    "typebox": "^1.3.2"
   },
   "pi": {
     "extensions": [
@@ -66,5 +71,8 @@
     "skills": [
       "./skills"
     ]
+  },
+  "dependencies": {
+    "minimatch": "^10.2.5"
   }
 }

package/prompt-execution.ts

@@ -1,8 +1,8 @@
-import type { Model } from "@mariozechner/pi-ai";
-import { substituteArgs } from "./args.js";
-import { getResolvedModelRef, selectModelCandidate, type RegistryLike, type SelectedModelCandidate } from "./model-selection.js";
-import type { PromptWithModel } from "./prompt-loader.js";
-import { renderTemplateConditionals } from "./template-conditionals.js";
+import type { Model } from "@earendil-works/pi-ai";
+import { substituteArgs } from "./args.ts";
+import { getResolvedModelRef, selectModelCandidate, type RegistryLike, type SelectedModelCandidate } from "./model-selection.ts";
+import type { PromptWithModel } from "./prompt-loader.ts";
+import { renderTemplateConditionals } from "./template-conditionals.ts";
 
 export interface PreparedPromptExecution {
 	selectedModel: SelectedModelCandidate;

package/prompt-loader.ts

@@ -1,9 +1,10 @@
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
-import { parseFrontmatter } from "@mariozechner/pi-coding-agent";
-import { parseChainDeclaration } from "./chain-parser.js";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { minimatch } from "minimatch";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import { CONFIG_DIR_NAME, getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { parseChainDeclaration } from "./chain-parser.ts";
 
 const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 export const RESERVED_COMMAND_NAMES = new Set([
@@ -1343,12 +1344,201 @@ function normalizeThinkingLevels(
 	return levels.map((level) => level.toLowerCase() as ThinkingLevel);
 }
 
+interface ConfiguredPromptPath {
+	rawPath: string;
+	resolvedPath: string;
+	settingsPath: string;
+	source: PromptSource;
+	baseDir: string;
+	patterns: string[];
+}
+
+interface ConfiguredPromptPaths {
+	paths: ConfiguredPromptPath[];
+	patterns: string[];
+}
+
+function expandConfiguredPromptPath(rawPath: string, baseDir: string): string {
+	const trimmed = rawPath.trim();
+	const expanded = trimmed === "~" ? homedir() : trimmed.startsWith("~/") ? join(homedir(), trimmed.slice(2)) : trimmed;
+	return isAbsolute(expanded) ? resolve(expanded) : resolve(baseDir, expanded);
+}
+
+function isSettingsPromptPattern(value: string): boolean {
+	return value.startsWith("!") || value.startsWith("+") || value.startsWith("-") || value.includes("*") || value.includes("?");
+}
+
+function isSettingsPromptOverridePattern(value: string): boolean {
+	return value.startsWith("!") || value.startsWith("+") || value.startsWith("-");
+}
+
+function toPosixPath(path: string): string {
+	return path.replace(/\\/g, "/");
+}
+
+function normalizeExactPromptPattern(pattern: string): string {
+	const normalized = pattern.startsWith("./") || pattern.startsWith(".\\") ? pattern.slice(2) : pattern;
+	return toPosixPath(normalized);
+}
+
+function matchesPromptPattern(filePath: string, pattern: string, baseDir: string): boolean {
+	const normalizedPattern = toPosixPath(pattern);
+	const rel = toPosixPath(relative(baseDir, filePath));
+	const name = basename(filePath);
+	const filePathPosix = toPosixPath(filePath);
+	return [rel, name, filePathPosix].some((candidate) => minimatch(candidate, normalizedPattern));
+}
+
+function matchesExactPromptPattern(filePath: string, pattern: string, baseDir: string): boolean {
+	const normalizedPattern = normalizeExactPromptPattern(pattern);
+	const rel = toPosixPath(relative(baseDir, filePath));
+	const filePathPosix = toPosixPath(filePath);
+	return normalizedPattern === rel || normalizedPattern === filePathPosix;
+}
+
+function shouldLoadPromptFile(filePath: string, patterns: string[], baseDir: string): boolean {
+	const includes: string[] = [];
+	const excludes: string[] = [];
+	const forceIncludes: string[] = [];
+	const forceExcludes: string[] = [];
+
+	for (const pattern of patterns) {
+		if (pattern.startsWith("+")) {
+			forceIncludes.push(pattern.slice(1));
+		} else if (pattern.startsWith("-")) {
+			forceExcludes.push(pattern.slice(1));
+		} else if (pattern.startsWith("!")) {
+			excludes.push(pattern.slice(1));
+		} else {
+			includes.push(pattern);
+		}
+	}
+
+	let enabled = includes.length === 0 || includes.some((pattern) => matchesPromptPattern(filePath, pattern, baseDir));
+	if (excludes.some((pattern) => matchesPromptPattern(filePath, pattern, baseDir))) enabled = false;
+	if (forceIncludes.some((pattern) => matchesExactPromptPattern(filePath, pattern, baseDir))) enabled = true;
+	if (forceExcludes.some((pattern) => matchesExactPromptPattern(filePath, pattern, baseDir))) enabled = false;
+	return enabled;
+}
+
+function createPromptFileFilter(patterns: string[], baseDir: string): ((filePath: string) => boolean) | undefined {
+	return patterns.length === 0 ? undefined : (filePath) => shouldLoadPromptFile(filePath, patterns, baseDir);
+}
+
+function loadConfiguredPromptPaths(
+	settingsPath: string,
+	source: PromptSource,
+	baseDir: string,
+	diagnostics: PromptLoaderDiagnostic[],
+): ConfiguredPromptPaths {
+	if (!existsSync(settingsPath)) return { paths: [], patterns: [] };
+
+	let rawSettings: string;
+	try {
+		rawSettings = readFileSync(settingsPath, "utf-8");
+	} catch (error) {
+		diagnostics.push(
+			createDiagnostic(
+				"unreadable-settings",
+				settingsPath,
+				source,
+				`Skipping prompt settings at ${settingsPath}: ${error instanceof Error ? error.message : String(error)}.`,
+			),
+		);
+		return { paths: [], patterns: [] };
+	}
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(rawSettings);
+	} catch (error) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-settings-json",
+				settingsPath,
+				source,
+				`Skipping prompt settings at ${settingsPath}: ${error instanceof Error ? error.message : String(error)}.`,
+			),
+		);
+		return { paths: [], patterns: [] };
+	}
+
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-settings",
+				settingsPath,
+				source,
+				`Skipping prompt settings at ${settingsPath}: settings must be a JSON object.`,
+			),
+		);
+		return { paths: [], patterns: [] };
+	}
+
+	const prompts = (parsed as Record<string, unknown>).prompts;
+	if (prompts === undefined) return { paths: [], patterns: [] };
+	if (!Array.isArray(prompts)) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-settings-prompts",
+				settingsPath,
+				source,
+				`Ignoring prompts in ${settingsPath}: expected "prompts" to be an array of strings.`,
+			),
+		);
+		return { paths: [], patterns: [] };
+	}
+
+	const configuredPaths: Omit<ConfiguredPromptPath, "patterns">[] = [];
+	const patterns: string[] = [];
+	for (let index = 0; index < prompts.length; index++) {
+		const rawPath = prompts[index];
+		if (typeof rawPath !== "string" || rawPath.trim().length === 0) {
+			diagnostics.push(
+				createDiagnostic(
+					"invalid-settings-prompt-entry",
+					settingsPath,
+					source,
+					`Ignoring prompts[${index}] in ${settingsPath}: expected a non-empty string.`,
+				),
+			);
+			continue;
+		}
+
+		const trimmed = rawPath.trim();
+		if (isSettingsPromptPattern(trimmed)) {
+			patterns.push(trimmed);
+			continue;
+		}
+		configuredPaths.push({
+			rawPath: trimmed,
+			resolvedPath: expandConfiguredPromptPath(trimmed, baseDir),
+			settingsPath,
+			source,
+			baseDir,
+		});
+	}
+
+	return { paths: configuredPaths.map((path) => ({ ...path, patterns })), patterns };
+}
+
+function canonicalizePromptFile(filePath: string): string {
+	try {
+		return realpathSync(filePath);
+	} catch {
+		return resolve(filePath);
+	}
+}
+
 function loadPromptsWithModelFromDir(
 	dir: string,
 	source: PromptSource,
 	includePlainPrompts: boolean,
 	subdir = "",
 	visitedDirectories = new Set<string>(),
+	onlyFileName?: string,
+	seenFiles?: Set<string>,
+	shouldLoadFile?: (filePath: string) => boolean,
 ): { prompts: PromptWithModel[]; diagnostics: PromptLoaderDiagnostic[] } {
 	const prompts: PromptWithModel[] = [];
 	const diagnostics: PromptLoaderDiagnostic[] = [];
@@ -1390,6 +1580,7 @@ function loadPromptsWithModelFromDir(
 		const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => lexicalCompare(a.name, b.name));
 
 		for (const entry of entries) {
+			if (onlyFileName && entry.name !== onlyFileName) continue;
 			const fullPath = join(dir, entry.name);
 
 			let isFile = entry.isFile();
@@ -1413,14 +1604,19 @@ function loadPromptsWithModelFromDir(
 			}
 
 			if (isDirectory) {
+				if (onlyFileName) continue;
 				const nextSubdir = subdir ? `${subdir}:${entry.name}` : entry.name;
-				const nested = loadPromptsWithModelFromDir(fullPath, source, includePlainPrompts, nextSubdir, visitedDirectories);
+				const nested = loadPromptsWithModelFromDir(fullPath, source, includePlainPrompts, nextSubdir, visitedDirectories, undefined, seenFiles, shouldLoadFile);
 				prompts.push(...nested.prompts);
 				diagnostics.push(...nested.diagnostics);
 				continue;
 			}
 
 			if (!isFile || !entry.name.endsWith(".md")) continue;
+			if (shouldLoadFile && !shouldLoadFile(fullPath)) continue;
+			const canonicalFile = canonicalizePromptFile(fullPath);
+			if (seenFiles?.has(canonicalFile)) continue;
+			seenFiles?.add(canonicalFile);
 
 			try {
 				const rawContent = readFileSync(fullPath, "utf-8");
@@ -1802,11 +1998,69 @@ function loadPromptsWithModelFromDir(
 	return { prompts, diagnostics };
 }
 
+function loadPromptsWithModelFromConfiguredPath(
+	configuredPath: ConfiguredPromptPath,
+	includePlainPrompts: boolean,
+	seenFiles: Set<string>,
+): { prompts: PromptWithModel[]; diagnostics: PromptLoaderDiagnostic[] } {
+	const diagnostics: PromptLoaderDiagnostic[] = [];
+	const { rawPath, resolvedPath, settingsPath, source, baseDir, patterns } = configuredPath;
+	const shouldLoadFile = createPromptFileFilter(patterns, baseDir);
+
+	if (!existsSync(resolvedPath)) {
+		diagnostics.push(
+			createDiagnostic(
+				"missing-prompt-path",
+				resolvedPath,
+				source,
+				`Skipping configured prompt path ${JSON.stringify(rawPath)} from ${settingsPath}: resolved path ${resolvedPath} does not exist.`,
+			),
+		);
+		return { prompts: [], diagnostics };
+	}
+
+	let stats: ReturnType<typeof statSync>;
+	try {
+		stats = statSync(resolvedPath);
+	} catch (error) {
+		diagnostics.push(
+			createDiagnostic(
+				"unreadable-prompt-path",
+				resolvedPath,
+				source,
+				`Skipping configured prompt path ${JSON.stringify(rawPath)} from ${settingsPath}: ${error instanceof Error ? error.message : String(error)}.`,
+			),
+		);
+		return { prompts: [], diagnostics };
+	}
+
+	if (stats.isDirectory()) {
+		return loadPromptsWithModelFromDir(resolvedPath, source, includePlainPrompts, "", new Set<string>(), undefined, seenFiles, shouldLoadFile);
+	}
+
+	if (!stats.isFile() || !resolvedPath.endsWith(".md")) {
+		diagnostics.push(
+			createDiagnostic(
+				"invalid-prompt-path",
+				resolvedPath,
+				source,
+				`Skipping configured prompt path ${JSON.stringify(rawPath)} from ${settingsPath}: expected a directory or .md file.`,
+			),
+		);
+		return { prompts: [], diagnostics };
+	}
+
+	return loadPromptsWithModelFromDir(dirname(resolvedPath), source, includePlainPrompts, "", new Set<string>(), basename(resolvedPath), seenFiles, shouldLoadFile);
+}
+
 export function loadPromptsWithModel(cwd: string, includePlainPrompts = false): LoadPromptsWithModelResult {
-	const globalDir = join(homedir(), ".pi", "agent", "prompts");
-	const projectDir = resolve(cwd, ".pi", "prompts");
+	const agentDir = getAgentDir();
+	const globalDir = join(agentDir, "prompts");
+	const projectBaseDir = resolve(cwd, CONFIG_DIR_NAME);
+	const projectDir = join(projectBaseDir, "prompts");
 	const promptMap = new Map<string, PromptWithModel>();
 	const diagnostics: PromptLoaderDiagnostic[] = [];
+	const seenPromptFiles = new Set<string>();
 
 	function addPrompt(prompt: PromptWithModel) {
 		const existing = promptMap.get(prompt.name);
@@ -1824,23 +2078,29 @@ export function loadPromptsWithModel(cwd: string, includePlainPrompts = false):
 					`Skipping ${prompt.source} prompt template "${prompt.name}" at ${prompt.filePath} because it conflicts with ${existing.filePath}.`,
 				),
 			);
-			return;
 		}
-
-		promptMap.set(prompt.name, prompt);
 	}
 
-	const globalResult = loadPromptsWithModelFromDir(globalDir, "user", includePlainPrompts);
-	diagnostics.push(...globalResult.diagnostics);
-	for (const prompt of globalResult.prompts) {
-		addPrompt(prompt);
+	function addResult(result: { prompts: PromptWithModel[]; diagnostics: PromptLoaderDiagnostic[] }) {
+		diagnostics.push(...result.diagnostics);
+		for (const prompt of result.prompts) {
+			addPrompt(prompt);
+		}
 	}
 
-	const projectResult = loadPromptsWithModelFromDir(projectDir, "project", includePlainPrompts);
-	diagnostics.push(...projectResult.diagnostics);
-	for (const prompt of projectResult.prompts) {
-		addPrompt(prompt);
+	const projectSettingsPaths = loadConfiguredPromptPaths(join(projectBaseDir, "settings.json"), "project", projectBaseDir, diagnostics);
+	const globalSettingsPaths = loadConfiguredPromptPaths(join(agentDir, "settings.json"), "user", agentDir, diagnostics);
+	const projectDefaultFilter = createPromptFileFilter(projectSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), projectBaseDir);
+	const globalDefaultFilter = createPromptFileFilter(globalSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), agentDir);
+
+	for (const configuredPath of projectSettingsPaths.paths) {
+		addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
+	}
+	addResult(loadPromptsWithModelFromDir(projectDir, "project", includePlainPrompts, "", new Set<string>(), undefined, seenPromptFiles, projectDefaultFilter));
+	for (const configuredPath of globalSettingsPaths.paths) {
+		addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
 	}
+	addResult(loadPromptsWithModelFromDir(globalDir, "user", includePlainPrompts, "", new Set<string>(), undefined, seenPromptFiles, globalDefaultFilter));
 
 	return { prompts: promptMap, diagnostics };
 }
@@ -1911,7 +2171,7 @@ function findFirstExisting(paths: string[]): string | undefined {
 export function resolveSkillPath(skillName: string, cwd: string): string | undefined {
 	const projectDir = resolve(cwd);
 
-	const projectPiSkill = findFirstExisting(getSkillCandidates(resolve(projectDir, ".pi", "skills"), skillName));
+	const projectPiSkill = findFirstExisting(getSkillCandidates(resolve(projectDir, CONFIG_DIR_NAME, "skills"), skillName));
 	if (projectPiSkill) return projectPiSkill;
 
 	const repoRoot = findRepoRoot(projectDir);
@@ -1920,7 +2180,7 @@ export function resolveSkillPath(skillName: string, cwd: string): string | undef
 		if (projectAgentsSkill) return projectAgentsSkill;
 	}
 
-	const globalPiSkill = findFirstExisting(getSkillCandidates(join(homedir(), ".pi", "agent", "skills"), skillName));
+	const globalPiSkill = findFirstExisting(getSkillCandidates(join(getAgentDir(), "skills"), skillName));
 	if (globalPiSkill) return globalPiSkill;
 
 	return findFirstExisting(getSkillCandidates(join(homedir(), ".agents", "skills"), skillName));

package/skill-loaded-renderer.ts

@@ -1,5 +1,5 @@
-import type { MessageRenderOptions, Theme } from "@mariozechner/pi-coding-agent";
-import { Box, Container, Spacer, Text } from "@mariozechner/pi-tui";
+import type { MessageRenderOptions, Theme } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
 
 export interface SkillLoadedDetails {
 	skillName: string;

package/subagent-renderer.ts

@@ -1,5 +1,5 @@
-import type { MessageRenderOptions, Theme } from "@mariozechner/pi-coding-agent";
-import { Box, Container, Spacer, Text } from "@mariozechner/pi-tui";
+import type { MessageRenderOptions, Theme } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
 
 interface AssistantContent {
 	type: string;

package/subagent-runtime.ts

@@ -1,7 +1,3 @@
-import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
 export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request";
 export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started";
 export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response";
@@ -93,67 +89,8 @@ export interface DelegatedSubagentLiveState {
 	updatedAt: number;
 }
 
-interface RuntimeAgent {
-	name: string;
-}
-
-interface DiscoverAgentsResult {
-	agents: RuntimeAgent[];
-}
-
-type DiscoverAgentsFn = (cwd: string, scope: "user" | "project" | "both") => DiscoverAgentsResult;
-
-export interface SubagentRuntime {
-	root: string;
-	discoverAgents: DiscoverAgentsFn;
-}
-
-let runtimeCache: SubagentRuntime | null = null;
 const delegatedLiveState = new Map<string, DelegatedSubagentLiveState>();
 
-function runtimeCandidates(cwd: string): string[] {
-	const fromEnv = process.env.PI_SUBAGENT_RUNTIME_ROOT?.trim();
-	if (fromEnv) return [resolve(fromEnv)];
-	const localSibling = resolve(dirname(fileURLToPath(import.meta.url)), "..", "pi-subagents");
-	return [
-		resolve(cwd, ".pi", "npm", "node_modules", "pi-subagents"),
-		localSibling,
-	];
-}
-
-function findSubagentRoot(cwd: string): string | undefined {
-	for (const candidate of runtimeCandidates(cwd)) {
-		if (existsSync(join(candidate, "agents.ts")) || existsSync(join(candidate, "agents.js"))) {
-			return candidate;
-		}
-	}
-	return undefined;
-}
-
-async function importRuntimeModule(root: string, baseName: string): Promise<unknown> {
-	const candidates = [
-		join(root, `${baseName}.ts`),
-		join(root, `${baseName}.mts`),
-		join(root, `${baseName}.js`),
-		join(root, `${baseName}.mjs`),
-	];
-
-	let lastError: unknown;
-	for (const filePath of candidates) {
-		if (!existsSync(filePath)) continue;
-		try {
-			return await import(pathToFileURL(filePath).href);
-		} catch (error) {
-			lastError = error;
-		}
-	}
-
-	if (lastError !== undefined) {
-		throw lastError;
-	}
-	throw new Error(`Missing runtime module: ${baseName}`);
-}
-
 export function updateDelegatedLiveState(requestId: string, update: Partial<DelegatedSubagentLiveState>): void {
 	const now = Date.now();
 	const existing = delegatedLiveState.get(requestId) ?? {
@@ -210,38 +147,3 @@ export function getDelegatedLiveState(requestId: string): DelegatedSubagentLiveS
 export function clearDelegatedLiveState(requestId: string): void {
 	delegatedLiveState.delete(requestId);
 }
-
-export async function ensureSubagentRuntime(cwd: string): Promise<SubagentRuntime> {
-	const root = findSubagentRoot(cwd);
-	if (!root) {
-		throw new Error(
-			"Delegated prompt execution requires pi-subagents. Install it with `pi install npm:pi-subagents` or set PI_SUBAGENT_RUNTIME_ROOT.",
-		);
-	}
-
-	if (runtimeCache && runtimeCache.root === root) {
-		return runtimeCache;
-	}
-
-	const module = await importRuntimeModule(root, "agents");
-	const discoverAgents = (module as { discoverAgents?: unknown }).discoverAgents;
-	if (typeof discoverAgents !== "function") {
-		throw new Error(`Invalid subagent runtime at ${root}: expected discoverAgents(cwd, scope).`);
-	}
-
-	runtimeCache = {
-		root,
-		discoverAgents: discoverAgents as DiscoverAgentsFn,
-	};
-	return runtimeCache;
-}
-
-export function resolveDelegatedAgent(runtime: SubagentRuntime, cwd: string, requested: string): string {
-	const discovered = runtime.discoverAgents(cwd, "both");
-	if (!discovered.agents.some((agent) => agent.name === requested)) {
-		throw new Error(
-			`Delegated subagent \`${requested}\` not found. Available agents: ${discovered.agents.map((a) => a.name).join(", ") || "none"}.`,
-		);
-	}
-	return requested;
-}

package/subagent-step.ts

@@ -1,17 +1,16 @@
 import { existsSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import type { AssistantMessage, Message } from "@mariozechner/pi-ai";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { Model } from "@mariozechner/pi-ai";
-import { Key, matchesKey } from "@mariozechner/pi-tui";
-import { preparePromptExecution } from "./prompt-execution.js";
-import type { PromptWithModel } from "./prompt-loader.js";
-import { notify } from "./notifications.js";
+import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
+import { Key, matchesKey } from "@earendil-works/pi-tui";
+import { preparePromptExecution } from "./prompt-execution.ts";
+import type { PromptWithModel } from "./prompt-loader.ts";
+import { notify } from "./notifications.ts";
 import {
 	DEFAULT_SUBAGENT_NAME,
 	appendDelegatedLiveOutput,
 	clearDelegatedLiveState,
-	ensureSubagentRuntime,
 	getDelegatedLiveState,
 	PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT,
 	PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE,
@@ -19,7 +18,6 @@ import {
 	PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT,
 	PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
 	PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT,
-	resolveDelegatedAgent,
 	updateDelegatedLiveState,
 	type DelegatedSubagentParallelResult,
 	type DelegatedSubagentRequest,
@@ -27,9 +25,9 @@ import {
 	type DelegatedSubagentTask,
 	type DelegatedSubagentTaskProgress,
 	type DelegatedSubagentUpdate,
-} from "./subagent-runtime.js";
-import type { SubagentOverride } from "./args.js";
-import { createDelegatedProgressWidget, DELEGATED_WIDGET_KEY } from "./subagent-widget.js";
+} from "./subagent-runtime.ts";
+import type { SubagentOverride } from "./args.ts";
+import { createDelegatedProgressWidget, DELEGATED_WIDGET_KEY } from "./subagent-widget.ts";
 
 interface DelegatedPromptBaseOptions {
 	pi: ExtensionAPI;
@@ -169,7 +167,6 @@ async function prepareDelegatedTask(
 	override: SubagentOverride | undefined,
 	inheritedModel: Model<any> | undefined,
 	taskPreamble: string | undefined,
-	runtime: Awaited<ReturnType<typeof ensureSubagentRuntime>>,
 ): Promise<PreparedDelegatedTask> {
 	const requestedAgent = resolveDelegationName(task.prompt, override);
 	if (!requestedAgent) {
@@ -179,7 +176,7 @@ async function prepareDelegatedTask(
 	if (effectiveCwd !== ctx.cwd && !existsSync(effectiveCwd)) {
 		throw new Error(`cwd directory does not exist: ${effectiveCwd}`);
 	}
-	const agent = resolveDelegatedAgent(runtime, effectiveCwd, requestedAgent);
+	const agent = requestedAgent;
 	const preparationOptions = inheritedModel === undefined ? undefined : { inheritedModel };
 	const prepared = await preparePromptExecution(
 		task.prompt,
@@ -340,7 +337,7 @@ async function requestDelegatedRun(
 		const startTimeoutMs = Number(process.env.PI_PROMPT_SUBAGENT_START_TIMEOUT_MS ?? "15000");
 		const effectiveTimeout = Number.isFinite(startTimeoutMs) && startTimeoutMs > 0 ? startTimeoutMs : 15_000;
 		const startTimeout = setTimeout(() => {
-			finish(() => reject(new Error(`Delegated subagent \`${requestLabel}\` did not start within ${Math.round(effectiveTimeout / 1000)}s. Check that the subagent extension is loaded.`)));
+			finish(() => reject(new Error(`Delegated subagent \`${requestLabel}\` did not start within ${Math.round(effectiveTimeout / 1000)}s. Check that the pi-subagents extension is loaded.`)));
 		}, effectiveTimeout);
 
 		const onStarted = (data: unknown) => {
@@ -528,8 +525,8 @@ async function requestDelegatedRun(
 		if (!started && done) return; // already finished (e.g. response came synchronously)
 		if (!started) {
 			finish(() => reject(new Error(
-				`No subagent runtime responded for \`${requestLabel}\`. ` +
-				`Ensure the subagent extension is loaded and has no name conflicts with other extensions.`,
+				`No loaded pi-subagents bridge responded for \`${requestLabel}\`. ` +
+				`Install or load pi-subagents and make sure no extension name conflicts are blocking it.`,
 			)));
 			return;
 		}
@@ -538,7 +535,6 @@ async function requestDelegatedRun(
 
 export async function executeSubagentPromptStep(options: DelegatedPromptOptions): Promise<DelegatedPromptOutcome | undefined> {
 	const { pi, ctx, currentModel, override, signal, inheritedModel, taskPreamble, allowPartialFailures } = options;
-	const runtime = await ensureSubagentRuntime(ctx.cwd);
 	const isParallelRequest = "parallel" in options;
 
 	const tasks = isParallelRequest
@@ -548,7 +544,7 @@ export async function executeSubagentPromptStep(options: DelegatedPromptOptions)
 
 	const preparedTasks: PreparedDelegatedTask[] = [];
 	for (const task of tasks) {
-		const preparedTask = await prepareDelegatedTask(task, ctx, currentModel, override, inheritedModel, taskPreamble, runtime);
+		const preparedTask = await prepareDelegatedTask(task, ctx, currentModel, override, inheritedModel, taskPreamble);
 		preparedTasks.push(preparedTask);
 	}
 

package/subagent-widget.ts

@@ -1,11 +1,11 @@
-import type { Theme } from "@mariozechner/pi-coding-agent";
-import { Box, Container, Spacer, Text } from "@mariozechner/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
 import {
 	getDelegatedLiveState,
 	type DelegatedSubagentLiveState,
 	type DelegatedSubagentTask,
 	type DelegatedSubagentTaskProgress,
-} from "./subagent-runtime.js";
+} from "./subagent-runtime.ts";
 
 export const DELEGATED_WIDGET_KEY = "prompt-subagent-progress";
 

package/tool-manager.ts

@@ -1,9 +1,8 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { getAgentDir, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { notify } from "./notifications.js";
+import { notify } from "./notifications.ts";
 
 export interface ToolManagerDeps {
 	isActive(): boolean;
@@ -17,7 +16,7 @@ export function createToolManager(pi: ExtensionAPI, deps: ToolManagerDeps) {
 	let toolGuidance: string | null = null;
 	let toolRegistered = false;
 	let toolQueuedCommand: string | null = null;
-	const configPath = join(homedir(), ".pi", "agent", "prompt-template-model.json");
+	const configPath = join(getAgentDir(), "prompt-template-model.json");
 
 	try {
 		const rawConfig = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -41,7 +40,7 @@ export function createToolManager(pi: ExtensionAPI, deps: ToolManagerDeps) {
 
 	function saveToolConfig() {
 		try {
-			mkdirSync(join(homedir(), ".pi", "agent"), { recursive: true });
+			mkdirSync(getAgentDir(), { recursive: true });
 			writeFileSync(configPath, JSON.stringify({ toolEnabled, toolGuidance }, null, 2));
 		} catch (error) {
 			process.stderr.write(
@@ -209,6 +208,9 @@ export function createToolManager(pi: ExtensionAPI, deps: ToolManagerDeps) {
 		getGuidance() {
 			return toolGuidance;
 		},
+		hasQueuedCommand() {
+			return toolQueuedCommand !== null;
+		},
 		clearQueue() {
 			toolQueuedCommand = null;
 		},