@oh-my-pi/pi-coding-agent 8.10.13 → 8.12.1

package/src/prompts/system/custom-system-prompt.md

@@ -5,43 +5,55 @@
 {{#if appendPrompt}}
 {{appendPrompt}}
 {{/if}}
-{{#if contextFiles.length}}
-# Project Context
+{{#ifAny projectTree contextFiles.length git.isRepo}}
+<project>
+{{#if projectTree}}
+## Files
+<tree>
+{{projectTree}}
+</tree>
+{{/if}}
 
-<project_context_files>
+{{#if contextFiles.length}}
+## Context
+<instructions>
 {{#list contextFiles join="\n"}}
 <file path="{{path}}">
 {{content}}
 </file>
 {{/list}}
-</project_context_files>
+</instructions>
 {{/if}}
+
 {{#if git.isRepo}}
-# Git Status
+## Version Control
+This is a snapshot. It does not update during the conversation.
 
-This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.
 Current branch: {{git.currentBranch}}
 Main branch: {{git.mainBranch}}
 
-Status:
 {{git.status}}
 
-Recent commits:
+### History
 {{git.commits}}
 {{/if}}
+</project>
+{{/ifAny}}
+
 {{#if skills.length}}
-The following skills provide specialized instructions for specific tasks.
-Use the read tool to load a skill's file when the task matches its description.
+Skills are specialized knowledge.
+They exist because someone learned the hard way.
 
-<available_skills>
+Scan descriptions against your task domain.
+If a skill covers what you're producing, read `skill://<name>` before proceeding.
+
+<skills>
 {{#list skills join="\n"}}
-<skill>
-<name>{{escapeXml name}}</name>
-<description>{{escapeXml description}}</description>
-<location>skill://{{escapeXml name}}</location>
+<skill name="{{name}}">
+{{description}}
 </skill>
 {{/list}}
-</available_skills>
+</skills>
 {{/if}}
 {{#if preloadedSkills.length}}
 The following skills are preloaded in full. Apply their instructions directly.
@@ -49,34 +61,28 @@ The following skills are preloaded in full. Apply their instructions directly.
 <preloaded_skills>
 {{#list preloadedSkills join="\n"}}
 <skill name="{{name}}">
-<location>skill://{{escapeXml name}}</location>
-<content>
 {{content}}
-</content>
 </skill>
 {{/list}}
 </preloaded_skills>
 {{/if}}
 {{#if rules.length}}
-The following rules define project-specific guidelines and constraints:
+Rules are local constraints.
+They exist because someone made a mistake here before.
+
+Read `rule://<name>` when working in their domain.
 
 <rules>
 {{#list rules join="\n"}}
-  <rule>
-    <name>{{escapeXml name}}</name>
-    <description>{{escapeXml description}}</description>
+<rule name="{{name}}">
+{{description}}
 {{#if globs.length}}
-    <globs>
-{{#list globs join="\n"}}
-      <glob>{{escapeXml this}}</glob>
-{{/list}}
-</globs>
+{{#list globs join="\n"}}<glob>{{this}}</glob>{{/list}}
 {{/if}}
-    <location>rule://{{escapeXml name}}</location>
 </rule>
 {{/list}}
 </rules>
 {{/if}}
 
 Current date and time: {{dateTime}}
-Current working directory: {{cwd}}
+Current working directory: {{cwd}}

package/src/prompts/system/system-prompt.md

@@ -221,22 +221,27 @@ It lies. The code that runs is not the code that works.
 - Resolve blockers before yielding.
 </procedure>
 
-<context>
+<project>
+{{#if projectTree}}
+## Files
+<tree>
+{{projectTree}}
+</tree>
+{{/if}}
+
 {{#if contextFiles.length}}
-<project_context_files>
+## Context
+<instructions>
 {{#list contextFiles join="\n"}}
 <file path="{{path}}">
 {{content}}
 </file>
 {{/list}}
-</project_context_files>
+</instructions>
 {{/if}}
-</context>
 
 {{#if git.isRepo}}
-<vcs>
-# Git Status
-
+## Version Control
 This is a snapshot. It does not update during the conversation.
 
 Current branch: {{git.currentBranch}}
@@ -244,23 +249,22 @@ Main branch: {{git.mainBranch}}
 
 {{git.status}}
 
-## History
-
+### History
 {{git.commits}}
-</vcs>
 {{/if}}
+</project>
+
 {{#if skills.length}}
 <skills>
 Skills are specialized knowledge.
 They exist because someone learned the hard way.
 
 Scan descriptions against your task domain.
-If a skill covers what you're producing, read it before proceeding.
+If a skill covers what you're producing, read `skill://<name>` before proceeding.
 
 {{#list skills join="\n"}}
 <skill name="{{name}}">
 {{description}}
-<path>skill://{{name}}</path>
 </skill>
 {{/list}}
 </skills>
@@ -271,7 +275,6 @@ The following skills are preloaded in full. Apply their instructions directly.
 
 {{#list preloadedSkills join="\n"}}
 <skill name="{{name}}">
-<location>skill://{{escapeXml name}}</location>
 {{content}}
 </skill>
 {{/list}}
@@ -282,12 +285,12 @@ The following skills are preloaded in full. Apply their instructions directly.
 Rules are local constraints.
 They exist because someone made a mistake here before.
 
-Load when working in their domain:
+Read `rule://<name>` when working in their domain.
+
 {{#list rules join="\n"}}
 <rule name="{{name}}">
 {{description}}
 {{#list globs join="\n"}}<glob>{{this}}</glob>{{/list}}
-<path>rule://{{name}}</path>
 </rule>
 {{/list}}
 </rules>

package/src/prompts/tools/patch.md

@@ -17,6 +17,7 @@ Performs patch operations on a file given a diff. Primary tool for modifying exi
 **Context Lines:**
 - Include enough ` `-prefixed lines to make match unique (usually 2–8 total)
 - Must exist in the file exactly as written (preserve indentation/trailing spaces)
+- When editing structured blocks (nested braces, tags, indented regions), include opening and closing lines in context so the edit stays inside the block
 </instruction>
 
 <parameters>
@@ -47,6 +48,9 @@ Returns success/failure status. On failure, returns error message indicating:
 - Always read the target file before editing
 - Copy anchors and context lines verbatim (including whitespace)
 - Never use anchors as comments (no line numbers, location labels, or placeholders like `@@ @@`)
+- Do not place new lines outside the intended block unless that is the explicit goal
+- If an edit fails or produces broken structure, re-read the file and produce a new patch from current content—do not retry the same diff
+- If indentation is wrong after editing, run the project's formatter (if available) rather than making repeated edit attempts
 </critical>
 
 <example name="create">
@@ -69,4 +73,6 @@ edit {"path":"obsolete.txt","op":"delete"}
 - Generic anchors: `import`, `export`, `describe`, `function`, `const`
 - Anchor comments: `line 207`, `top of file`, `near imports`, `...`
 - Editing without reading the file first (causes stale context errors)
+- Repeating the same addition in multiple hunks (creates duplicate blocks)
+- Falling back to full-file overwrites for minor changes (acceptable for major restructures or short files)
 </avoid>

package/src/session/agent-session.ts

@@ -1165,6 +1165,62 @@ export class AgentSession {
 			return;
 		}
 
+		const userContent: (TextContent | ImageContent)[] = [{ type: "text", text: expandedText }];
+		if (options?.images) {
+			userContent.push(...options.images);
+		}
+
+		await this._promptWithMessage(
+			{
+				role: "user",
+				content: userContent,
+				synthetic: options?.synthetic,
+				timestamp: Date.now(),
+			},
+			expandedText,
+			options,
+		);
+	}
+
+	async promptCustomMessage<T = unknown>(
+		message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details">,
+		options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice">,
+	): Promise<void> {
+		const textContent =
+			typeof message.content === "string"
+				? message.content
+				: message.content
+						.filter((content): content is TextContent => content.type === "text")
+						.map(content => content.text)
+						.join("");
+
+		if (this.isStreaming) {
+			if (!options?.streamingBehavior) {
+				throw new Error(
+					"Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.",
+				);
+			}
+			await this.sendCustomMessage(message, { deliverAs: options.streamingBehavior });
+			return;
+		}
+
+		const customMessage: CustomMessage<T> = {
+			role: "custom",
+			customType: message.customType,
+			content: message.content,
+			display: message.display,
+			details: message.details,
+			timestamp: Date.now(),
+		};
+
+		await this._promptWithMessage(customMessage, textContent, options);
+	}
+
+	private async _promptWithMessage(
+		message: AgentMessage,
+		expandedText: string,
+		options?: Pick<PromptOptions, "toolChoice" | "images">,
+	): Promise<void> {
 		// Flush any pending bash messages before the new prompt
 		this._flushPendingBashMessages();
 		this._flushPendingPythonMessages();
@@ -1207,17 +1263,7 @@ export class AgentSession {
 			messages.push(planModeMessage);
 		}
 
-		// Add user message
-		const userContent: (TextContent | ImageContent)[] = [{ type: "text", text: expandedText }];
-		if (options?.images) {
-			userContent.push(...options.images);
-		}
-		messages.push({
-			role: "user",
-			content: userContent,
-			synthetic: options?.synthetic,
-			timestamp: Date.now(),
-		});
+		messages.push(message);
 
 		// Inject any pending "nextTurn" messages as context alongside the user message
 		for (const msg of this._pendingNextTurnMessages) {

package/src/session/messages.ts

@@ -15,6 +15,15 @@ import { formatOutputNotice } from "../tools/output-meta";
 const COMPACTION_SUMMARY_TEMPLATE = compactionSummaryContextPrompt;
 const BRANCH_SUMMARY_TEMPLATE = branchSummaryContextPrompt;
 
+export const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
+
+export interface SkillPromptDetails {
+	name: string;
+	path: string;
+	args?: string;
+	lineCount: number;
+}
+
 function getPrunedToolResultContent(message: ToolResultMessage): (TextContent | ImageContent)[] {
 	if (message.prunedAt === undefined) {
 		return message.content;

package/src/system-prompt.ts

@@ -1,6 +1,8 @@
 /**
  * System prompt construction and project context loading
  */
+import type * as fsTypes from "node:fs";
+import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $ } from "bun";
@@ -14,6 +16,8 @@ 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 type { ToolName } from "./tools";
+import { runRg } from "./tools/grep";
+import { ensureTool } from "./utils/tools-manager";
 
 interface GitContext {
 	isRepo: boolean;
@@ -129,6 +133,24 @@ function stripQuotes(value: string): string {
 
 const AGENTS_MD_PATTERN = "**/AGENTS.md";
 const AGENTS_MD_LIMIT = 200;
+const PROJECT_TREE_LIMIT = 2000;
+const PROJECT_TREE_PER_DIR_LIMIT = 10;
+const PROJECT_TREE_PER_DIR_DEPTH = 2;
+const PROJECT_TREE_IGNORED = new Set([
+	".git",
+	".hg",
+	".svn",
+	".next",
+	".turbo",
+	".cache",
+	".venv",
+	".idea",
+	".vscode",
+	"build",
+	"dist",
+	"node_modules",
+	"target",
+]);
 
 interface AgentsMdSearch {
 	scopePath: string;
@@ -166,6 +188,273 @@ function buildAgentsMdSearch(cwd: string): AgentsMdSearch {
 	};
 }
 
+type ProjectTreeEntry = {
+	name: string;
+	isDirectory: boolean;
+	path: string;
+};
+
+type ProjectTreeScan = {
+	children: Map<string, ProjectTreeEntry[]>;
+	truncated: boolean;
+	truncatedDirs: Set<string>;
+};
+
+const RG_TIMEOUT_MS = 5000;
+
+/**
+ * Scan project tree using ripgrep to respect gitignore.
+ * Returns null if ripgrep is unavailable.
+ */
+async function scanProjectTreeWithRg(root: string): Promise<ProjectTreeScan | null> {
+	const rgPath = await ensureTool("rg", { silent: true });
+	if (!rgPath) return null;
+
+	const args = ["--files", "--no-require-git", "--color=never", root];
+
+	let stdout: string;
+	try {
+		const signal = AbortSignal.timeout(RG_TIMEOUT_MS);
+		const result = await runRg(rgPath, args, signal);
+		if (result.exitCode !== 0 && result.exitCode !== 1) return null;
+		stdout = result.stdout;
+	} catch {
+		return null;
+	}
+
+	// Build directory contents map from file list
+	// Map<dirPath, Map<entryPath, isDirectory>>
+	const dirContents = new Map<string, Map<string, boolean>>();
+	dirContents.set(root, new Map());
+
+	for (const line of stdout.split("\n")) {
+		const filePath = line.trim();
+		if (!filePath) continue;
+
+		// Check static ignores on path components
+		const relative = path.relative(root, filePath);
+		const parts = relative.split(path.sep);
+		if (parts.some(p => PROJECT_TREE_IGNORED.has(p))) continue;
+
+		// Add file to its parent directory
+		const parent = path.dirname(filePath);
+		if (!dirContents.has(parent)) dirContents.set(parent, new Map());
+		dirContents.get(parent)!.set(filePath, false);
+
+		// Add all intermediate directories
+		let dir = parent;
+		while (dir.length >= root.length && dir !== path.dirname(dir)) {
+			const parentDir = path.dirname(dir);
+			if (!dirContents.has(parentDir)) dirContents.set(parentDir, new Map());
+			dirContents.get(parentDir)!.set(dir, true);
+			dir = parentDir;
+		}
+	}
+
+	// BFS to build the tree with limits
+	const children = new Map<string, ProjectTreeEntry[]>();
+	let entryCount = 0;
+	let truncated = false;
+	const truncatedDirs = new Set<string>();
+
+	const queue: Array<{ dirPath: string; depth: number }> = [{ dirPath: root, depth: 0 }];
+	let cursor = 0;
+
+	while (cursor < queue.length && !truncated) {
+		const { dirPath, depth } = queue[cursor];
+		cursor += 1;
+
+		const contents = dirContents.get(dirPath);
+		if (!contents || contents.size === 0) continue;
+
+		// Get stats for sorting
+		const entries = Array.from(contents.entries());
+		const withStats = await Promise.all(
+			entries.map(async ([entryPath, isDirectory]) => {
+				try {
+					const stats = await fs.stat(entryPath);
+					return { entryPath, isDirectory, mtimeMs: stats.mtimeMs };
+				} catch {
+					return { entryPath, isDirectory, mtimeMs: 0 };
+				}
+			}),
+		);
+
+		withStats.sort((a, b) => {
+			if (a.mtimeMs !== b.mtimeMs) return b.mtimeMs - a.mtimeMs;
+			return path.basename(a.entryPath).localeCompare(path.basename(b.entryPath));
+		});
+
+		const perDirLimit = depth >= PROJECT_TREE_PER_DIR_DEPTH ? PROJECT_TREE_PER_DIR_LIMIT : null;
+		const limited = perDirLimit === null ? withStats : withStats.slice(0, perDirLimit);
+		const hasMoreEntries = perDirLimit !== null && withStats.length > perDirLimit;
+
+		const mapped: ProjectTreeEntry[] = [];
+		for (const { entryPath, isDirectory } of limited) {
+			if (entryCount >= PROJECT_TREE_LIMIT) {
+				truncated = true;
+				break;
+			}
+
+			mapped.push({
+				name: path.basename(entryPath),
+				isDirectory,
+				path: entryPath,
+			});
+			entryCount += 1;
+
+			if (isDirectory) {
+				queue.push({ dirPath: entryPath, depth: depth + 1 });
+			}
+		}
+
+		if (!truncated && hasMoreEntries) {
+			truncatedDirs.add(dirPath);
+		}
+		children.set(dirPath, mapped);
+	}
+
+	return { children, truncated, truncatedDirs };
+}
+
+/**
+ * Fallback scan using readdir when ripgrep is unavailable.
+ */
+async function scanProjectTreeFallback(root: string): Promise<ProjectTreeScan> {
+	const children = new Map<string, ProjectTreeEntry[]>();
+	let entryCount = 0;
+	let truncated = false;
+	const truncatedDirs = new Set<string>();
+
+	const queue: Array<{ dirPath: string; depth: number }> = [{ dirPath: root, depth: 0 }];
+	let cursor = 0;
+
+	while (cursor < queue.length && !truncated) {
+		const { dirPath, depth } = queue[cursor];
+		cursor += 1;
+		let entries: fsTypes.Dirent[];
+		try {
+			entries = await fs.readdir(dirPath, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+
+		const filtered = entries.filter(entry => !PROJECT_TREE_IGNORED.has(entry.name));
+		const withStats = await Promise.all(
+			filtered.map(async entry => {
+				const entryPath = path.join(dirPath, entry.name);
+				try {
+					const stats = await fs.stat(entryPath);
+					return { entry, entryPath, mtimeMs: stats.mtimeMs };
+				} catch {
+					return { entry, entryPath, mtimeMs: 0 };
+				}
+			}),
+		);
+
+		withStats.sort((a, b) => {
+			if (a.mtimeMs !== b.mtimeMs) return b.mtimeMs - a.mtimeMs;
+			return a.entry.name.localeCompare(b.entry.name);
+		});
+
+		const perDirLimit = depth >= PROJECT_TREE_PER_DIR_DEPTH ? PROJECT_TREE_PER_DIR_LIMIT : null;
+		const limited = perDirLimit === null ? withStats : withStats.slice(0, perDirLimit);
+		const hasMoreEntries = perDirLimit !== null && withStats.length > perDirLimit;
+
+		const mapped: ProjectTreeEntry[] = [];
+		for (const entryWithStat of limited) {
+			if (entryCount >= PROJECT_TREE_LIMIT) {
+				truncated = true;
+				break;
+			}
+
+			mapped.push({
+				name: entryWithStat.entry.name,
+				isDirectory: entryWithStat.entry.isDirectory(),
+				path: entryWithStat.entryPath,
+			});
+			entryCount += 1;
+
+			if (entryWithStat.entry.isDirectory()) {
+				queue.push({ dirPath: entryWithStat.entryPath, depth: depth + 1 });
+			}
+		}
+
+		if (!truncated && hasMoreEntries) {
+			truncatedDirs.add(dirPath);
+		}
+		children.set(dirPath, mapped);
+	}
+
+	return { children, truncated, truncatedDirs };
+}
+
+async function scanProjectTree(root: string): Promise<ProjectTreeScan> {
+	const rgResult = await scanProjectTreeWithRg(root);
+	if (rgResult) return rgResult;
+	return scanProjectTreeFallback(root);
+}
+
+function renderProjectTree(scan: ProjectTreeScan, root: string): string {
+	const lines: string[] = [];
+
+	const collapseDir = (dirPath: string): { path: string; entries: ProjectTreeEntry[] } | null => {
+		let currentPath = dirPath;
+		while (true) {
+			const entries = scan.children.get(currentPath);
+			if (!entries || entries.length === 0) return null;
+			const files = entries.filter(entry => !entry.isDirectory);
+			const dirs = entries.filter(entry => entry.isDirectory);
+			if (files.length === 0 && dirs.length === 1 && !scan.truncatedDirs.has(currentPath)) {
+				currentPath = dirs[0].path;
+				continue;
+			}
+			return { path: currentPath, entries };
+		}
+	};
+
+	const renderDir = (dirPath: string, indent: string, isRoot: boolean): void => {
+		const collapsed = collapseDir(dirPath);
+		if (!collapsed) return;
+		const { path: collapsedPath, entries } = collapsed;
+
+		// For non-root directories, print the header and indent contents
+		const contentIndent = isRoot ? indent : `${indent}  `;
+		if (!isRoot) {
+			const relative = path.relative(root, collapsedPath) || ".";
+			lines.push(`${indent}@ ${relative}`);
+		}
+
+		const files = entries.filter(entry => !entry.isDirectory);
+		const dirs = entries.filter(entry => entry.isDirectory);
+
+		for (const entry of files) {
+			lines.push(`${contentIndent}- ${entry.name}`);
+		}
+
+		if (scan.truncatedDirs.has(collapsedPath)) {
+			lines.push(`${contentIndent}- …`);
+		}
+
+		for (const entry of dirs) {
+			renderDir(entry.path, contentIndent, false);
+		}
+	};
+
+	renderDir(root, "", true);
+
+	if (scan.truncated) {
+		lines.push("…");
+	}
+
+	return lines.join("\n");
+}
+
+async function buildProjectTreeSnapshot(root: string): Promise<string> {
+	const scan = await scanProjectTree(root);
+	return renderProjectTree(scan, root);
+}
+
 function getOsName(): string {
 	switch (process.platform) {
 		case "win32":
@@ -707,6 +996,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	// Resolve context files: use provided or discover
 	const contextFiles = providedContextFiles ?? (await loadProjectContextFiles({ cwd: resolvedCwd }));
 	const agentsMdSearch = buildAgentsMdSearch(resolvedCwd);
+	const projectTree = await buildProjectTreeSnapshot(resolvedCwd);
 
 	// Build tool descriptions array
 	// Priority: toolNames (explicit list) > tools (Map) > defaults
@@ -744,6 +1034,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			customPrompt: resolvedCustomPrompt,
 			appendPrompt: resolvedAppendPrompt ?? "",
 			contextFiles,
+			projectTree,
 			agentsMdSearch,
 			git,
 			skills: filteredSkills,
@@ -759,6 +1050,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		environment: await getEnvironmentInfo(),
 		systemPromptCustomization: systemPromptCustomization ?? "",
 		contextFiles,
+		projectTree,
 		agentsMdSearch,
 		git,
 		skills: filteredSkills,

package/src/task/agents.ts

@@ -5,6 +5,7 @@
  */
 import { renderPromptTemplate } from "../config/prompt-templates";
 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" };
@@ -37,6 +38,7 @@ function buildAgentContent(def: EmbeddedAgentDef): string {
 const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "explore.md", template: exploreMd },
 	{ fileName: "plan.md", template: planMd },
+	{ fileName: "designer.md", template: designerMd },
 	{ fileName: "reviewer.md", template: reviewerMd },
 	{
 		fileName: "task.md",
@@ -57,15 +59,6 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 		},
 		template: taskMd,
 	},
-	{
-		fileName: "deep_task.md",
-		frontmatter: {
-			name: "deep_task",
-			description: "Deep task for comprehensive reasoning",
-			model: "pi/slow",
-		},
-		template: taskMd,
-	},
 ];
 
 const EMBEDDED_AGENTS: { name: string; content: string }[] = EMBEDDED_AGENT_DEFS.map(def => ({