@oh-my-pi/pi-coding-agent 12.5.0 → 12.5.1

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [12.5.1] - 2026-02-15
+### Added
+
+- Added `repeatToolDescriptions` setting to render full tool descriptions in the system prompt instead of a tool name list
+
 ## [12.5.0] - 2026-02-15
 ### Breaking Changes
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "12.5.0",
+	"version": "12.5.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"bin": {
@@ -84,12 +84,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "12.5.0",
-		"@oh-my-pi/pi-agent-core": "12.5.0",
-		"@oh-my-pi/pi-ai": "12.5.0",
-		"@oh-my-pi/pi-natives": "12.5.0",
-		"@oh-my-pi/pi-tui": "12.5.0",
-		"@oh-my-pi/pi-utils": "12.5.0",
+		"@oh-my-pi/omp-stats": "12.5.1",
+		"@oh-my-pi/pi-agent-core": "12.5.1",
+		"@oh-my-pi/pi-ai": "12.5.1",
+		"@oh-my-pi/pi-natives": "12.5.1",
+		"@oh-my-pi/pi-tui": "12.5.1",
+		"@oh-my-pi/pi-utils": "12.5.1",
 		"@sinclair/typebox": "^0.34.48",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.18.0",

package/src/config/settings-schema.ts

@@ -253,6 +253,15 @@ export const SETTINGS_SCHEMA = {
 			description: "Rewrite tool call arguments to normalized format in session history",
 		},
 	},
