@oh-my-pi/pi-coding-agent 2.3.1337 → 3.1.1337

package/src/core/tools/task/commands.ts

@@ -4,9 +4,9 @@
  * Commands are embedded at build time via Bun's import with { type: "text" }.
  */
 
-import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { type SlashCommand, slashCommandCapability } from "../../../capability/slash-command";
+import { loadSync } from "../../../discovery";
 
 // Embed command markdown files at build time
 import architectPlanMd from "./bundled-commands/architect-plan.md" with { type: "text" };
@@ -61,84 +61,6 @@ function parseFrontmatter(content: string): { frontmatter: Record<string, string
 	return { frontmatter, body };
 }
 
-/**
- * Load commands from a directory (for user/project commands).
- */
-function loadCommandsFromDir(dir: string, source: "user" | "project"): WorkflowCommand[] {
-	const commands: WorkflowCommand[] = [];
-
-	if (!fs.existsSync(dir)) {
-		return commands;
-	}
-
-	let entries: fs.Dirent[];
-	try {
-		entries = fs.readdirSync(dir, { withFileTypes: true });
-	} catch {
-		return commands;
-	}
-
-	for (const entry of entries) {
-		if (!entry.name.endsWith(".md")) continue;
-
-		const filePath = path.join(dir, entry.name);
-
-		try {
-			if (!fs.statSync(filePath).isFile()) continue;
-		} catch {
-			continue;
-		}
-
-		let content: string;
-		try {
-			content = fs.readFileSync(filePath, "utf-8");
-		} catch {
-			continue;
-		}
-
-		const { frontmatter, body } = parseFrontmatter(content);
-
-		// Name is filename without extension
-		const name = entry.name.replace(/\.md$/, "");
-
-		commands.push({
-			name,
-			description: frontmatter.description || "",
-			instructions: body,
-			source,
-			filePath,
-		});
-	}
-
-	return commands;
-}
-
-/**
- * Check if path is a directory.
- */
-function isDirectory(p: string): boolean {
-	try {
-		return fs.statSync(p).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Find nearest directory by walking up from cwd.
- */
-function findNearestDir(cwd: string, relPath: string): string | null {
-	let currentDir = cwd;
-	while (true) {
-		const candidate = path.join(currentDir, relPath);
-		if (isDirectory(candidate)) return candidate;
-
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) return null;
-		currentDir = parentDir;
-	}
-}
-
 /** Cache for bundled commands */
 let bundledCommandsCache: WorkflowCommand[] | null = null;
 
@@ -172,43 +94,44 @@ export function loadBundledCommands(): WorkflowCommand[] {
 /**
  * Discover all available commands.
  *
- * Precedence: project > user > bundled
+ * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
  */
 export function discoverCommands(cwd: string): WorkflowCommand[] {
-	const commandMap = new Map<string, WorkflowCommand>();
+	const resolvedCwd = path.resolve(cwd);
 
-	// Bundled commands (lowest priority)
-	for (const cmd of loadBundledCommands()) {
-		commandMap.set(cmd.name, cmd);
-	}
+	// Load slash commands from capability API
+	const result = loadSync<SlashCommand>(slashCommandCapability.id, { cwd: resolvedCwd });
+
+	const commands: WorkflowCommand[] = [];
+	const seen = new Set<string>();
 
-	// User commands
-	const userPiDir = path.join(os.homedir(), ".pi", "agent", "commands");
-	const userClaudeDir = path.join(os.homedir(), ".claude", "commands");
+	// Convert SlashCommand to WorkflowCommand format
+	for (const cmd of result.items) {
+		if (seen.has(cmd.name)) continue;
 
-	for (const cmd of loadCommandsFromDir(userClaudeDir, "user")) {
-		commandMap.set(cmd.name, cmd);
-	}
-	for (const cmd of loadCommandsFromDir(userPiDir, "user")) {
-		commandMap.set(cmd.name, cmd);
-	}
+		const { frontmatter, body } = parseFrontmatter(cmd.content);
 
-	// Project commands (highest priority)
-	const projectPiDir = findNearestDir(cwd, ".pi/commands");
-	const projectClaudeDir = findNearestDir(cwd, ".claude/commands");
+		// Map capability levels to WorkflowCommand source
+		const source: "bundled" | "user" | "project" = cmd.level === "native" ? "bundled" : cmd.level;
 
-	if (projectClaudeDir) {
-		for (const cmd of loadCommandsFromDir(projectClaudeDir, "project")) {
-			commandMap.set(cmd.name, cmd);
-		}
+		commands.push({
+			name: cmd.name,
+			description: frontmatter.description || "",
+			instructions: body,
+			source,
+			filePath: cmd.path,
+		});
+		seen.add(cmd.name);
 	}
-	if (projectPiDir) {
-		for (const cmd of loadCommandsFromDir(projectPiDir, "project")) {
-			commandMap.set(cmd.name, cmd);
-		}
+
+	// Add bundled commands if not already present
+	for (const cmd of loadBundledCommands()) {
+		if (seen.has(cmd.name)) continue;
+		commands.push(cmd);
+		seen.add(cmd.name);
 	}
 
-	return Array.from(commandMap.values());
+	return commands;
 }
 
 /**

package/src/core/tools/task/discovery.ts

@@ -2,17 +2,19 @@
  * Agent discovery from filesystem.
  *
  * Discovers agent definitions from:
- *   - ~/.pi/agent/agents/*.md (user-level, primary)
- *   - ~/.claude/agents/*.md (user-level, fallback)
- *   - .pi/agents/*.md (project-level, primary)
- *   - .claude/agents/*.md (project-level, fallback)
+ *   - ~/.omp/agent/agents/*.md (user-level, primary)
+ *   - ~/.pi/agent/agents/*.md (user-level, legacy)
+ *   - ~/.claude/agents/*.md (user-level, legacy)
+ *   - .omp/agents/*.md (project-level, primary)
+ *   - .pi/agents/*.md (project-level, legacy)
+ *   - .claude/agents/*.md (project-level, legacy)
  *
  * Agent files use markdown with YAML frontmatter.
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { findAllNearestProjectConfigDirs, getConfigDirs } from "../../../config";
 import { loadBundledAgents } from "./agents";
 import type { AgentDefinition, AgentSource } from "./types";
 
@@ -76,7 +78,7 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[]
 	for (const entry of entries) {
 		if (!entry.name.endsWith(".md")) continue;
 
-		const filePath = path.join(dir, entry.name);
+		const filePath = path.resolve(dir, entry.name);
 
 		// Handle both regular files and symlinks
 		try {
@@ -104,6 +106,26 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[]
 			.map((t) => t.trim())
 			.filter(Boolean);
 
+		// Parse spawns field
+		let spawns: string[] | "*" | undefined;
+		if (frontmatter.spawns !== undefined) {
+			const spawnsRaw = frontmatter.spawns.trim();
+			if (spawnsRaw === "*") {
+				spawns = "*";
+			} else if (spawnsRaw) {
+				spawns = spawnsRaw
+					.split(",")
+					.map((s) => s.trim())
+					.filter(Boolean);
+				if (spawns.length === 0) spawns = undefined;
+			}
+		}
+
+		// Backward compat: infer spawns: "*" when tools includes "task"
+		if (spawns === undefined && tools?.includes("task")) {
+			spawns = "*";
+		}
+
 		const recursive =
 			frontmatter.recursive === undefined
 				? undefined
@@ -113,6 +135,7 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[]
 			name: frontmatter.name,
 			description: frontmatter.description,
 			tools: tools && tools.length > 0 ? tools : undefined,
+			spawns,
 			model: frontmatter.model,
 			recursive,
 			systemPrompt: body,
@@ -124,80 +147,66 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[]
 	return agents;
 }
 
-/**
- * Check if path is a directory.
- */
-function isDirectory(p: string): boolean {
-	try {
-		return fs.statSync(p).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Find nearest directory by walking up from cwd.
- */
-function findNearestDir(cwd: string, relPath: string): string | null {
-	let currentDir = cwd;
-	while (true) {
-		const candidate = path.join(currentDir, relPath);
-		if (isDirectory(candidate)) return candidate;
-
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) return null;
-		currentDir = parentDir;
-	}
-}
-
 /**
  * Discover agents from filesystem and merge with bundled agents.
  *
- * Precedence (highest wins): project > user > bundled
- * Within each level: .pi > .claude
+ * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
  *
  * @param cwd - Current working directory for project agent discovery
  */
 export function discoverAgents(cwd: string): DiscoveryResult {
-	// Primary directories (.pi)
-	const userPiDir = path.join(os.homedir(), ".pi", "agent", "agents");
-	const projectPiDir = findNearestDir(cwd, ".pi/agents");
-
-	// Fallback directories (.claude)
-	const userClaudeDir = path.join(os.homedir(), ".claude", "agents");
-	const projectClaudeDir = findNearestDir(cwd, ".claude/agents");
-
-	const agentMap = new Map<string, AgentDefinition>();
-
-	// 1. Bundled agents (lowest priority)
-	for (const agent of loadBundledAgents()) {
-		agentMap.set(agent.name, agent);
+	const resolvedCwd = path.resolve(cwd);
+	const agentSources = Array.from(new Set(getConfigDirs("", { project: false }).map((entry) => entry.source)));
+
+	// Get user directories (priority order: .omp, .pi, .claude, ...)
+	const userDirs = getConfigDirs("agents", { project: false })
+		.filter((entry) => agentSources.includes(entry.source))
+		.map((entry) => ({
+			...entry,
+			path: path.resolve(entry.path),
+		}));
+
+	// Get project directories by walking up from cwd (priority order)
+	const projectDirs = findAllNearestProjectConfigDirs("agents", resolvedCwd)
+		.filter((entry) => agentSources.includes(entry.source))
+		.map((entry) => ({
+			...entry,
+			path: path.resolve(entry.path),
+		}));
+
+	const orderedSources = agentSources.filter(
+		(source) =>
+			userDirs.some((entry) => entry.source === source) || projectDirs.some((entry) => entry.source === source),
+	);
+
+	const orderedDirs: Array<{ dir: string; source: AgentSource }> = [];
+	for (const source of orderedSources) {
+		const project = projectDirs.find((entry) => entry.source === source);
+		if (project) orderedDirs.push({ dir: project.path, source: "project" });
+		const user = userDirs.find((entry) => entry.source === source);
+		if (user) orderedDirs.push({ dir: user.path, source: "user" });
 	}
 
-	// 2. User agents (.claude then .pi - .pi overrides .claude)
-	for (const agent of loadAgentsFromDir(userClaudeDir, "user")) {
-		agentMap.set(agent.name, agent);
-	}
-	for (const agent of loadAgentsFromDir(userPiDir, "user")) {
-		agentMap.set(agent.name, agent);
-	}
+	const agents: AgentDefinition[] = [];
+	const seen = new Set<string>();
 
-	// 3. Project agents (highest priority - .claude then .pi)
-	if (projectClaudeDir) {
-		for (const agent of loadAgentsFromDir(projectClaudeDir, "project")) {
-			agentMap.set(agent.name, agent);
+	for (const { dir, source } of orderedDirs) {
+		for (const agent of loadAgentsFromDir(dir, source)) {
+			if (seen.has(agent.name)) continue;
+			agents.push(agent);
+			seen.add(agent.name);
 		}
 	}
-	if (projectPiDir) {
-		for (const agent of loadAgentsFromDir(projectPiDir, "project")) {
-			agentMap.set(agent.name, agent);
-		}
+
+	for (const agent of loadBundledAgents()) {
+		if (seen.has(agent.name)) continue;
+		agents.push(agent);
+		seen.add(agent.name);
 	}
 
-	return {
-		agents: Array.from(agentMap.values()),
-		projectAgentsDir: projectPiDir,
-	};
+	const projectAgentsDir = projectDirs.length > 0 ? projectDirs[0].path : null;
+
+	return { agents, projectAgentsDir };
 }
 
 /**

package/src/core/tools/task/executor.ts

@@ -1,7 +1,7 @@
 /**
  * Subprocess execution for subagents.
  *
- * Spawns `pi` in JSON mode to execute tasks with isolated context.
+ * Spawns `omp` in JSON mode to execute tasks with isolated context.
  * Parses JSON events for progress tracking.
  */
 
@@ -18,15 +18,16 @@ import {
 	type AgentProgress,
 	MAX_OUTPUT_BYTES,
 	MAX_OUTPUT_LINES,
-	PI_BLOCKED_AGENT_ENV,
+	OMP_BLOCKED_AGENT_ENV,
+	OMP_SPAWNS_ENV,
 	type SingleResult,
 } from "./types";
 
-/** pi command: 'pi.cmd' on Windows, 'pi' elsewhere */
-const PI_CMD = process.platform === "win32" ? "pi.cmd" : "pi";
+/** omp command: 'omp.cmd' on Windows, 'omp' elsewhere */
+const OMP_CMD = process.platform === "win32" ? "omp.cmd" : "omp";
 
 /** Windows shell option for spawn */
-const PI_SHELL_OPT = process.platform === "win32";
+const OMP_SHELL_OPT = process.platform === "win32";
 
 /** Options for subprocess execution */
 export interface ExecutorOptions {
@@ -143,7 +144,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	const tempDir = os.tmpdir();
 	const promptFile = path.join(
 		tempDir,
-		`pi-agent-${agent.name}-${Date.now()}-${Math.random().toString(36).slice(2)}.md`,
+		`omp-agent-${agent.name}-${Date.now()}-${Math.random().toString(36).slice(2)}.md`,
 	);
 
 	try {
@@ -193,7 +194,12 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	// Add tools if specified
 	if (agent.tools && agent.tools.length > 0) {
-		args.push("--tools", agent.tools.join(","));
+		let toolList = agent.tools;
+		// Auto-include task tool if spawns defined but task not in tools
+		if (agent.spawns !== undefined && !toolList.includes("task")) {
+			toolList = [...toolList, "task"];
+		}
+		args.push("--tools", toolList.join(","));
 	}
 
 	// Resolve and add model
@@ -217,14 +223,23 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	// Set up environment - block same-agent recursion unless explicitly recursive
 	const env = { ...process.env };
 	if (!agent.recursive) {
-		env[PI_BLOCKED_AGENT_ENV] = agent.name;
+		env[OMP_BLOCKED_AGENT_ENV] = agent.name;
+	}
+
+	// Propagate spawn restrictions to subprocess
+	if (agent.spawns === undefined) {
+		env[OMP_SPAWNS_ENV] = ""; // No spawns = deny all
+	} else if (agent.spawns === "*") {
+		env[OMP_SPAWNS_ENV] = "*";
+	} else {
+		env[OMP_SPAWNS_ENV] = agent.spawns.join(",");
 	}
 
 	// Spawn subprocess
-	const proc = spawn(PI_CMD, args, {
+	const proc = spawn(OMP_CMD, args, {
 		cwd,
 		stdio: ["ignore", "pipe", "pipe"],
-		shell: PI_SHELL_OPT,
+		shell: OMP_SHELL_OPT,
 		env,
 	});
 

package/src/core/tools/task/index.ts

@@ -2,9 +2,9 @@
  * Task tool - Delegate tasks to specialized agents.
  *
  * Discovers agent definitions from:
- *   - Bundled agents (shipped with pi-coding-agent)
- *   - ~/.pi/agent/agents/*.md (user-level)
- *   - .pi/agents/*.md (project-level)
+ *   - Bundled agents (shipped with omp-coding-agent)
+ *   - ~/.omp/agent/agents/*.md (user-level)
+ *   - .omp/agents/*.md (project-level)
  *
  * Supports:
  *   - Single agent execution
@@ -25,8 +25,9 @@ import {
 	MAX_AGENTS_IN_DESCRIPTION,
 	MAX_CONCURRENCY,
 	MAX_PARALLEL_TASKS,
-	PI_BLOCKED_AGENT_ENV,
-	PI_NO_SUBAGENTS_ENV,
+	OMP_BLOCKED_AGENT_ENV,
+	OMP_NO_SUBAGENTS_ENV,
+	OMP_SPAWNS_ENV,
 	type TaskToolDetails,
 	taskSchema,
 } from "./types";
@@ -122,13 +123,13 @@ function buildDescription(cwd: string): string {
 		`- tasks: Array of {agent, task, model?} - tasks to run in parallel (max ${MAX_PARALLEL_TASKS}, ${MAX_CONCURRENCY} concurrent)`,
 	);
 	lines.push(
-		'  - model: (optional) Override the agent\'s default model with fuzzy matching (e.g., "sonnet", "codex", "5.2"). Supports comma-separated fallbacks: "gpt, opus" tries gpt first, then opus. Use "default" for pi\'s default model',
+		'  - model: (optional) Override the agent\'s default model with fuzzy matching (e.g., "sonnet", "codex", "5.2"). Supports comma-separated fallbacks: "gpt, opus" tries gpt first, then opus. Use "default" for omp\'s default model',
 	);
 	lines.push(
 		"- context: (optional) Shared context string prepended to all task prompts - use this to avoid repeating instructions",
 	);
 	lines.push("");
-	lines.push("Results are always written to {tempdir}/pi-task-{runId}/task_{agent}_{index}.md");
+	lines.push("Results are always written to {tempdir}/omp-task-{runId}/task_{agent}_{index}.md");
 	lines.push("");
 	lines.push("Example usage:");
 	lines.push("");
@@ -173,7 +174,7 @@ function buildDescription(cwd: string): string {
 	lines.push('    { "agent": "explore", "task": "Search in tests/" }');
 	lines.push("  ]");
 	lines.push("}");
-	lines.push("Results → {tempdir}/pi-task-{runId}/task_explore_*.md");
+	lines.push("Results → {tempdir}/omp-task-{runId}/task_explore_*.md");
 	lines.push("</example>");
 
 	return lines.join("\n");
@@ -189,7 +190,7 @@ export function createTaskTool(
 ): AgentTool<typeof taskSchema, TaskToolDetails, Theme> {
 	const hasOutputTool = options?.availableTools?.has("output") ?? false;
 	// Check if subagents are completely inhibited (legacy recursion prevention)
-	if (process.env[PI_NO_SUBAGENTS_ENV]) {
+	if (process.env[OMP_NO_SUBAGENTS_ENV]) {
 		return {
 			name: "task",
 			label: "Task",
@@ -207,7 +208,7 @@ export function createTaskTool(
 	}
 
 	// Check for same-agent blocking (allows other agent types)
-	const blockedAgent = process.env[PI_BLOCKED_AGENT_ENV];
+	const blockedAgent = process.env[OMP_BLOCKED_AGENT_ENV];
 
 	return {
 		name: "task",
@@ -321,6 +322,30 @@ export function createTaskTool(
 					}
 				}
 
+				// Check spawn restrictions from parent
+				const parentSpawns = process.env[OMP_SPAWNS_ENV];
+				const isSpawnAllowed = (agentName: string): boolean => {
+					if (parentSpawns === undefined) return true; // Root = allow all
+					if (parentSpawns === "") return false; // Empty = deny all
+					if (parentSpawns === "*") return true; // Wildcard = allow all
+					const allowed = new Set(parentSpawns.split(",").map((s) => s.trim()));
+					return allowed.has(agentName);
+				};
+
+				for (const task of tasks) {
+					if (!isSpawnAllowed(task.agent)) {
+						const allowed = parentSpawns === "" ? "none (spawns disabled for this agent)" : parentSpawns;
+						return {
+							content: [{ type: "text", text: `Cannot spawn '${task.agent}'. Allowed: ${allowed}` }],
+							details: {
+								projectAgentsDir,
+								results: [],
+								totalDurationMs: Date.now() - startTime,
+							},
+						};
+					}
+				}
+
 				// Initialize progress for all tasks
 				for (let i = 0; i < tasks.length; i++) {
 					const agentCfg = getAgent(agents, tasks[i].agent);

package/src/core/tools/task/model-resolver.ts

@@ -8,19 +8,18 @@
  *   - Fuzzy match: "opus" → "p-anthropic/claude-opus-4-5"
  *   - Comma fallback: "gpt, opus" → tries gpt first, then opus
  *   - "default" → undefined (use system default)
- *   - "pi/slow" → configured slow model from settings
+ *   - "omp/slow" → configured slow model from settings
  */
 
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { type Settings, settingsCapability } from "../../../capability/settings";
+import { loadSync } from "../../../discovery";
 
-/** pi command: 'pi.cmd' on Windows, 'pi' elsewhere */
-const PI_CMD = process.platform === "win32" ? "pi.cmd" : "pi";
+/** omp command: 'omp.cmd' on Windows, 'omp' elsewhere */
+const OMP_CMD = process.platform === "win32" ? "omp.cmd" : "omp";
 
 /** Windows shell option for spawn/spawnSync */
-const PI_SHELL_OPT = process.platform === "win32";
+const OMP_SHELL_OPT = process.platform === "win32";
 
 /** Cache for available models (provider/modelId format) */
 let cachedModels: string[] | null = null;
@@ -31,7 +30,7 @@ let cacheExpiry = 0;
 const CACHE_TTL_MS = 5 * 60 * 1000;
 
 /**
- * Get available models from `pi --list-models`.
+ * Get available models from `omp --list-models`.
  * Returns models in "provider/modelId" format.
  * Caches the result for performance.
  */
@@ -42,10 +41,10 @@ export function getAvailableModels(): string[] {
 	}
 
 	try {
-		const result = spawnSync(PI_CMD, ["--list-models"], {
+		const result = spawnSync(OMP_CMD, ["--list-models"], {
 			encoding: "utf-8",
 			timeout: 5000,
-			shell: PI_SHELL_OPT,
+			shell: OMP_SHELL_OPT,
 		});
 
 		if (result.status !== 0 || !result.stdout) {
@@ -83,26 +82,29 @@ export function clearModelCache(): void {
 }
 
 /**
- * Load model roles from settings file.
+ * Load model roles from settings files using capability API.
  */
 function loadModelRoles(): Record<string, string> {
-	try {
-		const settingsPath = join(homedir(), ".pi", "agent", "settings.json");
-		if (!existsSync(settingsPath)) return {};
-		const content = readFileSync(settingsPath, "utf-8");
-		const settings = JSON.parse(content);
-		return settings.modelRoles ?? {};
-	} catch {
-		return {};
+	const result = loadSync<Settings>(settingsCapability.id, { cwd: process.cwd() });
+
+	// Merge all settings, prioritizing first (highest priority)
+	let modelRoles: Record<string, string> = {};
+	for (const settings of result.items.reverse()) {
+		const roles = settings.data.modelRoles as Record<string, string> | undefined;
+		if (roles) {
+			modelRoles = { ...modelRoles, ...roles };
+		}
 	}
+
+	return modelRoles;
 }
 
 /**
- * Resolve a pi/<role> alias to a model string.
+ * Resolve an omp/<role> alias to a model string.
  * Looks up the role in settings.modelRoles and returns the configured model.
  * Returns undefined if the role isn't configured.
  */
-function resolvePiAlias(role: string, availableModels: string[]): string | undefined {
+function resolveOmpAlias(role: string, availableModels: string[]): string | undefined {
 	const roles = loadModelRoles();
 
 	// Look up role in settings (case-insensitive)
@@ -148,10 +150,10 @@ export function resolveModelPattern(pattern: string | undefined, availableModels
 		.filter(Boolean);
 
 	for (const p of patterns) {
-		// Handle pi/<role> aliases - looks up role in settings.modelRoles
-		if (p.toLowerCase().startsWith("pi/")) {
-			const role = p.slice(3); // Remove "pi/" prefix
-			const resolved = resolvePiAlias(role, models);
+		// Handle omp/<role> aliases - looks up role in settings.modelRoles
+		if (p.toLowerCase().startsWith("omp/")) {
+			const role = p.slice(4); // Remove "omp/" prefix
+			const resolved = resolveOmpAlias(role, models);
 			if (resolved) return resolved;
 			continue; // Role not configured, try next pattern
 		}

package/src/core/tools/task/types.ts

@@ -28,10 +28,13 @@ export const MAX_OUTPUT_LINES = 5000;
 export const MAX_AGENTS_IN_DESCRIPTION = 10;
 
 /** Environment variable to inhibit subagent spawning (legacy, still checked for backwards compat) */
-export const PI_NO_SUBAGENTS_ENV = "PI_NO_SUBAGENTS";
+export const OMP_NO_SUBAGENTS_ENV = "OMP_NO_SUBAGENTS";
 
 /** Environment variable containing blocked agent name (self-recursion prevention) */
-export const PI_BLOCKED_AGENT_ENV = "PI_BLOCKED_AGENT";
+export const OMP_BLOCKED_AGENT_ENV = "OMP_BLOCKED_AGENT";
+
+/** Environment variable containing allowed spawn list (propagated to subprocesses) */
+export const OMP_SPAWNS_ENV = "OMP_SPAWNS";
 
 /** Task tool parameters */
 export const taskSchema = Type.Object({
@@ -74,6 +77,7 @@ export interface AgentDefinition {
 	description: string;
 	systemPrompt: string;
 	tools?: string[];
+	spawns?: string[] | "*";
 	model?: string;
 	recursive?: boolean;
 	source: AgentSource;