@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/session/tool-choice-queue.ts

@@ -0,0 +1,213 @@
+import type { ToolChoice } from "@oh-my-pi/pi-ai";
+
+// ── Callback types ──────────────────────────────────────────────────────────
+
+export interface ResolveInfo {
+	/** The ToolChoice that was served to the LLM. */
+	choice: ToolChoice;
+}
+
+export interface RejectInfo {
+	/** The ToolChoice that was yielded but never (or unsuccessfully) served. */
+	choice: ToolChoice;
+	reason: "aborted" | "error" | "cleared" | "removed";
+}
+
+/** "requeue" replays the lost yield next turn; "drop" (or void/undefined) discards it. */
+export type RejectOutcome = "requeue" | "drop";
+
+export interface DirectiveCallbacks {
+	/** Fires when the yield was served (LLM call completed). The directive is consumed. */
+	onResolved?: (info: ResolveInfo) => void;
+	/**
+	 * Fires when the yield is being discarded. Return "requeue" to replay the
+	 * same value at the head of the queue for the next turn. Default: "drop".
+	 */
+	onRejected?: (info: RejectInfo) => RejectOutcome | undefined;
+	/**
+	 * Handler invoked when the model actually calls the forced tool. The queue
+	 * directive carries the real execution logic; the tool's own execute() is
+	 * bypassed. Returns the tool result directly.
+	 */
+	onInvoked?: (input: unknown) => Promise<unknown> | unknown;
+}
+
+// ── Directive ───────────────────────────────────────────────────────────────
+
+export interface ToolChoiceDirective {
+	generator: Iterator<ToolChoice>;
+	/** Stable label for targeted removal and debugging (e.g. "user-force"). */
+	label: string;
+	callbacks: DirectiveCallbacks;
+}
+
+export interface PushOptions {
+	/** Prepend to head instead of appending to tail. Default: false. */
+	now?: boolean;
+	label?: string;
+	/** Lifecycle callbacks for this directive. */
+	onResolved?: DirectiveCallbacks["onResolved"];
+	onRejected?: DirectiveCallbacks["onRejected"];
+	onInvoked?: DirectiveCallbacks["onInvoked"];
+}
+
+// ── Generators ──────────────────────────────────────────────────────────────
+
+export function* onceGen(choice: ToolChoice): Generator<ToolChoice, void, unknown> {
+	yield choice;
+}
+
+// ── In-flight state ─────────────────────────────────────────────────────────
+
+interface InFlight {
+	directive: ToolChoiceDirective;
+	yielded: ToolChoice;
+}
+
+// ── Queue ───────────────────────────────────────────────────────────────────
+
+export class ToolChoiceQueue {
+	#queue: ToolChoiceDirective[] = [];
+	#inFlight: InFlight | undefined;
+	/**
+	 * Label of the directive whose last yield was resolved this turn.
+	 * Consumers (e.g. todo reminder suppression) read via consumeLastServedLabel().
+	 */
+	#lastResolvedLabel: string | undefined;
+
+	// ── Push ──────────────────────────────────────────────────────────────
+
+	pushOnce(choice: ToolChoice, options?: PushOptions): void {
+		this.push(onceGen(choice), options);
+	}
+
+	pushSequence(choices: ToolChoice[], options?: PushOptions): void {
+		this.push(choices, options);
+	}
+
+	push(generator: Iterable<ToolChoice>, options?: PushOptions): void {
+		const directive: ToolChoiceDirective = {
+			generator: generator[Symbol.iterator](),
+			label: options?.label ?? "anonymous",
+			callbacks: {
+				onResolved: options?.onResolved,
+				onRejected: options?.onRejected,
+				onInvoked: options?.onInvoked,
+			},
+		};
+		if (options?.now) {
+			this.#queue.unshift(directive);
+		} else {
+			this.#queue.push(directive);
+		}
+	}
+
+	// ── Consume ───────────────────────────────────────────────────────────
+
+	/**
+	 * Advance the head directive and return its next yield. Records the value
+	 * as in-flight until resolve() or reject() is called.
+	 */
+	nextToolChoice(): ToolChoice | undefined {
+		while (this.#queue.length > 0) {
+			const head = this.#queue[0]!;
+			const result = head.generator.next();
+			if (result.done) {
+				this.#queue.shift();
+				continue;
+			}
+			this.#inFlight = { directive: head, yielded: result.value };
+			return result.value;
+		}
+		return undefined;
+	}
+
+	// ── Lifecycle ─────────────────────────────────────────────────────────
+
+	/**
+	 * The in-flight yield was served — the LLM call completed normally.
+	 * Fires onResolved, then clears in-flight state. The directive's generator
+	 * remains in the queue if it has more values to yield.
+	 */
+	resolve(): void {
+		const inFlight = this.#inFlight;
+		this.#inFlight = undefined;
+		if (!inFlight) return;
+
+		this.#lastResolvedLabel = inFlight.directive.label;
+		inFlight.directive.callbacks.onResolved?.({ choice: inFlight.yielded });
+	}
+
+	/**
+	 * The in-flight yield was not served, or the turn aborted/errored.
+	 * Fires onRejected to let the caller decide: "requeue" replays the exact
+	 * lost value at the head of the queue; anything else drops it.
+	 */
+	reject(reason: RejectInfo["reason"]): void {
+		const inFlight = this.#inFlight;
+		this.#inFlight = undefined;
+		if (!inFlight) return;
+
+		const outcome = inFlight.directive.callbacks.onRejected?.({
+			choice: inFlight.yielded,
+			reason,
+		});
+
+		if (outcome === "requeue") {
+			// Re-queue only the lost yield, not the rest of the sequence. Carry forward
+			// onInvoked and onRejected so the replayed yield still executes correctly
+			// and can requeue itself again if the next turn also aborts.
+			this.#queue.unshift({
+				generator: onceGen(inFlight.yielded),
+				label: `${inFlight.directive.label}-requeued`,
+				callbacks: {
+					onInvoked: inFlight.directive.callbacks.onInvoked,
+					onRejected: inFlight.directive.callbacks.onRejected,
+				},
+			});
+		}
+	}
+
+	/** True if there is an in-flight yield that hasn't been resolved or rejected. */
+	get hasInFlight(): boolean {
+		return this.#inFlight !== undefined;
+	}
+
+	/** Peek the in-flight directive's onInvoked handler, if any. */
+	peekInFlightInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
+		return this.#inFlight?.directive.callbacks.onInvoked;
+	}
+
+	// ── Cleanup ───────────────────────────────────────────────────────────
+
+	/** Remove all directives with the given label. Rejects in-flight if it matches. */
+	removeByLabel(label: string): void {
+		if (this.#inFlight?.directive.label === label) {
+			this.reject("removed");
+		}
+		this.#queue = this.#queue.filter(d => d.label !== label);
+	}
+
+	/** Empty the queue and reject any in-flight yield. */
+	clear(): void {
+		if (this.#inFlight) {
+			this.reject("cleared");
+		}
+		this.#queue = [];
+		this.#lastResolvedLabel = undefined;
+	}
+
+	// ── Observation ───────────────────────────────────────────────────────
+
+	/** Return the label of the most recently resolved directive, then clear it. */
+	consumeLastServedLabel(): string | undefined {
+		const label = this.#lastResolvedLabel;
+		this.#lastResolvedLabel = undefined;
+		return label;
+	}
+
+	/** For tests/debug: labels of currently queued directives in order. */
+	inspect(): readonly string[] {
+		return this.#queue.map(d => d.label);
+	}
+}

