@oh-my-pi/pi-coding-agent 7.0.0 → 8.0.0

package/src/{core/tools/task → task}/types.ts

@@ -31,9 +31,6 @@ export const MAX_OUTPUT_BYTES = getEnv("OMP_TASK_MAX_OUTPUT_BYTES", 500_000);
 /** Maximum output lines per agent */
 export const MAX_OUTPUT_LINES = getEnv("OMP_TASK_MAX_OUTPUT_LINES", 5000);
 
-/** Maximum agents to show in description */
-export const MAX_AGENTS_IN_DESCRIPTION = getEnv("OMP_TASK_MAX_AGENTS_IN_DESCRIPTION", 10);
-
 /** EventBus channel for raw subagent events */
 export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
 
@@ -43,35 +40,28 @@ export const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
 /** Single task item for parallel execution */
 export const taskItemSchema = Type.Object({
 	id: Type.String({
-		description: "Short task identifier for display (max 32 chars, CamelCase, e.g. 'SessionStore', 'WebFetchFix')",
+		description: "Task ID, CamelCase, max 32 chars",
 		maxLength: 32,
 	}),
-	description: Type.String({ description: "Short description for UI display" }),
-	vars: Type.Record(Type.String(), Type.String(), {
-		description: "Template variables to fill {{placeholders}} in context",
-	}),
+	description: Type.String({ description: "Short description for display" }),
+	args: Type.Optional(
+		Type.Record(Type.String(), Type.String(), {
+			description: "Arguments to fill {{placeholders}} in context",
+		}),
+	),
 });
 
 export type TaskItem = Static<typeof taskItemSchema>;
 
 /** Task tool parameters */
 export const taskSchema = Type.Object({
-	agent: Type.String({ description: "Agent type to use for all tasks" }),
-	context: Type.String({ description: "Template with {{placeholders}} filled by task vars" }),
-	model: Type.Optional(
-		Type.String({
-			description: "Model override for all tasks (fuzzy matching, e.g. 'sonnet', 'opus')",
-		}),
-	),
+	agent: Type.String({ description: "Agent type for all tasks" }),
+	context: Type.String({ description: "Template with {{placeholders}} for args" }),
+	isolated: Type.Optional(Type.Boolean({ description: "Run in isolated git worktree" })),
 	output: Type.Optional(
-		Type.Record(Type.String(), Type.Unknown(), {
-			description: "JTD schema for structured subagent output",
-		}),
+		Type.Record(Type.String(), Type.Unknown(), { description: "JTD schema for structured output" }),
 	),
-	tasks: Type.Array(taskItemSchema, {
-		description: "Tasks to run in parallel",
-		maxItems: MAX_PARALLEL_TASKS,
-	}),
+	tasks: Type.Array(taskItemSchema, { description: "Tasks to run in parallel", maxItems: MAX_PARALLEL_TASKS }),
 });
 
 export type TaskParams = Static<typeof taskSchema>;