+	repeatToolDescriptions: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "agent",
+			label: "Repeat tool descriptions",
+			description: "Render full tool descriptions in the system prompt instead of a tool name list",
+		},
+	},
 	readLineNumbers: {
 		type: "boolean",
 		default: false,

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

@@ -56,11 +56,15 @@ The question is not "does this work?" but "under what conditions? What happens o
 
 <tools>
 ## Available Tools
+{{#if repeatToolDescriptions}}
 {{#each toolDescriptions}}
 <tool name="{{name}}">
 {{description}}
 </tool>
 {{/each}}
+{{else}}
+{{#list tools join="\n"}}- {{this}}{{/list}}
+{{/if}}
 
 {{#ifAny (includes tools "python") (includes tools "bash")}}
 ### Precedence: Specialized → Python → Bash

package/src/prompts/tools/hashline.md

@@ -1,94 +1,85 @@
-# Edit (Hash anchored)
+# Edit (Hash Anchored)
 
-Line-addressed edits using hash-verified line references. Read file in hashline mode, then edit by referencing `LINE:HASH` pairs.
+Line-addressed edits using hash-verified line references. Read files in hashline mode, collect exact `LINE:HASH` references, and submit edits that change only the targeted token or expression.
+**CRITICAL: Copy `LINE:HASH` refs verbatim from read output. Use only the anchor prefix (e.g., `{{hashline 42 "const x = 1"}}`), never the trailing source text after `|`.**
 
-<critical>
-- Copy `LINE:HASH` refs verbatim from read output — never fabricate or guess hashes
-- `new_text` (set_line/replace_lines) or `text` (insert_after) contains plain replacement lines only — no `LINE:HASH` prefix, no diff `+` markers
-- On hash mismatch: use the updated `LINE:HASH` refs shown by `>>>` directly; only `read` again if you need additional lines/context
-- If you already edited a file in this turn, re-read that file before the next edit to it
-- For code-change requests, respond with tool calls, not prose
-- Edit only requested lines. Do not reformat unrelated code.
-- Direction-lock every mutation: replace the exact currently-present token/expression with the intended target token/expression; never reverse the change or "change something nearby".
-- `new_text` must differ from the current line content — sending identical content is rejected as a no-op
-</critical>
+<workflow>
+1. Read the target file (`read`) to obtain `LINE:HASH` references
+2. Collect the exact `LINE:HASH` refs for lines you will change
+3. Direction-lock each mutation: identify the exact current token/expression → the intended replacement
+4. Submit one `edit` call containing all operations for that file
+5. If another edit is needed on the same file: re-read first, then edit (hashes change after every edit)
+6. Respond with tool calls only — no prose
+</workflow>
 
-<instruction>
-**Workflow:**
-1. Read target file (`read`)
-2. Collect the exact `LINE:HASH` refs you need
-3. Submit one `edit` call with all known operations for that file
-4. If another change on same file is needed later: re-read first, then edit
-5. Direction-lock each operation before submitting (`exact source token/expression on target line` → `intended replacement`) and keep the mutation to one logical locus. Do not output prose; submit only the tool call.
-**Atomicity:** All edits in one call are validated against the file as last read — line numbers and hashes refer to the original state, not after earlier edits in the same array. The applicator sorts and applies bottom-up automatically.
-**Edit variants:**
-- `{ set_line: { anchor: "LINE:HASH", new_text: "..." } }`
-- `{ replace_lines: { start_anchor: "LINE:HASH", end_anchor: "LINE:HASH", new_text: "..." } }`
-- `{ insert_after: { anchor: "LINE:HASH", text: "..." } }`
-- `{ replace: { old_text: "...", new_text: "...", all?: boolean } }` — substr-style fuzzy replace (no LINE:HASH; use when line refs unavailable)
+<operations>
+Four edit variants are available:
+- **`set_line`**: Replace a single line
+  `{ set_line: { anchor: "LINE:HASH", new_text: "..." } }`
+  `new_text: ""` keeps the line but makes it blank.
+- **`replace_lines`**: Replace a contiguous range (use for deletions with `new_text: ""`)
+  `{ replace_lines: { start_anchor: "LINE:HASH", end_anchor: "LINE:HASH", new_text: "..." } }`
+- **`insert_after`**: Add new content after an anchor line
+  `{ insert_after: { anchor: "LINE:HASH", text: "..." } }`
+- **`replace`**: Substring-style fuzzy match (when line refs are unavailable)
+  `{ replace: { old_text: "...", new_text: "...", all?: boolean } }`
+**Atomicity:** All edits in one call validate against the file as last read. Line numbers and hashes refer to the original state, not post-edit state. The applicator sorts and applies bottom-up automatically.
+</operations>
 
-`new_text: ""` means delete (for `set_line`/`replace_lines`).
-</instruction>
+<rules>
+1. **Scope each operation minimally.** One logical change site per operation. Use separate `set_line` ops for non-adjacent lines instead of a wide `replace_lines` that spans unchanged code.
+2. **Preserve original formatting exactly.** Copy each line's whitespace, braces, semicolons, trailing commas, and style — then change only the targeted token/expression. Keep `import { foo }` as-is; keep indentation and line breaks as-is.
+3. **Use `insert_after` for additions.** When adding a field, argument, or import near existing lines, prefer `insert_after` over replacing a neighboring line.
+4. **Ensure `new_text` differs from current content.** Identical content is rejected as a no-op.
+5. **Edit only requested lines.** Leave unrelated code untouched.
+6. **Lock mutation direction.** Replace the exact currently-present token with the intended target. For swaps between two locations, use two `set_line` ops in one call.
+</rules>
 
-<caution>
-**Preserve original formatting.** When writing `new_text`/`text`, copy each line's exact whitespace, braces, and style from the read output — then change *only* the targeted token/expression. Do not:
-- Restyle braces: `import { foo }` → `import {foo}`
-- Reflow arguments onto multiple lines or collapse them onto one line
-- Change indentation style, trailing commas, or semicolons on lines you replace
-- Do NOT use `replace_lines` over a wide span when multiple `set_line` ops would work — wide ranges tempt reformatting everything in between
-
-If a change spans multiple non-adjacent lines, use separate `set_line` operations for each — not a single `replace_lines` that includes unchanged lines in `new_text`.
-- Each edit operation must target one logical change site with minimal scope. If a fix requires two locations, use two operations; never span unrelated lines in one `replace_lines`.
-- Self-check before submitting: if your edit touches lines unrelated to the stated fix, split or narrow it.
-- Do NOT reformat lines you are replacing — preserve exact whitespace, braces (`{ foo }` not `{foo}`), arrow style, and line breaks. Change ONLY the targeted token/expression. Reformatting causes hash verification failure even when the logic is correct.
-- For swaps (exchanging content between two locations), use two `set_line` operations in one call — the applicator handles ordering. Do not try to account for line number shifts between operations.
-</caution>
-<instruction>
-**Recovery:**
-- Hash mismatch (`>>>` error): copy the updated `LINE:HASH` refs from the error verbatim and retry with the same intended mutation. Do NOT re-read unless you need lines not shown in the error.
-- If hash mismatch repeats after applying updated refs, stop blind retries and re-read the relevant region before retrying.
-- After a successful edit, always re-read the file before making another edit to the same file (hashes have changed).
-- No-op error ("identical content"): your replacement text matches what the file already contains. STOP and re-read the file — you are likely targeting the wrong line or your replacement is not actually different. Do NOT retry with the same content. After 2 consecutive no-op errors on the same line, re-read the entire function/block to understand the current file state.
-</instruction>
-
-<instruction>
-**Preflight schema and validation (required):**
-- Payload shape is `{"path": string, "edits": [operation, ...]}` with a non-empty `edits` array.
-- Each operation contains exactly one variant key: `set_line`, `replace_lines`, `insert_after`, or `replace`.
-- Required fields by variant:
-  - `set_line`: `anchor`, `new_text`
-  - `replace_lines`: `start_anchor`, `end_anchor`, `new_text`
-  - `insert_after`: `anchor`, `text` (non-empty)
-  - `replace`: `old_text`, `new_text` (fuzzy match; `all: true` for replace-all)
-- Each `anchor`/`start_anchor`/`end_anchor` ref matches `^\d+:[A-Za-z0-9]+$` (no spaces, no trailing source text).
-- `new_text`/`text` preserves original formatting and changes only the direction-locked target locus.
-</instruction>
-
-<input>
-- `path`: File path
-- `edits`: Array of edit operations (one of the variants above)
-</input>
+<recovery>
+**Hash mismatch (`>>>` error):**
+→ Copy the updated `LINE:HASH` refs from the error output verbatim and retry with the same intended mutation.
+→ Re-read only if you need lines not shown in the error.
+→ If mismatch repeats after applying updated refs, stop and re-read the relevant region.
+**No-op error ("identical content"):**
+→ Stop. Re-read the file — you are targeting the wrong line or your replacement is not different.
+→ After 2 consecutive no-op errors on the same line, re-read the entire function/block.
+</recovery>
 
+<examples>
 <example name="replace single line">
-edit {"path":"src/app.py","edits":[{"set_line":{"anchor":"{{hashline 2 'x = 42'}}","new_text":"  x = 99"}}]}
+set_line: { anchor: "{{hashline 2 "  x"}}", new_text: "  x = 99" }
 </example>
 
 <example name="replace range">
-edit {"path":"src/app.py","edits":[{"replace_lines":{"start_anchor":"{{hashline 5 'old_value = True'}}","end_anchor":"{{hashline 8 'return result'}}","new_text":"  combined = True"}}]}
+replace_lines: { start_anchor: "{{hashline 5 "old start line"}}", end_anchor: "{{hashline 8 "old end line"}}", new_text: "  combined = True" }
 </example>
 
 <example name="delete lines">
-edit {"path":"src/app.py","edits":[{"replace_lines":{"start_anchor":"{{hashline 5 'old_value = True'}}","end_anchor":"{{hashline 6 'unused = None'}}","new_text":""}}]}
+replace_lines: { start_anchor: "{{hashline 5 "line to delete A"}}", end_anchor: "{{hashline 6 "line to delete B"}}", new_text: "" }
 </example>
 
 <example name="insert after">
-edit {"path":"src/app.py","edits":[{"insert_after":{"anchor":"{{hashline 3 'def hello'}}","text":"  # new comment"}}]}
+insert_after: { anchor: "{{hashline 3 "anchor line content"}}", text: "  # new comment" }
 </example>
 
 <example name="multiple edits (bottom-up safe)">
-edit {"path":"src/app.py","edits":[{"set_line":{"anchor":"{{hashline 10 'return True'}}","new_text":"  return False"}},{"set_line":{"anchor":"{{hashline 3 'def hello'}}","new_text":"  x = 42"}}]}
+set_line: { anchor: "{{hashline 10 "old line 10"}}", new_text: "  return False" }
+set_line: { anchor: "{{hashline 3 "old line 3"}}", new_text: "  x = 42" }
 </example>
 
 <example name="content replace (substr-style, no hashes)">
-edit {"path":"src/app.py","edits":[{"replace":{"old_text":"x = 42","new_text":"x = 99"}}]}
-</example>
+replace: { old_text: "x = 42", new_text: "x = 99" }
+</example>
+</examples>
+
+<validation>
+Before submitting, verify:
+- [ ] Payload shape: `{"path": string, "edits": [operation, ...]}`  with non-empty `edits` array
+- [ ] Each operation has exactly one variant key: `set_line` | `replace_lines` | `insert_after` | `replace`
+- [ ] Each anchor is copied exactly from the `LINE:HASH` prefix (no spaces, no trailing source text)
+- [ ] `new_text`/`text` contains plain replacement lines only — no `LINE:HASH` prefixes, no diff `+` markers
+- [ ] Each replacement differs from the current line content
+- [ ] Each operation targets one logical change site with minimal scope
+- [ ] Formatting of replaced lines matches the original exactly, except for the targeted change
+</validation>
+**REMINDER: Copy `LINE:HASH` refs verbatim. Anchors are `LINE:HASH` only — never `LINE:HASH|content`. Preserve exact formatting. Change only the targeted token.**

package/src/sdk.ts

@@ -323,6 +323,7 @@ export interface BuildSystemPromptOptions {
 	contextFiles?: Array<{ path: string; content: string }>;
 	cwd?: string;
 	appendPrompt?: string;
+	repeatToolDescriptions?: boolean;
 }
 
 /**
@@ -334,6 +335,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills: options.skills,
 		contextFiles: options.contextFiles,
 		appendSystemPrompt: options.appendPrompt,
+		repeatToolDescriptions: options.repeatToolDescriptions,
 	});
 }
 
@@ -986,6 +988,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		emitEvent: event => cursorEventEmitter?.(event),
 	});
 
+	const repeatToolDescriptions = settings.get("repeatToolDescriptions");
 	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
 		const memoryInstructions = await buildMemoryToolDeveloperInstructions(agentDir, settings);
@@ -999,6 +1002,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			rules: rulebookRules,
 			skillsSettings: settings.getGroup("skills") as SkillsSettings,
 			appendSystemPrompt: memoryInstructions,
+			repeatToolDescriptions,
 		});
 
 		if (options.systemPrompt === undefined) {
@@ -1016,6 +1020,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				skillsSettings: settings.getGroup("skills") as SkillsSettings,
 				customPrompt: options.systemPrompt,
 				appendSystemPrompt: memoryInstructions,
+				repeatToolDescriptions,
 			});
 		}
 		return options.systemPrompt(defaultPrompt);

package/src/system-prompt.ts

@@ -430,6 +430,8 @@ export interface BuildSystemPromptOptions {
 	toolNames?: string[];
 	/** Text to append to system prompt. */
 	appendSystemPrompt?: string;
+	/** Repeat full tool descriptions in system prompt. Default: false */
+	repeatToolDescriptions?: boolean;
 	/** Skills settings for discovery. */
 	skillsSettings?: SkillsSettings;
 	/** Working directory. Default: getProjectDir() */
@@ -454,6 +456,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		customPrompt,
 		tools,
 		appendSystemPrompt,
+		repeatToolDescriptions = false,
 		skillsSettings,
 		toolNames,
 		cwd,
@@ -553,6 +556,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	return renderPromptTemplate(systemPromptTemplate, {
 		tools: toolNamesArray,
 		toolDescriptions,
+		repeatToolDescriptions,
 		environment,
 		systemPromptCustomization: systemPromptCustomization ?? "",
 		contextFiles,