package/src/slash-commands/builtin-registry.ts

@@ -55,7 +55,15 @@ interface ParsedBuiltinSlashCommand {
 interface BuiltinSlashCommandSpec extends BuiltinSlashCommand {
 	aliases?: string[];
 	allowArgs?: boolean;
-	handle: (command: ParsedBuiltinSlashCommand, runtime: BuiltinSlashCommandRuntime) => Promise<void> | void;
+	/**
+	 * Handle the command. Return a string to pass remaining text through as prompt input.
+	 * Return void/undefined to consume the input entirely.
+	 */
+	handle: (
+		command: ParsedBuiltinSlashCommand,
+		runtime: BuiltinSlashCommandRuntime,
+		// biome-ignore lint/suspicious/noConfusingVoidType: void needed so handlers returning nothing are assignable
+	) => Promise<string | undefined> | string | void;
 }
 
 export interface BuiltinSlashCommandRuntime {
@@ -69,7 +77,11 @@ function parseBuiltinSlashCommand(text: string): ParsedBuiltinSlashCommand | nul
 	if (!body) return null;
 
 	const firstWhitespace = body.search(/\s/);
-	if (firstWhitespace === -1) {
+	const firstColon = body.indexOf(":");
+	const firstSeparator =
+		firstWhitespace === -1 ? firstColon : firstColon === -1 ? firstWhitespace : Math.min(firstWhitespace, firstColon);
+
+	if (firstSeparator === -1) {
 		return {
 			name: body,
 			args: "",
@@ -78,8 +90,8 @@ function parseBuiltinSlashCommand(text: string): ParsedBuiltinSlashCommand | nul
 	}
 
 	return {
-		name: body.slice(0, firstWhitespace),
-		args: body.slice(firstWhitespace).trim(),
+		name: body.slice(0, firstSeparator),
+		args: body.slice(firstSeparator + 1).trim(),
 		text,
 	};
 }
@@ -888,6 +900,37 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "force",
+		description: "Force next turn to use a specific tool",
+		inlineHint: "<tool-name> [prompt]",
+		allowArgs: true,
+		handle: (command, runtime) => {
+			const spaceIdx = command.args.indexOf(" ");
+			const toolName = spaceIdx === -1 ? command.args : command.args.slice(0, spaceIdx);
+			const prompt = spaceIdx === -1 ? "" : command.args.slice(spaceIdx + 1).trim();
+
+			if (!toolName) {
+				runtime.ctx.showError("Usage: /force:<tool-name> [prompt]");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+
+			try {
+				runtime.ctx.session.setForcedToolChoice(toolName);
+				runtime.ctx.showStatus(`Next turn forced to use ${toolName}.`);
+			} catch (error) {
+				runtime.ctx.showError(error instanceof Error ? error.message : String(error));
+				runtime.ctx.editor.setText("");
+				return;
+			}
+
+			runtime.ctx.editor.setText("");
+
+			// If a prompt was provided, pass it through as input
+			if (prompt) return prompt;
+		},
+	},
 	{
 		name: "quit",
 		description: "Quit the application",
@@ -916,9 +959,14 @@ export const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand> = BU
 /**
  * Execute a builtin slash command when it matches known command syntax.
  *
- * Returns true when a builtin command consumed the input; false otherwise.
+ * Returns `false` when no builtin matched. Returns `true` when a command consumed
+ * the input entirely. Returns a `string` when the command was handled but remaining
+ * text should be sent as a prompt.
  */
-export async function executeBuiltinSlashCommand(text: string, runtime: BuiltinSlashCommandRuntime): Promise<boolean> {
+export async function executeBuiltinSlashCommand(
+	text: string,
+	runtime: BuiltinSlashCommandRuntime,
+): Promise<string | boolean> {
 	const parsed = parseBuiltinSlashCommand(text);
 	if (!parsed) return false;
 
@@ -928,6 +976,6 @@ export async function executeBuiltinSlashCommand(text: string, runtime: BuiltinS
 		return false;
 	}
 
-	await command.handle(parsed, runtime);
-	return true;
+	const remaining = await command.handle(parsed, runtime);
+	return remaining ?? true;
 }

package/src/ssh/connection-manager.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getRemoteHostDir, getSshControlDir, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
+import { $which, getRemoteHostDir, getSshControlDir, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { buildSshTarget, sanitizeHostName } from "./utils";
 
@@ -106,7 +106,7 @@ async function runSshCaptureSync(args: string[]): Promise<{ exitCode: number | n
 }
 
 function ensureSshBinary(): void {
-	if (!Bun.which("ssh")) {
+	if (!$which("ssh")) {
 		throw new Error("ssh binary not found on PATH");
 	}
 }

package/src/ssh/sshfs-mount.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getRemoteDir, postmortem } from "@oh-my-pi/pi-utils";
+import { $which, getRemoteDir, postmortem } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { getControlDir, getControlPathTemplate, type SSHConnectionTarget } from "./connection-manager";
 import { buildSshTarget, sanitizeHostName } from "./utils";
@@ -60,24 +60,24 @@ function buildSshfsArgs(host: SSHConnectionTarget): string[] {
 }
 
 async function unmountPath(path: string): Promise<boolean> {
-	const fusermount = Bun.which("fusermount") ?? Bun.which("fusermount3");
+	const fusermount = $which("fusermount") ?? $which("fusermount3");
 	if (fusermount) {
 		const result = await $`${fusermount} -u ${path}`.quiet().nothrow();
 		if (result.exitCode === 0) return true;
 	}
 
-	const umount = Bun.which("umount");
+	const umount = $which("umount");
 	if (!umount) return false;
 	const result = await $`${umount} ${path}`.quiet().nothrow();
 	return result.exitCode === 0;
 }
 
 export function hasSshfs(): boolean {
-	return Bun.which("sshfs") !== null;
+	return $which("sshfs") !== null;
 }
 
 export async function isMounted(path: string): Promise<boolean> {
-	const mountpoint = Bun.which("mountpoint");
+	const mountpoint = $which("mountpoint");
 	if (!mountpoint) return false;
 	const result = await $`${mountpoint} -q ${path}`.quiet().nothrow();
 	return result.exitCode === 0;

package/src/stt/downloader.ts

@@ -1,4 +1,4 @@
-import { logger } from "@oh-my-pi/pi-utils";
+import { $which, logger } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { resolvePython } from "./transcriber";
 
@@ -15,9 +15,9 @@ export interface EnsureOptions {
 // ── Recording tool ─────────────────────────────────────────────────
 
 async function ensureRecordingTool(options?: EnsureOptions): Promise<void> {
-	if (Bun.which("sox")) return;
-	if (Bun.which("ffmpeg")) return;
-	if (process.platform === "linux" && Bun.which("arecord")) return;
+	if ($which("sox")) return;
+	if ($which("ffmpeg")) return;
+	if (process.platform === "linux" && $which("arecord")) return;
 
 	// Windows: PowerShell mciSendString is always available as fallback
 	if (process.platform === "win32") {

package/src/stt/recorder.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import { logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { $which, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 
 export interface RecordingHandle {
@@ -15,9 +15,9 @@ const isWindows = process.platform === "win32";
  */
 export function detectRecordingTools(): string[] {
 	const tools: string[] = [];
-	if (Bun.which("sox")) tools.push("sox");
-	if (Bun.which("ffmpeg")) tools.push("ffmpeg");
-	if (!isWindows && Bun.which("arecord")) tools.push("arecord");
+	if ($which("sox")) tools.push("sox");
+	if ($which("ffmpeg")) tools.push("ffmpeg");
+	if (!isWindows && $which("arecord")) tools.push("arecord");
 	if (isWindows) tools.push("powershell");
 	return tools;
 }

package/src/stt/transcriber.ts

@@ -1,4 +1,4 @@
-import { logger } from "@oh-my-pi/pi-utils";
+import { $which, logger } from "@oh-my-pi/pi-utils";
 import transcribeScript from "./transcribe.py" with { type: "text" };
 
 export interface TranscribeOptions {
@@ -14,7 +14,7 @@ const TRANSCRIBE_TIMEOUT_MS = 120_000;
  */
 export function resolvePython(): string | null {
 	for (const cmd of ["python", "py", "python3"]) {
-		if (Bun.which(cmd)) return cmd;
+		if ($which(cmd)) return cmd;
 	}
 	return null;
 }

package/src/system-prompt.ts

@@ -6,17 +6,15 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { $env, getGpuCachePath, getProjectDir, hasFsCode, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { $env, getGpuCachePath, getProjectDir, hasFsCode, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { contextFileCapability } from "./capability/context-file";
 import { systemPromptCapability } from "./capability/system-prompt";
-import { renderPromptTemplate } from "./config/prompt-templates";
 import type { SkillsSettings } from "./config/settings";
 import { type ContextFile, loadCapability, type SystemPrompt as SystemPromptFile } from "./discovery";
 import { loadSkills, type Skill } from "./extensibility/skills";
 import customSystemPromptTemplate from "./prompts/system/custom-system-prompt.md" with { type: "text" };
 import systemPromptTemplate from "./prompts/system/system-prompt.md" with { type: "text" };
-import { formatPromptContent } from "./utils/prompt-format";
 
 interface AlwaysApplyRule {
 	name: string;
@@ -25,7 +23,7 @@ interface AlwaysApplyRule {
 }
 
 function normalizePromptBlock(content: string): string {
-	return formatPromptContent(content, { renderPhase: "post-render" }).trim();
+	return prompt.format(content, { renderPhase: "post-render" }).trim();
 }
 
 function splitComparablePromptBlocks(content: string | null | undefined): string[] {
@@ -267,14 +265,16 @@ async function saveGpuCache(info: GpuCache): Promise<void> {
 }
 
 async function getCachedGpu(): Promise<string | undefined> {
-	const cached = await logger.timeAsync("getCachedGpu:loadGpuCache", loadGpuCache);
+	const cached = await logger.time("getCachedGpu:loadGpuCache", loadGpuCache);
 	if (cached) return cached.gpu;
-	const gpu = await logger.timeAsync("getCachedGpu:getGpuModel", getGpuModel);
-	if (gpu) await logger.timeAsync("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
+	const gpu = await logger.time("getCachedGpu:getGpuModel", getGpuModel);
+	if (gpu) {
+		await logger.time("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
+	}
 	return gpu ?? undefined;
 }
 async function getEnvironmentInfo(): Promise<Array<{ label: string; value: string }>> {
-	const gpu = await logger.timeAsync("getEnvironmentInfo:getCachedGpu", getCachedGpu);
+	const gpu = await getCachedGpu();
 	const cpus = os.cpus();
 	const entries: Array<{ label: string; value: string | undefined }> = [
 		{ label: "OS", value: `${os.platform()} ${os.release()}` },
@@ -432,6 +432,8 @@ export interface BuildSystemPromptOptions {
 	eagerTasks?: boolean;
 	/** Rules with alwaysApply=true — their full content is injected into the prompt. */
 	alwaysApplyRules?: AlwaysApplyRule[];
+	/** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
+	secretsEnabled?: boolean;
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -456,17 +458,18 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		mcpDiscoveryMode = false,
 		mcpDiscoveryServerSummaries = [],
 		eagerTasks = false,
+		secretsEnabled = false,
 	} = options;
 	const resolvedCwd = cwd ?? getProjectDir();
 
 	const prepPromise = (() => {
-		const systemPromptCustomizationPromise = logger.timeAsync("loadSystemPromptFiles", loadSystemPromptFiles, {
+		const systemPromptCustomizationPromise = logger.time("loadSystemPromptFiles", loadSystemPromptFiles, {
 			cwd: resolvedCwd,
 		});
 		const contextFilesPromise = providedContextFiles
 			? Promise.resolve(providedContextFiles)
-			: logger.timeAsync("loadProjectContextFiles", loadProjectContextFiles, { cwd: resolvedCwd });
-		const agentsMdSearchPromise = logger.timeAsync("buildAgentsMdSearch", buildAgentsMdSearch, resolvedCwd);
+			: logger.time("loadProjectContextFiles", loadProjectContextFiles, { cwd: resolvedCwd });
+		const agentsMdSearchPromise = logger.time("buildAgentsMdSearch", buildAgentsMdSearch, resolvedCwd);
 		const skillsPromise: Promise<Skill[]> =
 			providedSkills !== undefined
 				? Promise.resolve(providedSkills)
@@ -580,7 +583,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	const promptSources = [effectiveSystemPromptCustomization, resolvedCustomPrompt, resolvedAppendPrompt];
 	const injectedAlwaysApplyRules = dedupeAlwaysApplyRules(alwaysApplyRules, promptSources);
 
-	const environment = await logger.timeAsync("getEnvironmentInfo", getEnvironmentInfo);
+	const environment = await logger.time("getEnvironmentInfo", getEnvironmentInfo);
 	const data = {
 		systemPromptCustomization: effectiveSystemPromptCustomization,
 		customPrompt: resolvedCustomPrompt,
@@ -603,6 +606,15 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		hasMCPDiscoveryServers: mcpDiscoveryServerSummaries.length > 0,
 		mcpDiscoveryServerSummaries,
 		eagerTasks,
+		secretsEnabled,
 	};
-	return renderPromptTemplate(resolvedCustomPrompt ? customSystemPromptTemplate : systemPromptTemplate, data);
+	let rendered = prompt.render(resolvedCustomPrompt ? customSystemPromptTemplate : systemPromptTemplate, data);
+
+	// When autoqa is active the report_tool_issue tool is in the tool set — nudge the agent.
+	if (toolNames.includes("report_tool_issue")) {
+		rendered +=
+			"\n\n<critical>\nThe `report_tool_issue` tool is available for automated QA. If ANY tool you call returns output that is unexpected, incorrect, malformed, or otherwise inconsistent with what you anticipated given the tool's described behavior and your parameters, call `report_tool_issue` with the tool name and a concise description of the discrepancy. Do not hesitate to report — false positives are acceptable.\n</critical>";
+	}
+
+	return rendered;
 }

package/src/task/agents.ts

@@ -4,18 +4,18 @@
  * Agents are embedded at build time via Bun's import with { type: "text" }.
  */
 import { Effort } from "@oh-my-pi/pi-ai";
-import { renderPromptTemplate } from "../config/prompt-templates";
+import { parseFrontmatter, prompt } from "@oh-my-pi/pi-utils";
 import { parseAgentFields } from "../discovery/helpers";
 import designerMd from "../prompts/agents/designer.md" with { type: "text" };
 import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
 import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
 import librarianMd from "../prompts/agents/librarian.md" with { type: "text" };
-import oracleMd from "../prompts/agents/oracle.md" with { type: "text" };
+
 import planMd from "../prompts/agents/plan.md" with { type: "text" };
 import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
 import taskMd from "../prompts/agents/task.md" with { type: "text" };
-import { parseFrontmatter } from "../utils/frontmatter";
+
 import type { AgentDefinition, AgentSource } from "./types";
 
 interface AgentFrontmatter {
@@ -35,9 +35,9 @@ interface EmbeddedAgentDef {
 }
 
 function buildAgentContent(def: EmbeddedAgentDef): string {
-	const body = renderPromptTemplate(def.template);
+	const body = prompt.render(def.template);
 	if (!def.frontmatter) return body;
-	return renderPromptTemplate(agentFrontmatterTemplate, { ...def.frontmatter, body });
+	return prompt.render(agentFrontmatterTemplate, { ...def.frontmatter, body });
 }
 
 const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
@@ -45,7 +45,6 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "plan.md", template: planMd },
 	{ fileName: "designer.md", template: designerMd },
 	{ fileName: "reviewer.md", template: reviewerMd },
-	{ fileName: "oracle.md", template: oracleMd },
 	{ fileName: "librarian.md", template: librarianMd },
 	{
 		fileName: "task.md",

package/src/task/commands.ts

@@ -4,16 +4,13 @@
  * Commands are embedded at build time via Bun's import with { type: "text" }.
  */
 import * as path from "node:path";
+import { parseFrontmatter, prompt } from "@oh-my-pi/pi-utils";
 import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import { loadCapability } from "../discovery";
 // Embed command markdown files at build time
 import initMd from "../prompts/agents/init.md" with { type: "text" };
-import { parseFrontmatter } from "../utils/frontmatter";
 
-const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
-	{ name: "init.md", content: renderPromptTemplate(initMd) },
-];
+const EMBEDDED_COMMANDS: { name: string; content: string }[] = [{ name: "init.md", content: prompt.render(initMd) }];
 
 export const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{ name: string; content: string }> = EMBEDDED_COMMANDS;