@oh-my-pi/pi-coding-agent 13.0.1 → 13.1.0

package/src/patch/index.ts

@@ -34,9 +34,8 @@ import { enforcePlanModeWrite, resolvePlanPath } from "../tools/plan-mode-guard"
 import { applyPatch } from "./applicator";
 import { generateDiffString, generateUnifiedDiffString, replaceText } from "./diff";
 import { findMatch } from "./fuzzy";
-import { applyHashlineEdits, computeLineHash, type HashlineEdit, type LineTag, parseTag } from "./hashline";
+import { type Anchor, applyHashlineEdits, computeLineHash, type HashlineEdit, parseTag } from "./hashline";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
-import { buildNormativeUpdateInput } from "./normative";
 import { type EditToolDetails, getLspBatchRequest } from "./shared";
 // Internal imports
 import type { FileSystem, Operation, PatchInput } from "./types";
@@ -168,7 +167,7 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
 	});
 }
 
-export function hashlineParseContent(edit: string | string[] | null): string[] {
+export function hashlineParseText(edit: string[] | string | null): string[] {
 	if (edit === null) return [];
 	if (Array.isArray(edit)) return edit;
 	const lines = stripNewLinePrefixes(edit.split("\n"));
@@ -177,52 +176,45 @@ export function hashlineParseContent(edit: string | string[] | null): string[] {
 	return lines;
 }
 
-const hashlineEditSpecSchema = Type.Object(
+const hashlineEditSchema = Type.Object(
 	{
-		op: StringEnum(["replace", "append", "prepend", "insert"], {
-			description: "Operation type",
-		}),
-		first: Type.Optional(Type.String({ description: 'First/start anchor tag in "LINE#ID" format' })),
-		last: Type.Optional(Type.String({ description: 'Last/end anchor tag in "LINE#ID" format' })),
-		content: Type.Union([
+		op: StringEnum(["replace", "append", "prepend"]),
+		pos: Type.Optional(Type.String({ description: "anchor" })),
+		end: Type.Optional(Type.String({ description: "limit position" })),
+		lines: Type.Union([
+			Type.Array(Type.String(), { description: "content (preferred format)" }),
+			Type.String(),
 			Type.Null(),
-			Type.Array(Type.String(), { description: "Content lines" }),
-			Type.String({ description: "Content line" }),
 		]),
 	},
 	{ additionalProperties: false },
 );
 
-const hashlineEditSchema = Type.Object(
+const hashlineEditParamsSchema = Type.Object(
 	{
-		path: Type.String({ description: "File path (relative or absolute)" }),
-		edits: Type.Array(hashlineEditSpecSchema, {
-			description: "Changes to apply to the file at `path`",
-			minItems: 0,
-		}),
-		delete: Type.Optional(Type.Boolean({ description: "Delete the file when true" })),
-		rename: Type.Optional(Type.String({ description: "New path if moving" })),
+		path: Type.String({ description: "path" }),
+		edits: Type.Array(hashlineEditSchema, { description: "edits over $path" }),
+		delete: Type.Optional(Type.Boolean({ description: "If true, delete $path" })),
+		move: Type.Optional(Type.String({ description: "If set, move $path to $move" })),
 	},
 	{ additionalProperties: false },
 );
 
-export type HashlineToolEdit = Static<typeof hashlineEditSpecSchema>;
-export type HashlineParams = Static<typeof hashlineEditSchema>;
+export type HashlineToolEdit = Static<typeof hashlineEditSchema>;
+export type HashlineParams = Static<typeof hashlineEditParamsSchema>;
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Resilient anchor resolution
 // ═══════════════════════════════════════════════════════════════════════════
 
 /**
- * Map flat tool-schema edits (first/last) into typed HashlineEdit objects.
+ * Map flat tool-schema edits (tag/end) into typed HashlineEdit objects.
  *
  * Resilient: as long as at least one anchor exists, we execute.
- * - replace + first only → single-line replace (tag = first)
- * - replace + first + last → range replace
- * - append + first or last → append after that anchor
- * - prepend + first or last → prepend before that anchor
- * - insert + first + last → insert between them
- * - insert + one anchor → degrade to append/prepend
+ * - replace + tag only → single-line replace
+ * - replace + tag + end → range replace
+ * - append + tag or end → append after that anchor
+ * - prepend + tag or end → prepend before that anchor
  * - no anchors → file-level append/prepend (only for those ops)
  *
  * Unknown ops default to "replace".
@@ -230,51 +222,29 @@ export type HashlineParams = Static<typeof hashlineEditSchema>;
 function resolveEditAnchors(edits: HashlineToolEdit[]): HashlineEdit[] {
 	const result: HashlineEdit[] = [];
 	for (const edit of edits) {
-		const content = hashlineParseContent(edit.content);
-		const first = edit.first ? tryParseTag(edit.first) : undefined;
-		const last = edit.last ? tryParseTag(edit.last) : undefined;
+		const lines = hashlineParseText(edit.lines);
+		const tag = edit.pos ? tryParseTag(edit.pos) : undefined;
+		const end = edit.end ? tryParseTag(edit.end) : undefined;
 
 		// Normalize op — default unknown values to "replace"
-		const op = edit.op === "append" || edit.op === "prepend" || edit.op === "insert" ? edit.op : "replace";
-
+		const op = edit.op === "append" || edit.op === "prepend" ? edit.op : "replace";
 		switch (op) {
 			case "replace": {
-				if (first && last) {
-					result.push({ op: "replace", first, last, content });
-				} else if (first) {
-					result.push({ op: "replace", tag: first, content });
-				} else if (last) {
-					result.push({ op: "replace", tag: last, content });
+				if (tag && end) {
+					result.push({ op: "replace", pos: tag, end, lines });
+				} else if (tag || end) {
+					result.push({ op: "replace", pos: tag || end!, lines });
 				} else {
-					throw new Error("Replace requires at least one anchor (first or last).");
+					throw new Error("Replace requires at least one anchor (tag or end).");
 				}
 				break;
 			}
 			case "append": {
-				// Prefer first as the "after" anchor; fall back to last
-				const anchor = first ?? last;
-				result.push({ op: "append", ...(anchor ? { after: anchor } : {}), content });
+				result.push({ op: "append", pos: tag ?? end, lines });
 				break;
 			}
 			case "prepend": {
-				// Prefer last as the "before" anchor; fall back to first
-				const anchor = last ?? first;
-				result.push({ op: "prepend", ...(anchor ? { before: anchor } : {}), content });
-				break;
-			}
-			case "insert": {
-				if (first && last) {
-					result.push({ op: "insert", after: first, before: last, content });
-				} else if (first) {
-					// Degrade: insert after first
-					result.push({ op: "append", after: first, content });
-				} else if (last) {
-					// Degrade: insert before last
-					result.push({ op: "prepend", before: last, content });
-				} else {
-					// No anchors — append to end
-					result.push({ op: "append", content });
-				}
+				result.push({ op: "prepend", pos: end ?? tag, lines });
 				break;
 			}
 		}
@@ -283,7 +253,7 @@ function resolveEditAnchors(edits: HashlineToolEdit[]): HashlineEdit[] {
 }
 
 /** Parse a tag, returning undefined instead of throwing on garbage. */
-function tryParseTag(raw: string): LineTag | undefined {
+function tryParseTag(raw: string): Anchor | undefined {
 	try {
 		return parseTag(raw);
 	} catch {
@@ -379,11 +349,11 @@ function mergeDiagnosticsWithWarnings(
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
 
-type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditSchema;
+type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditParamsSchema;
 
 export type EditMode = "replace" | "patch" | "hashline";
 
-export const DEFAULT_EDIT_MODE: EditMode = "patch";
+export const DEFAULT_EDIT_MODE: EditMode = "hashline";
 
 export function normalizeEditMode(mode?: string | null): EditMode | null {
 	switch (mode) {
@@ -408,6 +378,7 @@ export class EditTool implements AgentTool<TInput> {
 	readonly label = "Edit";
 	readonly nonAbortable = true;
 	readonly concurrency = "exclusive";
+	readonly strict = true;
 
 	readonly #allowFuzzy: boolean;
 	readonly #fuzzyThreshold: number;
@@ -499,7 +470,7 @@ export class EditTool implements AgentTool<TInput> {
 			case "patch":
 				return patchEditSchema;
 			case "hashline":
-				return hashlineEditSchema;
+				return hashlineEditParamsSchema;
 			default:
 				return replaceEditSchema;
 		}
@@ -518,21 +489,20 @@ export class EditTool implements AgentTool<TInput> {
 		// Hashline mode execution
 		// ─────────────────────────────────────────────────────────────────
 		if (this.mode === "hashline") {
-			const { path, edits, delete: deleteFile, rename } = params as HashlineParams;
+			const { path, edits, delete: deleteFile, move } = params as HashlineParams;
 
-			enforcePlanModeWrite(this.session, path, { op: deleteFile ? "delete" : "update", rename });
+			enforcePlanModeWrite(this.session, path, { op: deleteFile ? "delete" : "update", move });
 
 			if (path.endsWith(".ipynb") && edits?.length > 0) {
 				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
 			}
 
 			const absolutePath = resolvePlanPath(this.session, path);
-			const resolvedRename = rename ? resolvePlanPath(this.session, rename) : undefined;
-			const file = Bun.file(absolutePath);
+			const resolvedMove = move ? resolvePlanPath(this.session, move) : undefined;
 
 			if (deleteFile) {
-				if (await file.exists()) {
-					await file.unlink();
+				if (await fs.exists(absolutePath)) {
+					await fs.unlink(absolutePath);
 				}
 				invalidateFsScanAfterDelete(absolutePath);
 				return {
@@ -545,21 +515,21 @@ export class EditTool implements AgentTool<TInput> {
 				};
 			}
 
-			if (!(await file.exists())) {
-				const content: string[] = [];
+			if (!(await fs.exists(absolutePath))) {
+				const lines: string[] = [];
 				for (const edit of edits) {
 					// For file creation, only anchorless appends/prepends are valid
-					if ((edit.op === "append" || edit.op === "prepend") && !edit.first && !edit.last) {
+					if ((edit.op === "append" || edit.op === "prepend") && !edit.pos && !edit.end) {
 						if (edit.op === "prepend") {
-							content.unshift(...hashlineParseContent(edit.content));
+							lines.unshift(...hashlineParseText(edit.lines));
 						} else {
-							content.push(...hashlineParseContent(edit.content));
+							lines.push(...hashlineParseText(edit.lines));
 						}
 					} else {
 						throw new Error(`File not found: ${path}`);
 					}
 				}
-				await file.write(content.join("\n"));
+				await fs.writeFile(absolutePath, lines.join("\n"));
 				return {
 					content: [{ type: "text", text: `Created ${path}` }],
 					details: {
@@ -572,29 +542,29 @@ export class EditTool implements AgentTool<TInput> {
 
 			const anchorEdits = resolveEditAnchors(edits);
 
-			const rawContent = await file.text();
-			const { bom, text: content } = stripBom(rawContent);
-			const originalEnding = detectLineEnding(content);
-			const originalNormalized = normalizeToLF(content);
-			let normalizedContent = originalNormalized;
+			const rawContent = await fs.readFile(absolutePath, "utf-8");
+			const { bom, text } = stripBom(rawContent);
+			const originalEnding = detectLineEnding(text);
+			const originalNormalized = normalizeToLF(text);
+			let normalizedText = originalNormalized;
 
-			// Apply anchor-based edits first (set, set_range, insert)
-			const anchorResult = applyHashlineEdits(normalizedContent, anchorEdits);
-			normalizedContent = anchorResult.content;
+			// Apply anchor-based edits first (replace, append, prepend)
+			const anchorResult = applyHashlineEdits(normalizedText, anchorEdits);
+			normalizedText = anchorResult.lines;
 
 			const result = {
-				content: normalizedContent,
+				text: normalizedText,
 				firstChangedLine: anchorResult.firstChangedLine,
 				warnings: anchorResult.warnings,
 				noopEdits: anchorResult.noopEdits,
 			};
-			if (originalNormalized === result.content && !rename) {
+			if (originalNormalized === result.text && !move) {
 				let diagnostic = `No changes made to ${path}. The edits produced identical content.`;
 				if (result.noopEdits && result.noopEdits.length > 0) {
 					const details = result.noopEdits
 						.map(
 							e =>
-								`Edit ${e.editIndex}: replacement for ${e.loc} is identical to current content:\n  ${e.loc}| ${e.currentContent}`,
+								`Edit ${e.editIndex}: replacement for ${e.loc} is identical to current content:\n  ${e.loc}| ${e.current}`,
 						)
 						.join("\n");
 					diagnostic += `\n${details}`;
@@ -602,27 +572,24 @@ export class EditTool implements AgentTool<TInput> {
 						"\nYour content must differ from what the file already contains. Re-read the file to see the current state.";
 				} else {
 					// Edits were not literally identical but heuristics normalized them back
-					const lines = result.content.split("\n");
+					const lines = result.text.split("\n");
 					const targetLines: string[] = [];
-					const refs: LineTag[] = [];
+					const refs: Anchor[] = [];
 					for (const edit of anchorEdits) {
 						refs.length = 0;
 						switch (edit.op) {
 							case "replace":
-								if ("tag" in edit) {
-									refs.push(edit.tag);
+								if (edit.end) {
+									refs.push(edit.end, edit.pos);
 								} else {
-									refs.push(edit.first, edit.last);
+									refs.push(edit.pos);
 								}
 								break;
 							case "append":
-								if (edit.after) refs.push(edit.after);
+								if (edit.pos) refs.push(edit.pos);
 								break;
 							case "prepend":
-								if (edit.before) refs.push(edit.before);
-								break;
-							case "insert":
-								refs.push(edit.after, edit.before);
+								if (edit.pos) refs.push(edit.pos);
 								break;
 							default:
 								break;
@@ -631,9 +598,9 @@ export class EditTool implements AgentTool<TInput> {
 						for (const ref of refs) {
 							try {
 								if (ref.line >= 1 && ref.line <= lines.length) {
-									const lineContent = lines[ref.line - 1];
-									const hash = computeLineHash(ref.line, lineContent);
-									targetLines.push(`${ref.line}#${hash}:${lineContent}`);
+									const text = lines[ref.line - 1];
+									const hash = computeLineHash(ref.line, text);
+									targetLines.push(`${ref.line}#${hash}:${text}`);
 								}
 							} catch {
 								/* skip malformed refs */
@@ -648,8 +615,8 @@ export class EditTool implements AgentTool<TInput> {
 				throw new Error(diagnostic);
 			}
 
-			const finalContent = bom + restoreLineEndings(result.content, originalEnding);
-			const writePath = resolvedRename ?? absolutePath;
+			const finalContent = bom + restoreLineEndings(result.text, originalEnding);
+			const writePath = resolvedMove ?? absolutePath;
 			const diagnostics = await this.#writethrough(
 				writePath,
 				finalContent,
@@ -657,26 +624,19 @@ export class EditTool implements AgentTool<TInput> {
 				Bun.file(writePath),
 				batchRequest,
 			);
-			if (resolvedRename && resolvedRename !== absolutePath) {
-				await file.unlink();
-				invalidateFsScanAfterRename(absolutePath, resolvedRename);
+			if (resolvedMove && resolvedMove !== absolutePath) {
+				await fs.unlink(absolutePath);
+				invalidateFsScanAfterRename(absolutePath, resolvedMove);
 			} else {
 				invalidateFsScanAfterWrite(absolutePath);
 			}
-			const diffResult = generateDiffString(originalNormalized, result.content);
-
-			const normative = buildNormativeUpdateInput({
-				path,
-				...(rename ? { rename } : {}),
-				oldContent: rawContent,
-				newContent: finalContent,
-			});
+			const diffResult = generateDiffString(originalNormalized, result.text);
 
 			const meta = outputMeta()
 				.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
 				.get();
 
-			const resultText = rename ? `Updated and moved ${path} to ${rename}` : `Updated ${path}`;
+			const resultText = move ? `Moved ${path} to ${move}` : `Updated ${path}`;
 			return {
 				content: [
 					{
@@ -689,10 +649,9 @@ export class EditTool implements AgentTool<TInput> {
 					firstChangedLine: result.firstChangedLine ?? diffResult.firstChangedLine,
 					diagnostics,
 					op: "update",
-					rename,
+					move,
 					meta,
 				},
-				$normative: normative,
 			};
 		}
 
@@ -705,7 +664,7 @@ export class EditTool implements AgentTool<TInput> {
 			// Normalize unrecognized operations to "update"
 			const op: Operation = rawOp === "create" || rawOp === "delete" ? rawOp : "update";
 
-			enforcePlanModeWrite(this.session, path, { op, rename });
+			enforcePlanModeWrite(this.session, path, { op, move: rename });
 			const resolvedPath = resolvePlanPath(this.session, path);
 			const resolvedRename = rename ? resolvePlanPath(this.session, rename) : undefined;
 
@@ -773,7 +732,7 @@ export class EditTool implements AgentTool<TInput> {
 					firstChangedLine: diffResult.firstChangedLine,
 					diagnostics: mergedDiagnostics,
 					op,
-					rename: effRename,
+					move: effRename,
 					meta,
 				},
 			};
@@ -795,13 +754,12 @@ export class EditTool implements AgentTool<TInput> {
 		}
 
 		const absolutePath = resolvePlanPath(this.session, path);
-		const file = Bun.file(absolutePath);
 
-		if (!(await file.exists())) {
+		if (!(await fs.exists(absolutePath))) {
 			throw new Error(`File not found: ${path}`);
 		}
 
-		const rawContent = await file.text();
+		const rawContent = await fs.readFile(absolutePath, "utf-8");
 		const { bom, text: content } = stripBom(rawContent);
 		const originalEnding = detectLineEnding(content);
 		const normalizedContent = normalizeToLF(content);
@@ -844,7 +802,13 @@ export class EditTool implements AgentTool<TInput> {
 		}
 
 		const finalContent = bom + restoreLineEndings(result.content, originalEnding);
-		const diagnostics = await this.#writethrough(absolutePath, finalContent, signal, file, batchRequest);
+		const diagnostics = await this.#writethrough(
+			absolutePath,
+			finalContent,
+			signal,
+			Bun.file(absolutePath),
+			batchRequest,
+		);
 		invalidateFsScanAfterWrite(absolutePath);
 		const diffResult = generateDiffString(normalizedContent, result.content);
 

package/src/patch/shared.ts

@@ -22,6 +22,7 @@ import {
 	truncateDiffByHunk,
 } from "../tools/render-utils";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import type { HashlineToolEdit } from "./index";
 import type { DiffError, DiffResult, Operation } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -58,7 +59,7 @@ export interface EditToolDetails {
 	/** Operation type (patch mode only) */
 	op?: Operation;
 	/** New path after move/rename (patch mode only) */
-	rename?: string;
+	move?: string;
 	/** Structured output metadata */
 	meta?: OutputMeta;
 }
@@ -83,16 +84,9 @@ interface EditRenderArgs {
 	 */
 	previewDiff?: string;
 	// Hashline mode fields
-	edits?: HashlineEditPreview[];
+	edits?: Partial<HashlineToolEdit>[];
 }
 
-type HashlineEditPreview = {
-	op: string;
-	first?: string;
-	last?: string;
-	content: string | string[] | null;
-};
-
 /** Extended context for edit tool rendering */
 export interface EditRenderContext {
 	/** Pre-computed diff preview (computed before tool executes) */
@@ -123,7 +117,7 @@ function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, labe
 	return text;
 }
 
-function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme): string {
+function formatStreamingHashlineEdits(edits: Partial<HashlineToolEdit>[], uiTheme: Theme): string {
 	const MAX_EDITS = 4;
 	const MAX_DST_LINES = 8;
 	let text = "\n\n";
@@ -158,22 +152,21 @@ function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme): string
 	}
 
 	return text.trimEnd();
-	function formatHashlineEdit(edit: unknown): { srcLabel: string; dst: string } {
-		const editRecord = typeof edit === "object" && edit !== null ? (edit as Record<string, unknown>) : undefined;
-		if (!editRecord) {
+	function formatHashlineEdit(edit: Partial<HashlineToolEdit>): { srcLabel: string; dst: string } {
+		if (typeof edit !== "object" || !edit) {
 			return { srcLabel: "• (incomplete edit)", dst: "" };
 		}
 
-		const contentLines = Array.isArray(editRecord.content) ? (editRecord.content as string[]).join("\n") : "";
+		const contentLines = Array.isArray(edit.lines) ? (edit.lines as string[]).join("\n") : "";
 
-		const op = typeof editRecord.op === "string" ? editRecord.op : "?";
-		const first = typeof editRecord.first === "string" ? editRecord.first : undefined;
-		const last = typeof editRecord.last === "string" ? editRecord.last : undefined;
+		const op = typeof edit.op === "string" ? edit.op : "?";
+		const pos = typeof edit.pos === "string" ? edit.pos : undefined;
+		const end = typeof edit.end === "string" ? edit.end : undefined;
 
-		if (first && last && first !== last) {
-			return { srcLabel: `\u2022 ${op} ${first}..${last}`, dst: contentLines };
+		if (pos && end && pos !== end) {
+			return { srcLabel: `• ${op} ${pos}…${end}`, dst: contentLines };
 		}
-		const anchor = first ?? last;
+		const anchor = pos ?? end;
 		if (anchor) {
 			return { srcLabel: `\u2022 ${op} ${anchor}`, dst: contentLines };
 		}
@@ -287,7 +280,7 @@ export const editToolRenderer = {
 		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
 
 		const op = args?.op || result.details?.op;
-		const rename = args?.rename || result.details?.rename;
+		const rename = args?.rename || result.details?.move;
 		const opTitle = op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
 
 		// Pre-compute metadata line (static across renders)

package/src/prompts/system/agent-creation-architect.md

@@ -50,8 +50,8 @@ When a user describes what they want an agent to do, you will:
 Your output MUST be a valid JSON object with exactly these fields:
 {
   "identifier": "A unique, descriptive identifier using lowercase letters, numbers, and hyphens (e.g., 'test-runner', 'api-docs-writer', 'code-formatter')",
-  "whenToUse": "A precise, actionable description starting with 'Use this agent when...' that clearly defines the triggering conditions and use cases. Ensure you include examples as described above.",
-  "systemPrompt": "The complete system prompt that will govern the agent's behavior, written in second person ('You are...', 'You will...') and structured for maximum clarity and effectiveness"
+  "whenToUse": "A precise, actionable description starting with 'Use this agent when…' that clearly defines the triggering conditions and use cases. Ensure you include examples as described above.",
+  "systemPrompt": "The complete system prompt that will govern the agent's behavior, written in second person ('You are…', 'You will…') and structured for maximum clarity and effectiveness"
 }
 
 Key principles for your system prompts:

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

@@ -90,7 +90,7 @@ Semantic questions MUST be answered with semantic tools.
 {{#has tools "ssh"}}
 ### SSH: match commands to host shell
 Commands MUST match the host shell. linux/bash, macos/zsh: Unix. windows/cmd: dir, type, findstr. windows/powershell: Get-ChildItem, Get-Content.
-Remote filesystems: `~/.omp/remote/<hostname>/`. Windows paths need colons: `C:/Users/...`
+Remote filesystems: `~/.omp/remote/<hostname>/`. Windows paths need colons: `C:/Users/…`
 {{/has}}
 
 {{#ifAny (includes tools "grep") (includes tools "find")}}
@@ -100,6 +100,10 @@ You MUST NOT open a file hoping. Hope is not a strategy.
 {{#has tools "grep"}}- Known territory → `grep` to locate target{{/has}}
 {{#has tools "read"}}- Known location → `read` with offset/limit, not whole file{{/has}}
 {{/ifAny}}
+
+{{#if intentTracing}}
+Every tool has a required `{{intentField}}` parameter. Describe intent as one sentence in present participle form (e.g., Inserting comment before the function) with no trailing period.
+{{/if}}
 </tools>
 
 <procedure>
@@ -215,30 +219,26 @@ Match skill descriptions to the task domain. If a skill is relevant, you MUST re
 Relative paths in skill files resolve against the skill directory.
 
 {{#list skills join="\n"}}
-<skill name="{{name}}">
+### {{name}}
 {{description}}
-</skill>
 {{/list}}
 </skills>
 {{/if}}
 {{#if preloadedSkills.length}}
-<preloaded-skills>
+<skills>
 {{#list preloadedSkills join="\n"}}
 <skill name="{{name}}">
 {{content}}
 </skill>
 {{/list}}
-</preloaded-skills>
+</skills>
 {{/if}}
 {{#if rules.length}}
 <rules>
 Read `rule://<name>` when working in matching domain.
-
 {{#list rules join="\n"}}
-<rule name="{{name}}">
+### {{name}} (Glob: {{#list globs join=", "}}{{this}}{{/list}})
 {{description}}
-{{#list globs join="\n"}}<glob>{{this}}</glob>{{/list}}
-</rule>
 {{/list}}
 </rules>
 {{/if}}

package/src/prompts/tools/ask.md

@@ -12,33 +12,18 @@ Ask user when you need clarification or input during task execution.
 - Set `multi: true` on question to allow multiple selections
 </instruction>
 
-<output>
-Returns selected option(s) as text. For multi-part questions, returns map of question IDs to selected values.
-</output>
-
 <caution>
 - Provide 2-5 concise, distinct options
 </caution>
 
 <critical>
-**Default to action. You MUST NOT ask unless you are genuinely blocked and user preference is required to avoid a wrong outcome.**
-1. You MUST **resolve ambiguity yourself** using repo conventions, existing patterns, and reasonable defaults.
-2. You MUST **exhaust existing sources** (code, configs, docs, history) before asking anything.
-3. **If multiple choices are acceptable**, you MUST pick the most conservative/standard option and proceed; state the choice.
-4. You MUST **only ask when options have materially different tradeoffs and the user must decide.**
-**You MUST NOT include "Other" option in your options array.** UI automatically adds "Other (type your own)" to every question; adding your own creates duplicates.
+- **Default to action.** Resolve ambiguity yourself using repo conventions, existing patterns, and reasonable defaults. Exhaust existing sources (code, configs, docs, history) before asking. Only ask when options have materially different tradeoffs the user must decide.
+- **If multiple choices are acceptable**, pick the most conservative/standard option and proceed; state the choice.
+- **Do NOT include "Other" option** — UI automatically adds "Other (type your own)" to every question.
 </critical>
 
 <example name="single">
 question: "Which authentication method should this API use?"
 options: [{"label": "JWT"}, {"label": "OAuth2"}, {"label": "Session cookies"}]
 recommended: 0
-</example>
-
-<example name="multi-part">
-questions: [
-  {"id": "auth", "question": "Which auth method?", "options": [{"label": "JWT"}, {"label": "OAuth2"}], "recommended": 0},
-  {"id": "cache", "question": "Enable caching?", "options": [{"label": "Yes"}, {"label": "No"}]},
-  {"id": "features", "question": "Which features to include?", "options": [{"label": "Logging"}, {"label": "Metrics"}, {"label": "Tracing"}], "multi": true}
-]
 </example>

package/src/prompts/tools/{poll-jobs.md → await.md}

@@ -1,4 +1,4 @@
-# Poll Jobs
+# Await
 
 Block until one or more background jobs complete, fail, or are cancelled.