@oh-my-pi/pi-coding-agent 14.5.8 → 14.5.9

package/src/session/compaction/compaction.ts

@@ -26,6 +26,7 @@ import {
 	getOpenAIResponsesHistoryPayload,
 	normalizeResponsesToolCallId,
 } from "@oh-my-pi/pi-ai/utils";
+import { countTokens } from "@oh-my-pi/pi-natives";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import compactionShortSummaryPrompt from "../../prompts/compaction/compaction-short-summary.md" with { type: "text" };
 import compactionSummaryPrompt from "../../prompts/compaction/compaction-summary.md" with { type: "text" };
@@ -218,7 +219,7 @@ export function shouldCompact(contextTokens: number, contextWindow: number, sett
 	return contextTokens > thresholdTokens;
 }
 
-function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
+export function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
 	// Fixed token limit takes priority over percentage
 	const thresholdTokens = settings.thresholdTokens;
 	if (typeof thresholdTokens === "number" && Number.isFinite(thresholdTokens) && thresholdTokens > 0) {
@@ -240,67 +241,79 @@ function resolveThresholdTokens(contextWindow: number, settings: CompactionSetti
 // ============================================================================
 
 /**
- * Estimate token count for a message using chars/4 heuristic.
- * This is conservative (overestimates tokens).
+ * Image content has no tokenizer representation; charge a fixed estimate
+ * matching what providers typically bill for inline images.
+ */
+const IMAGE_TOKEN_ESTIMATE = 1200;
+
+/**
+ * Estimate token count for a message using cl100k_base via the native
+ * tokenizer. This is not Claude's first-party tokenizer (Anthropic doesn't
+ * publish one) but is within ~5–10% across English/code text.
  */
 export function estimateTokens(message: AgentMessage): number {
-	let chars = 0;
+	const fragments: string[] = [];
+	let extra = 0;
 
 	switch (message.role) {
 		case "user": {
 			const content = (message as { content: string | Array<{ type: string; text?: string }> }).content;
 			if (typeof content === "string") {
-				chars = content.length;
+				fragments.push(content);
 			} else if (Array.isArray(content)) {
 				for (const block of content) {
 					if (block.type === "text" && block.text) {
-						chars += block.text.length;
+						fragments.push(block.text);
 					}
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "assistant": {
 			const assistant = message as AssistantMessage;
 			for (const block of assistant.content) {
 				if (block.type === "text") {
-					chars += block.text.length;
+					fragments.push(block.text);
 				} else if (block.type === "thinking") {
-					chars += block.thinking.length;
+					fragments.push(block.thinking);
 				} else if (block.type === "toolCall") {
-					chars += block.name.length + JSON.stringify(block.arguments).length;
+					fragments.push(block.name);
+					fragments.push(JSON.stringify(block.arguments));
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "hookMessage":
 		case "toolResult": {
 			if (typeof message.content === "string") {
-				chars = message.content.length;
+				fragments.push(message.content);
 			} else {
 				for (const block of message.content) {
 					if (block.type === "text" && block.text) {
-						chars += block.text.length;
-					}
-					if (block.type === "image") {
-						chars += 4800; // Estimate images as 4000 chars, or 1200 tokens
+						fragments.push(block.text);
+					} else if (block.type === "image") {
+						extra += IMAGE_TOKEN_ESTIMATE;
 					}
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "bashExecution": {
-			chars = message.command.length + message.output.length;
-			return Math.ceil(chars / 4);
+			fragments.push(message.command);
+			fragments.push(message.output);
+			break;
 		}
 		case "branchSummary":
 		case "compactionSummary": {
-			chars = message.summary.length;
-			return Math.ceil(chars / 4);
+			fragments.push(message.summary);
+			break;
 		}
+		default:
+			return 0;
 	}
 
-	return 0;
+	if (fragments.length === 0) return extra;
+	return extra + countTokens(fragments);
 }
 
 function estimateEntriesTokens(entries: SessionEntry[], startIndex: number, endIndex: number): number {

package/src/session/session-dump-format.ts

@@ -114,6 +114,7 @@ export function formatSessionDumpText(options: FormatSessionDumpTextOptions): st
 				if (c.type === "text") {
 					lines.push(c.text);
 				} else if (c.type === "thinking") {
+					if (c.thinking.trim().length === 0) continue;
 					lines.push("<thinking>");
 					lines.push(c.thinking);
 					lines.push("</thinking>\n");

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

@@ -123,11 +123,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 	},
 	{
 		name: "loop",
-		description: "Loop the agent: re-submit the same prompt every time it yields (Esc to stop)",
-		inlineHint: "<prompt>",
-		allowArgs: true,
-		handle: async (command, runtime) => {
-			await runtime.ctx.handleLoopCommand(command.args || undefined);
+		description:
+			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleLoopCommand();
 			runtime.ctx.editor.setText("");
 		},
 	},
@@ -356,6 +355,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "context",
+		description: "Show estimated context usage breakdown",
+		handle: (_command, runtime) => {
+			runtime.ctx.handleContextCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "extensions",
 		aliases: ["status"],

package/src/tools/debug.ts

@@ -52,85 +52,72 @@ import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
 const debugSchema = Type.Object({
-	action: StringEnum(
-		[
-			"launch",
-			"attach",
-			"set_breakpoint",
-			"remove_breakpoint",
-			"set_instruction_breakpoint",
-			"remove_instruction_breakpoint",
-			"data_breakpoint_info",
-			"set_data_breakpoint",
-			"remove_data_breakpoint",
-			"continue",
-			"step_over",
-			"step_in",
-			"step_out",
-			"pause",
-			"evaluate",
-			"stack_trace",
-			"threads",
-			"scopes",
-			"variables",
-			"disassemble",
-			"read_memory",
-			"write_memory",
-			"modules",
-			"loaded_sources",
-			"custom_request",
-			"output",
-			"terminate",
-			"sessions",
-		],
-		{ description: "dap debugger action" },
-	),
-	program: Type.Optional(Type.String({ description: "program path", examples: ["./my_app", "src/main.py"] })),
-	args: Type.Optional(Type.Array(Type.String(), { description: "program arguments", examples: [["--verbose"]] })),
-	adapter: Type.Optional(
-		Type.String({ description: "debugger adapter", examples: ["gdb", "lldb-dap", "debugpy", "dlv"] }),
-	),
-	cwd: Type.Optional(Type.String({ description: "working directory", examples: ["src/"] })),
-	file: Type.Optional(Type.String({ description: "source file", examples: ["src/main.c"] })),
-	line: Type.Optional(Type.Number({ description: "source line", examples: [42] })),
-	function: Type.Optional(Type.String({ description: "function name", examples: ["main", "handle_request"] })),
-	name: Type.Optional(Type.String({ description: "variable or data name", examples: ["counter", "buffer"] })),
-	condition: Type.Optional(Type.String({ description: "breakpoint condition", examples: ["i == 10", "x > 0"] })),
-	hit_condition: Type.Optional(Type.String({ description: "hit condition" })),
-	expression: Type.Optional(Type.String({ description: "expression to evaluate", examples: ["x + 1", "obj.field"] })),
+	action: StringEnum([
+		"launch",
+		"attach",
+		"set_breakpoint",
+		"remove_breakpoint",
+		"set_instruction_breakpoint",
+		"remove_instruction_breakpoint",
+		"data_breakpoint_info",
+		"set_data_breakpoint",
+		"remove_data_breakpoint",
+		"continue",
+		"step_over",
+		"step_in",
+		"step_out",
+		"pause",
+		"evaluate",
+		"stack_trace",
+		"threads",
+		"scopes",
+		"variables",
+		"disassemble",
+		"read_memory",
+		"write_memory",
+		"modules",
+		"loaded_sources",
+		"custom_request",
+		"output",
+		"terminate",
+		"sessions",
+	]),
+	program: Type.Optional(Type.String({ description: "program path" })),
+	args: Type.Optional(Type.Array(Type.String(), { description: "program arguments" })),
+	adapter: Type.Optional(Type.String({ description: "debugger adapter (gdb, lldb-dap, debugpy, dlv)" })),
+	cwd: Type.Optional(Type.String()),
+	file: Type.Optional(Type.String({ description: "source file" })),
+	line: Type.Optional(Type.Number({ description: "source line" })),
+	function: Type.Optional(Type.String({ description: "function name" })),
+	name: Type.Optional(Type.String({ description: "variable or data name" })),
+	condition: Type.Optional(Type.String({ description: "breakpoint condition" })),
+	hit_condition: Type.Optional(Type.String()),
+	expression: Type.Optional(Type.String({ description: "expression to evaluate" })),
 	context: Type.Optional(
-		Type.String({ description: "evaluate context", examples: ["watch", "repl", "hover", "variables", "clipboard"] }),
+		Type.String({ description: "evaluate context: watch | repl | hover | variables | clipboard" }),
 	),
-	frame_id: Type.Optional(Type.Number({ description: "stack frame id" })),
+	frame_id: Type.Optional(Type.Number()),
 	scope_id: Type.Optional(Type.Number({ description: "scope variables reference" })),
 	variable_ref: Type.Optional(Type.Number({ description: "variable reference" })),
-	pid: Type.Optional(Type.Number({ description: "process id for attach", examples: [12345] })),
-	port: Type.Optional(Type.Number({ description: "remote attach port", examples: [4711] })),
-	host: Type.Optional(Type.String({ description: "remote attach host", examples: ["127.0.0.1"] })),
+	pid: Type.Optional(Type.Number({ description: "process id for attach" })),
+	port: Type.Optional(Type.Number({ description: "remote attach port" })),
+	host: Type.Optional(Type.String({ description: "remote attach host" })),
 	levels: Type.Optional(Type.Number({ description: "max stack frames" })),
-	memory_reference: Type.Optional(
-		Type.String({ description: "memory reference or address", examples: ["0x7ffd1234"] }),
-	),
-	instruction_reference: Type.Optional(Type.String({ description: "instruction address or reference" })),
-	instruction_count: Type.Optional(Type.Number({ description: "instructions to disassemble" })),
-	instruction_offset: Type.Optional(Type.Number({ description: "instruction offset" })),
+	memory_reference: Type.Optional(Type.String({ description: "memory reference or address" })),
+	instruction_reference: Type.Optional(Type.String()),
+	instruction_count: Type.Optional(Type.Number()),
+	instruction_offset: Type.Optional(Type.Number()),
 	count: Type.Optional(Type.Number({ description: "bytes to read" })),
 	data: Type.Optional(Type.String({ description: "base64 memory payload" })),
 	data_id: Type.Optional(Type.String({ description: "data breakpoint id" })),
-	access_type: Type.Optional(
-		StringEnum(["read", "write", "readWrite"], { description: "data breakpoint access type" }),
-	),
+	access_type: Type.Optional(StringEnum(["read", "write", "readWrite"])),
 	command: Type.Optional(Type.String({ description: "custom dap request command" })),
-	arguments: Type.Optional(
-		Type.Record(Type.String(), Type.Any(), {
-			description: "custom request arguments",
-		}),
-	),
-	offset: Type.Optional(Type.Number({ description: "memory or instruction offset" })),
-	resolve_symbols: Type.Optional(Type.Boolean({ description: "resolve symbols during disassembly" })),
-	allow_partial: Type.Optional(Type.Boolean({ description: "allow partial writes" })),
-	start_module: Type.Optional(Type.Number({ description: "modules start index" })),
-	module_count: Type.Optional(Type.Number({ description: "max modules to fetch" })),
+	arguments: Type.Optional(Type.Record(Type.String(), Type.Any(), { description: "custom request arguments" })),
+	offset: Type.Optional(Type.Number()),
+	resolve_symbols: Type.Optional(Type.Boolean()),
+	allow_partial: Type.Optional(Type.Boolean()),
+	start_module: Type.Optional(Type.Number()),
+	module_count: Type.Optional(Type.Number()),
 	timeout: Type.Optional(Type.Number({ description: "per-request timeout seconds" })),
 });
 

package/src/tools/index.ts

@@ -37,11 +37,11 @@ import { NotebookTool } from "./notebook";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
+import { RecipeTool } from "./recipe";
 import { RenderMermaidTool } from "./render-mermaid";
 import { createReportToolIssueTool, isAutoQaEnabled } from "./report-tool-issue";
 import { ResolveTool } from "./resolve";
 import { reportFindingTool } from "./review";
-import { RunCommandTool } from "./run-command";
 import { SearchTool } from "./search";
 import { SearchToolBm25Tool } from "./search-tool-bm25";
 import { loadSshTool } from "./ssh";
@@ -76,11 +76,11 @@ export * from "./job";
 export * from "./notebook";
 export * from "./python";
 export * from "./read";
+export * from "./recipe";
 export * from "./render-mermaid";
 export * from "./report-tool-issue";
 export * from "./resolve";
 export * from "./review";
-export * from "./run-command";
 export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./ssh";
@@ -226,7 +226,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	rewind: RewindTool.createIf,
 	task: TaskTool.create,
 	job: JobTool.createIf,
-	run_command: RunCommandTool.createIf,
+	recipe: RecipeTool.createIf,
 	irc: IrcTool.createIf,
 	todo_write: s => new TodoWriteTool(s),
 	web_search: s => new WebSearchTool(s),
@@ -375,10 +375,10 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		}
 		if (
 			requestedTools.includes("bash") &&
-			!requestedTools.includes("run_command") &&
-			session.settings.get("runCommand.enabled")
+			!requestedTools.includes("recipe") &&
+			session.settings.get("recipe.enabled")
 		) {
-			requestedTools.push("run_command");
+			requestedTools.push("recipe");
 		}
 	}
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
@@ -402,7 +402,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
 		if (name === "irc") return session.settings.get("irc.enabled");
-		if (name === "run_command") return session.settings.get("runCommand.enabled");
+		if (name === "recipe") return session.settings.get("recipe.enabled");
 		if (name === "task") {
 			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;
 			const currentDepth = session.taskDepth ?? 0;

package/src/tools/{run-command → recipe}/index.ts

@@ -4,43 +4,43 @@ import { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
-import runCommandDescription from "../../prompts/tools/run-command.md" with { type: "text" };
+import recipeDescription from "../../prompts/tools/recipe.md" with { type: "text" };
 import type { ToolSession } from "..";
 import { type BashRenderContext, BashTool, type BashToolDetails } from "../bash";
-import { createRunCommandToolRenderer, type RunCommandRenderArgs } from "./render";
+import { createRecipeToolRenderer, type RecipeRenderArgs } from "./render";
 import { buildPromptModel, type DetectedRunner, resolveCommand } from "./runner";
 import { RUNNERS } from "./runners";
 
-const runCommandSchema = Type.Object({
+const recipeSchema = Type.Object({
 	op: Type.String({
 		description: 'task name and args, e.g. "test" or "build --release"',
 		examples: ["test", "build --release", "pkg:test --watch"],
 	}),
 });
 
-type RunCommandParams = Static<typeof runCommandSchema>;
+type RecipeParams = Static<typeof recipeSchema>;
 
-type RunCommandRenderResult = {
+type RecipeRenderResult = {
 	content: Array<{ type: string; text?: string }>;
 	details?: BashToolDetails;
 	isError?: boolean;
 };
 
-export class RunCommandTool implements AgentTool<typeof runCommandSchema, BashToolDetails, Theme> {
-	readonly name = "run_command";
+export class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetails, Theme> {
+	readonly name = "recipe";
 	readonly label = "Run";
 	readonly description: string;
-	readonly parameters = runCommandSchema;
+	readonly parameters = recipeSchema;
 	readonly strict = true;
 	readonly concurrency = "exclusive";
 	readonly mergeCallAndResult = true;
 	readonly inline = true;
-	readonly renderCall: (args: RunCommandRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
+	readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
 	readonly renderResult: (
-		result: RunCommandRenderResult,
+		result: RecipeRenderResult,
 		options: RenderResultOptions & { renderContext?: BashRenderContext },
 		uiTheme: Theme,
-		args?: RunCommandRenderArgs,
+		args?: RecipeRenderArgs,
 	) => Component;
 
 	readonly #bash: BashTool;
@@ -49,30 +49,30 @@ export class RunCommandTool implements AgentTool<typeof runCommandSchema, BashTo
 	constructor(session: ToolSession, runners: DetectedRunner[]) {
 		this.#runners = runners;
 		this.#bash = new BashTool(session);
-		this.description = prompt.render(runCommandDescription, buildPromptModel(runners));
-		const renderer = createRunCommandToolRenderer(runners);
+		this.description = prompt.render(recipeDescription, buildPromptModel(runners));
+		const renderer = createRecipeToolRenderer(runners);
 		this.renderCall = renderer.renderCall;
 		this.renderResult = renderer.renderResult;
 	}
 
-	static async createIf(session: ToolSession): Promise<RunCommandTool | null> {
-		if (!session.settings.get("runCommand.enabled")) return null;
+	static async createIf(session: ToolSession): Promise<RecipeTool | null> {
+		if (!session.settings.get("recipe.enabled")) return null;
 		const detected = (await Promise.all(RUNNERS.map(runner => runner.detect(session.cwd)))).filter(
 			(runner): runner is DetectedRunner => runner !== null && runner.tasks.length > 0,
 		);
 		if (detected.length === 0) return null;
-		return new RunCommandTool(session, detected);
+		return new RecipeTool(session, detected);
 	}
 
 	async execute(
 		toolCallId: string,
-		{ op }: RunCommandParams,
+		{ op }: RecipeParams,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
 		ctx?: AgentToolContext,
 	): Promise<AgentToolResult<BashToolDetails>> {
-		const command = resolveCommand(op, this.#runners);
-		return await this.#bash.execute(toolCallId, { command }, signal, onUpdate, ctx);
+		const { command, cwd } = resolveCommand(op, this.#runners);
+		return await this.#bash.execute(toolCallId, { command, cwd }, signal, onUpdate, ctx);
 	}
 }
 

package/src/tools/recipe/render.ts

@@ -0,0 +1,19 @@
+import { createShellRenderer } from "../bash";
+import type { DetectedRunner } from "./runner";
+import { commandFromOp, cwdFromOp, titleFromOp } from "./runner";
+
+export interface RecipeRenderArgs {
+	op?: string;
+	__partialJson?: string;
+	[key: string]: unknown;
+}
+
+export function createRecipeToolRenderer(runners: DetectedRunner[]) {
+	return createShellRenderer<RecipeRenderArgs>({
+		resolveTitle: args => titleFromOp(args?.op, runners),
+		resolveCommand: args => commandFromOp(args?.op, runners),
+		resolveCwd: args => cwdFromOp(args?.op, runners),
+	});
+}
+
+export const recipeToolRenderer = createRecipeToolRenderer([]);

package/src/tools/{run-command → recipe}/runner.ts

@@ -9,6 +9,8 @@ export interface RunnerTask {
 	commandPrefix?: string;
 	/** Token passed to the runner command; defaults to `name`. Used when display names are namespaced. */
 	commandName?: string;
+	/** Working directory for the task, relative to the session cwd; absent means the runner's root cwd. */
+	cwd?: string;
 }
 
 export interface DetectedRunner {
@@ -39,16 +41,20 @@ interface PromptTaskModel {
 	paramSig?: string;
 	command?: string;
 	doc?: string;
+	cwd?: string;
 }
 
+const PROMPT_TASK_LIMIT = 20;
+
 interface PromptRunnerModel {
 	id: string;
 	label: string;
 	commandPrefix: string;
 	tasks: PromptTaskModel[];
+	hiddenTaskCount?: number;
 }
 
-export interface RunCommandPromptModel {
+export interface RecipePromptModel {
 	[key: string]: unknown;
 	hasMultipleRunners: boolean;
 	ambiguityExampleRunner?: string;
@@ -101,7 +107,7 @@ function resolveRunnerAndTask(
 ): { runner: DetectedRunner; task: RunnerTask; tail: string } {
 	const { head, tail } = parseOp(op);
 	if (!head) {
-		throw new ToolError(`run_command op is empty. Available tasks:\n${formatAvailableTasks(runners)}`);
+		throw new ToolError(`recipe op is empty. Available tasks:\n${formatAvailableTasks(runners)}`);
 	}
 
 	const colonIndex = head.indexOf(":");
@@ -136,12 +142,18 @@ function resolveRunnerAndTask(
 	);
 }
 
-export function resolveCommand(op: string, runners: DetectedRunner[]): string {
+export interface ResolvedTask {
+	command: string;
+	cwd?: string;
+}
+
+export function resolveCommand(op: string, runners: DetectedRunner[]): ResolvedTask {
 	const { runner, task, tail } = resolveRunnerAndTask(op, runners);
-	return buildCommand(task.commandPrefix ?? runner.commandPrefix, task.commandName ?? task.name, tail);
+	const command = buildCommand(task.commandPrefix ?? runner.commandPrefix, task.commandName ?? task.name, tail);
+	return task.cwd ? { command, cwd: task.cwd } : { command };
 }
 
-export function commandFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined {
+export function resolveTaskFromOp(op: string | undefined, runners: DetectedRunner[]): ResolvedTask | undefined {
 	if (!op) return undefined;
 	try {
 		return resolveCommand(op, runners);
@@ -150,6 +162,14 @@ export function commandFromOp(op: string | undefined, runners: DetectedRunner[])
 	}
 }
 
+export function commandFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined {
+	return resolveTaskFromOp(op, runners)?.command;
+}
+
+export function cwdFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined {
+	return resolveTaskFromOp(op, runners)?.cwd;
+}
+
 export function titleFromOp(op: string | undefined, runners: DetectedRunner[]): string {
 	if (!op) return "Run";
 	const { head } = parseOp(op);
@@ -177,7 +197,7 @@ function findAmbiguityExample(runners: DetectedRunner[]): { runner: string; task
 	return firstRunner && firstTask ? { runner: firstRunner.id, task: firstTask.name } : undefined;
 }
 
-export function buildPromptModel(runners: DetectedRunner[]): RunCommandPromptModel {
+export function buildPromptModel(runners: DetectedRunner[]): RecipePromptModel {
 	const ambiguityExample = findAmbiguityExample(runners);
 	return {
 		hasMultipleRunners: runners.length > 1,
@@ -187,11 +207,12 @@ export function buildPromptModel(runners: DetectedRunner[]): RunCommandPromptMod
 			id: runner.id,
 			label: runner.label,
 			commandPrefix: runner.commandPrefix,
-			tasks: runner.tasks.map(task => ({
+			tasks: runner.tasks.slice(0, PROMPT_TASK_LIMIT).map(task => ({
 				name: task.name,
 				paramSig: task.parameters.length > 0 ? task.parameters.join(" ") : undefined,
 				command: buildCommand(task.commandPrefix ?? runner.commandPrefix, task.commandName ?? task.name, ""),
 				doc: task.doc,
+				cwd: task.cwd,
 			})),
 		})),
 	};