@@ -117,12 +107,12 @@ export interface AgentDefinition {
 /** Progress tracking for a single agent */
 export interface AgentProgress {
 	index: number;
-	taskId: string;
+	id: string;
 	agent: string;
 	agentSource: AgentSource;
 	status: "pending" | "running" | "completed" | "failed" | "aborted";
 	task: string;
-	vars?: Record<string, string>;
+	args?: Record<string, string>;
 	description?: string;
 	currentTool?: string;
 	currentToolArgs?: string;
@@ -140,11 +130,11 @@ export interface AgentProgress {
 /** Result from a single agent execution */
 export interface SingleResult {
 	index: number;
-	taskId: string;
+	id: string;
 	agent: string;
 	agentSource: AgentSource;
 	task: string;
-	vars?: Record<string, string>;
+	args?: Record<string, string>;
 	description?: string;
 	exitCode: number;
 	output: string;
@@ -159,9 +149,11 @@ export interface SingleResult {
 	usage?: Usage;
 	/** Output path for the task result */
 	outputPath?: string;
+	/** Patch path for isolated worktree output */
+	patchPath?: string;
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
 	extractedToolData?: Record<string, unknown[]>;
-	/** Output metadata for Output tool integration */
+	/** Output metadata for agent:// URL integration */
 	outputMeta?: { lineCount: number; charCount: number };
 }
 

package/src/{core/tools/task → task}/worker-protocol.ts

@@ -1,7 +1,7 @@
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { SerializedAuthStorage } from "../../auth-storage";
-import type { SerializedModelRegistry } from "../../model-registry";
-import type { Settings } from "../../settings-manager";
+import type { SerializedModelRegistry } from "$c/config/model-registry";
+import type { Settings } from "$c/config/settings-manager";
+import type { SerializedAuthStorage } from "$c/session/auth-storage";
 
 /**
  * MCP tool metadata passed from parent to worker for proxy tool creation.
@@ -22,7 +22,10 @@ export interface MCPToolMetadata {
 export interface MCPToolCallRequest {
 	type: "mcp_tool_call";
 	callId: string;
-	toolName: string;
+	/** Server name for routing to correct connection */
+	serverName: string;
+	/** Original MCP tool name (as expected by the MCP server) */
+	mcpToolName: string;
 	params: Record<string, unknown>;
 	timeoutMs?: number;
 }
@@ -84,6 +87,7 @@ export interface LspToolCallResponse {
 
 export interface SubagentWorkerStartPayload {
 	cwd: string;
+	worktree?: string;
 	task: string;
 	systemPrompt: string;
 	model?: string;

package/src/{core/tools/task → task}/worker.ts

@@ -17,18 +17,19 @@ import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { logger, postmortem, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
-import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
-import type { AgentSessionEvent } from "../../agent-session";
-import { AuthStorage } from "../../auth-storage";
-import type { CustomTool } from "../../custom-tools/types";
-import { ModelRegistry } from "../../model-registry";
-import { parseModelPattern, parseModelString } from "../../model-resolver";
-import { renderPromptTemplate } from "../../prompt-templates";
-import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
-import { SessionManager } from "../../session-manager";
-import { SettingsManager } from "../../settings-manager";
-import { type LspToolDetails, lspSchema } from "../lsp/types";
-import { getPythonToolDescription, type PythonToolDetails, type PythonToolParams, pythonSchema } from "../python";
+import { ModelRegistry } from "$c/config/model-registry";
+import { parseModelPattern, parseModelString } from "$c/config/model-resolver";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import { SettingsManager } from "$c/config/settings-manager";
+import type { CustomTool } from "$c/extensibility/custom-tools/types";
+import { type LspToolDetails, lspSchema } from "$c/lsp/types";
+import lspDescription from "$c/prompts/tools/lsp.md" with { type: "text" };
+import { createAgentSession, discoverAuthStorage, discoverModels } from "$c/sdk";
+import type { AgentSessionEvent } from "$c/session/agent-session";
+import { AuthStorage } from "$c/session/auth-storage";
+import { SessionManager } from "$c/session/session-manager";
+import { getPythonToolDescription, type PythonToolDetails, type PythonToolParams, pythonSchema } from "$c/tools/python";
+import { ToolAbortError } from "$c/tools/tool-errors";
 import type {
 	LspToolCallResponse,
 	MCPToolCallResponse,
@@ -88,7 +89,8 @@ function generateLspCallId(): string {
 }
 
 function callMCPToolViaParent(
-	toolName: string,
+	serverName: string,
+	mcpToolName: string,
 	params: Record<string, unknown>,
 	signal?: AbortSignal,
 	timeoutMs = MCP_CALL_TIMEOUT_MS,
@@ -99,7 +101,7 @@ function callMCPToolViaParent(
 	}>();
 	const callId = generateMCPCallId();
 	if (signal?.aborted) {
-		reject(new Error("Aborted"));
+		reject(new ToolAbortError());
 		return promise;
 	}
 
@@ -118,7 +120,7 @@ function callMCPToolViaParent(
 			"abort",
 			() => {
 				cleanup();
-				reject(new Error("Aborted"));
+				reject(new ToolAbortError());
 			},
 			{ once: true },
 		);
@@ -139,7 +141,8 @@ function callMCPToolViaParent(
 	postMessageSafe({
 		type: "mcp_tool_call",
 		callId,
-		toolName,
+		serverName,
+		mcpToolName,
 		params,
 		timeoutMs,
 	} as SubagentWorkerResponse);
@@ -155,7 +158,7 @@ function callPythonToolViaParent(
 	const { promise, resolve, reject } = Promise.withResolvers<PythonToolCallResponse["result"]>();
 	const callId = generatePythonCallId();
 	if (signal?.aborted) {
-		reject(new Error("Aborted"));
+		reject(new ToolAbortError());
 		return promise;
 	}
 
@@ -185,7 +188,7 @@ function callPythonToolViaParent(
 			() => {
 				cleanup();
 				sendCancel("Aborted");
-				reject(new Error("Aborted"));
+				reject(new ToolAbortError());
 			},
 			{ once: true },
 		);
@@ -221,7 +224,7 @@ function callLspToolViaParent(
 	const { promise, resolve, reject } = Promise.withResolvers<LspToolCallResponse["result"]>();
 	const callId = generateLspCallId();
 	if (signal?.aborted) {
-		reject(new Error("Aborted"));
+		reject(new ToolAbortError());
 		return promise;
 	}
 
@@ -245,7 +248,7 @@ function callLspToolViaParent(
 			"abort",
 			() => {
 				cleanup();
-				reject(new Error("Aborted"));
+				reject(new ToolAbortError());
 			},
 			{ once: true },
 		);
@@ -334,7 +337,8 @@ function createMCPProxyTool(metadata: MCPToolMetadata): CustomTool<TSchema> {
 		execute: async (_toolCallId, params, _onUpdate, _ctx, signal) => {
 			try {
 				const result = await callMCPToolViaParent(
-					metadata.name,
+					metadata.serverName,
+					metadata.mcpToolName,
 					params as Record<string, unknown>,
 					signal,
 					metadata.timeoutMs,
@@ -363,7 +367,7 @@ function createMCPProxyTool(metadata: MCPToolMetadata): CustomTool<TSchema> {
 }
 
 function getPythonCallTimeoutMs(params: PythonToolParams): number | undefined {
-	const timeout = params.timeoutMs;
+	const timeout = params.timeout;
 	if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) {
 		return Math.max(1000, Math.round(timeout * 1000) + 1000);
 	}
@@ -530,7 +534,7 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 		if (signal.aborted) {
 			aborted = true;
 			exitCode = 1;
-			throw new Error("Aborted");
+			throw new ToolAbortError();
 		}
 	};
 
@@ -538,9 +542,6 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 		// Check for pre-start abort
 		checkAbort();
 
-		// Set working directory (CLI does this implicitly)
-		process.chdir(payload.cwd);
-
 		// Use serialized auth/models if provided, otherwise discover from disk
 		let authStorage: AuthStorage;
 		let modelRegistry: ModelRegistry;
@@ -574,7 +575,7 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 		// Create session manager (equivalent to CLI's --session or --no-session)
 		const sessionManager = payload.sessionFile
 			? await SessionManager.open(payload.sessionFile)
-			: SessionManager.inMemory(payload.cwd);
+			: SessionManager.inMemory(payload.worktree ?? payload.cwd);
 		checkAbort();
 
 		// Use serialized settings if provided, otherwise use empty in-memory settings
@@ -585,9 +586,12 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 		// Note: hasUI: false disables interactive features
 		const completionInstruction =
 			"When finished, call the complete tool exactly once. Do not end with a plain-text final answer.";
+		const worktreeNotice = payload.worktree
+			? `You will work under this working tree: ${payload.worktree}. CRITICAL: Do not touch the original repository; only make changes inside this worktree.`
+			: "";
 
 		const { session } = await createAgentSession({
-			cwd: payload.cwd,
+			cwd: payload.worktree ?? payload.cwd,
 			authStorage,
 			modelRegistry,
 			settingsManager,
@@ -597,7 +601,8 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			outputSchema: payload.outputSchema,
 			requireCompleteTool: true,
 			// Append system prompt (equivalent to CLI's --append-system-prompt)
-			systemPrompt: (defaultPrompt) => `${defaultPrompt}\n\n${payload.systemPrompt}\n\n${completionInstruction}`,
+			systemPrompt: (defaultPrompt) =>
+				`${defaultPrompt}\n\n${payload.systemPrompt}\n\n${worktreeNotice}\n\n${completionInstruction}`,
 			sessionManager,
 			hasUI: false,
 			// Pass spawn restrictions to nested tasks

package/src/task/worktree.ts

@@ -0,0 +1,166 @@
+import { randomUUID } from "node:crypto";
+import { cp, mkdir, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { $ } from "bun";
+
+export interface WorktreeBaseline {
+	repoRoot: string;
+	staged: string;
+	unstaged: string;
+	untracked: string[];
+}
+
+export function getEncodedProjectName(cwd: string): string {
+	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+
+export async function getRepoRoot(cwd: string): Promise<string> {
+	const result = await $`git rev-parse --show-toplevel`.cwd(cwd).quiet().nothrow();
+	if (result.exitCode !== 0) {
+		throw new Error("Git repository not found for isolated task execution.");
+	}
+	const repoRoot = result.text().trim();
+	if (!repoRoot) {
+		throw new Error("Git repository root could not be resolved for isolated task execution.");
+	}
+	return repoRoot;
+}
+
+export async function ensureWorktree(baseCwd: string, id: string): Promise<string> {
+	const repoRoot = await getRepoRoot(baseCwd);
+	const encodedProject = getEncodedProjectName(repoRoot);
+	const worktreeDir = path.join(homedir(), ".omp", "wt", encodedProject, id);
+	await mkdir(path.dirname(worktreeDir), { recursive: true });
+	await $`git worktree remove -f ${worktreeDir}`.cwd(repoRoot).quiet().nothrow();
+	await rm(worktreeDir, { recursive: true, force: true });
+	await $`git worktree add --detach ${worktreeDir} HEAD`.cwd(repoRoot).quiet();
+	return worktreeDir;
+}
+
+export async function captureBaseline(repoRoot: string): Promise<WorktreeBaseline> {
+	const staged = await $`git diff --cached --binary`.cwd(repoRoot).quiet().text();
+	const unstaged = await $`git diff --binary`.cwd(repoRoot).quiet().text();
+	const untrackedRaw = await $`git ls-files --others --exclude-standard`.cwd(repoRoot).quiet().text();
+	const untracked = untrackedRaw
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+
+	return {
+		repoRoot,
+		staged,
+		unstaged,
+		untracked,
+	};
+}
+
+async function writeTempPatchFile(patch: string): Promise<string> {
+	const tempPath = path.join(tmpdir(), `omp-task-patch-${randomUUID()}.patch`);
+	await Bun.write(tempPath, patch);
+	return tempPath;
+}
+
+async function applyPatch(
+	cwd: string,
+	patch: string,
+	options?: { cached?: boolean; env?: Record<string, string> },
+): Promise<void> {
+	if (!patch.trim()) return;
+	const tempPath = await writeTempPatchFile(patch);
+	try {
+		const command = options?.cached ? $`git apply --cached --binary ${tempPath}` : $`git apply --binary ${tempPath}`;
+		let runner = command.cwd(cwd).quiet();
+		if (options?.env) {
+			runner = runner.env(options.env);
+		}
+		await runner;
+	} finally {
+		await rm(tempPath, { force: true });
+	}
+}
+
+export async function applyBaseline(worktreeDir: string, baseline: WorktreeBaseline): Promise<void> {
+	await applyPatch(worktreeDir, baseline.staged, { cached: true });
+	await applyPatch(worktreeDir, baseline.staged);
+	await applyPatch(worktreeDir, baseline.unstaged);
+
+	for (const entry of baseline.untracked) {
+		const source = path.join(baseline.repoRoot, entry);
+		const destination = path.join(worktreeDir, entry);
+		const exists = await Bun.file(source).exists();
+		if (!exists) continue;
+		await mkdir(path.dirname(destination), { recursive: true });
+		await cp(source, destination, { recursive: true });
+	}
+}
+
+async function applyPatchToIndex(cwd: string, patch: string, indexFile: string): Promise<void> {
+	if (!patch.trim()) return;
+	const tempPath = await writeTempPatchFile(patch);
+	try {
+		await $`git apply --cached --binary ${tempPath}`
+			.cwd(cwd)
+			.env({
+				GIT_INDEX_FILE: indexFile,
+			})
+			.quiet();
+	} finally {
+		await rm(tempPath, { force: true });
+	}
+}
+
+async function listUntracked(cwd: string): Promise<string[]> {
+	const raw = await $`git ls-files --others --exclude-standard`.cwd(cwd).quiet().text();
+	return raw
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+}
+
+export async function captureDeltaPatch(worktreeDir: string, baseline: WorktreeBaseline): Promise<string> {
+	const tempIndex = path.join(tmpdir(), `omp-task-index-${randomUUID()}`);
+	try {
+		await $`git read-tree HEAD`.cwd(worktreeDir).env({
+			GIT_INDEX_FILE: tempIndex,
+		});
+		await applyPatchToIndex(worktreeDir, baseline.staged, tempIndex);
+		await applyPatchToIndex(worktreeDir, baseline.unstaged, tempIndex);
+		const diff = await $`git diff --binary`
+			.cwd(worktreeDir)
+			.env({
+				GIT_INDEX_FILE: tempIndex,
+			})
+			.quiet()
+			.text();
+
+		const currentUntracked = await listUntracked(worktreeDir);
+		const baselineUntracked = new Set(baseline.untracked);
+		const newUntracked = currentUntracked.filter((entry) => !baselineUntracked.has(entry));
+
+		if (newUntracked.length === 0) return diff;
+
+		const untrackedDiffs = await Promise.all(
+			newUntracked.map((entry) =>
+				$`git diff --binary --no-index /dev/null ${entry}`.cwd(worktreeDir).quiet().nothrow().text(),
+			),
+		);
+		return `${diff}${diff && !diff.endsWith("\n") ? "\n" : ""}${untrackedDiffs.join("\n")}`;
+	} finally {
+		await rm(tempIndex, { force: true });
+	}
+}
+
+export async function cleanupWorktree(dir: string): Promise<void> {
+	try {
+		const commonDirRaw = await $`git rev-parse --git-common-dir`.cwd(dir).quiet().nothrow().text();
+		const commonDir = commonDirRaw.trim();
+		if (commonDir) {
+			const resolvedCommon = path.resolve(dir, commonDir);
+			const repoRoot = path.dirname(resolvedCommon);
+			await $`git worktree remove -f ${dir}`.cwd(repoRoot).quiet().nothrow();
+		}
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+}

package/src/{core/tools → tools}/ask.ts

@@ -19,10 +19,10 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { type Theme, theme } from "../../modes/interactive/theme/theme";
-import askDescription from "../../prompts/tools/ask.md" with { type: "text" };
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import { type Theme, theme } from "$c/modes/theme/theme";
+import askDescription from "$c/prompts/tools/ask.md" with { type: "text" };
 import type { ToolSession } from "./index";
 import { ToolUIKit } from "./render-utils";
 
@@ -31,29 +31,21 @@ import { ToolUIKit } from "./render-utils";
 // =============================================================================
 
 const OptionItem = Type.Object({
-	label: Type.String({ description: "Display label for this option" }),
+	label: Type.String({ description: "Display label" }),
 });
 
 const QuestionItem = Type.Object({
-	id: Type.String({ description: "Short identifier for this question (e.g., 'auth', 'cache')" }),
-	question: Type.String({ description: "The question text" }),
-	options: Type.Array(OptionItem, { description: "Options for this question" }),
-	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections for this question" })),
+	id: Type.String({ description: "Question ID, e.g. 'auth', 'cache'" }),
+	question: Type.String({ description: "Question text" }),
+	options: Type.Array(OptionItem, { description: "Available options" }),
+	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections" })),
 });
 
 const askSchema = Type.Object({
-	question: Type.Optional(Type.String({ description: "The question to ask the user" })),
-	options: Type.Optional(Type.Array(OptionItem, { description: "Available options for the user to choose from." })),
-	multi: Type.Optional(
-		Type.Boolean({
-			description: "Allow multiple options to be selected (default: false)",
-		}),
-	),
-	questions: Type.Optional(
-		Type.Array(QuestionItem, {
-			description: "Multiple questions to ask in sequence, each with their own options",
-		}),
-	),
+	question: Type.Optional(Type.String({ description: "Question to ask" })),
+	options: Type.Optional(Type.Array(OptionItem, { description: "Available options" })),
+	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections (default: false)" })),
+	questions: Type.Optional(Type.Array(QuestionItem, { description: "Multiple questions in sequence" })),
 });
 
 /** Result for a single question */

package/src/{core/tools → tools}/bash-interceptor.ts

@@ -6,7 +6,7 @@
  * the specialized tools instead.
  */
 
-import { type BashInterceptorRule, DEFAULT_BASH_INTERCEPTOR_RULES } from "../settings-manager";
+import { type BashInterceptorRule, DEFAULT_BASH_INTERCEPTOR_RULES } from "$c/config/settings-manager";
 
 export interface InterceptionResult {
 	/** If true, the bash command should be blocked */