@oh-my-pi/pi-coding-agent 15.5.0 → 15.5.2

package/src/prompts/tools/hashline.md

@@ -1,110 +1,63 @@
 Your patch language is a compact, line-anchored edit format.
 
-A patch contains one or more file sections. Each anchored section starts with `¶PATH#HASH`, copied verbatim from the latest `read`/`search` output. `HASH` is a 4-hex file hash; `¶PATH` without `#HASH` is allowed only for new-file / `BOF` / `EOF` boundary inserts.
-
-Operations reference lines by bare line number (`5`, `123`). Payload text is verbatim — NEVER escape unicode. The tool has NO awareness of language, indentation, brackets, fences, or table widths. Emit valid syntax in replacements/insertions.
+<payload>
+Patch payload is a series of hunks: `¶PATH#HASH` header followed by any number of operations. `HASH` should be copied as is from read/search. Missing? Re-`read`.
+- No context rows, no gutters.
+- NEVER restate unchanged lines "for context".
+- Inline payload after an op is literal. Additional payload lines MUST start with `+`; that delimiter is stripped.
+- Payload indentation after the op sigil or after `+` is literal.
+</payload>
 
 <ops>
-¶PATH#HASH     header: subsequent anchored ops apply to PATH at file hash HASH
-¶PATH          unbound header: only BOF/EOF boundary inserts
-LINE↑PAYLOAD   insert ABOVE the anchored line (or BOF)
-LINE↓PAYLOAD   insert BELOW the anchored line (or EOF)
-A-B:PAYLOAD    replace the inclusive range A..B with PAYLOAD
-A:PAYLOAD      shorthand for A-A:PAYLOAD
-A-B!           delete the inclusive range A..B (payload forbidden)
-A!             shorthand for A-A!
+LINE↑PAYLOAD   insert before (or BOF↑)
+LINE↓PAYLOAD   insert after  (or EOF↓)
+A-B:PAYLOAD    replace A..B  (or A: == A..A)
+A-B!           delete A..B   (or A! == A..A)
++PAYLOAD      continuation payload line; leading `+` is not written
 </ops>
 
-<payload>
-- The first payload line is whatever follows the sigil on the op line. Additional payload lines follow on the next lines and append after the first.
-- An empty inline IS an empty first line. So bare `A↓` / `A↑` insert one blank line; bare `A:` / `A-B:` replace with one blank line. `A↓\nfoo` inserts blank-then-`foo`, NOT just `foo`.
-- Payload ends at the next op, next `¶PATH`, envelope marker, or EOF. Blank lines immediately before a next op or `¶PATH` are dropped; blank lines between content lines are preserved.
-</payload>
-
 <rules>
-- The sigil tells where content lands: `↑` above, `↓` below, `:` replaces, `!` deletes.
-- **Payload is only what's NEW relative to your range.** `:` replaces inside; `↑`/`↓` add at anchor. NEVER repeat the anchor line or neighbors — that duplicates them.
-- **Pick a self-contained unit.** Touching a multiline construct (return, array, brace block, JSX element)? Widen the range to span it. Don't bisect.
-- Smallest op wins: add with `↑`/`↓`; replace with `:`; delete with `!`.
-- Anchors reference the file as last read. ONE patch, ONE coordinate space — later ops still use original line numbers.
+- **Payload is only what's NEW.** `:` replaces inside; `↑`/`↓` add at anchor. NEVER repeat anchor lines or neighbors.
+- **Continuation lines require `+`.** Use `+` for a blank payload line; use `++text` to write a line starting with `+text`.
+- **Go small.** Add → `↑`/`↓`; replace → `:`; delete → `!`.
+- **Line numbers are frozen references to what you have seen.** Later ops still use original line numbers.
 </rules>
 
 <common-failures>
-- **NEVER replay past your range.** Stop before B+1; extend B if it must go.
-- **NEVER duplicate chunks inside one payload.**
-- **Read lines look like replace ops.** `84:content` already means "make line 84 equal to content" — don't echo a context line before it.
+- **NEVER replay past your range.** Stop before B+1; extend B if needed.
+- **Read lines look like replace ops.** `84:content` = "make line 84 content" — don't echo context before it.
 - **NEVER fabricate file hashes.** Missing? Re-`read`.
-- **`A!` deletes silently.** Deleting a line that closes/opens a block (`}`, `} else {`, `})`, `*/`) breaks structure with no parse error.
-- **Pure removal uses `A-B!`, NEVER `A-B:something`.** If you have nothing to put in the range, use `!`. `A-B:X` where line `A-1` or `B+1` already reads `X` silently produces two copies of `X` — the tool trusts your payload literally. Before writing `A-B:payload`, glance at `A-1` and `B+1` and confirm payload doesn't echo either.
 </common-failures>
 
-<case file="mod.ts">
-¶mod.ts#1a2b
-{{hline 1 'const TITLE = "Mr";'}}
-{{hline 2 'export function greet(name) {'}}
-{{hline 3 '	return ['}}
-{{hline 4 '		TITLE,'}}
-{{hline 5 '		name?.trim() || "guest",'}}
-{{hline 6 '	].join(" ");'}}
-{{hline 7 "}"}}
-</case>
-
-<examples>
-# Replace one line (inline payload preserves original indentation)
-¶mod.ts#1a2b
-{{hrefr 1}}:const TITLE = "Mrs";
-
-# Replace a multiline statement — first line inline, rest below
-¶mod.ts#1a2b
-{{hrefr 3}}-{{hrefr 6}}:	return [
-		"Mrs",
-		name?.trim() || "guest",
-	].join(" ");
-
-# Insert ABOVE / BELOW a line
-¶mod.ts#1a2b
-{{hrefr 4}}↓		"Dr",
-{{hrefr 5}}↑		"Dr",
-
-# Delete one line / blank a line / insert a blank line
-¶mod.ts#1a2b
-{{hrefr 5}}!
-{{hrefr 6}}:
-{{hrefr 7}}↑
-
-# Create a file / append to one (hash optional for boundary-only inserts)
-¶new.ts
-BOF↓export const done = true;
-¶mod.ts
-EOF↓export const done = true;
-
-# Multi-file patch
-¶src/a.ts#1a2b
-12:const enabled = true;
-¶src/b.ts#3c4d
-20!
-</examples>
+<example>
+```a.ts#1a2b
+1:const X = "a";
+2:export function f() { return X; }
+```
+
+# replace with a continuation line, insert after, delete
+```
+¶a.ts#1a2b
+1:const X = "b";
++export const Y = X;
+1↓const Z = Y;
+2!
+```
+</example>
 
 <anti-pattern>
-# WRONG — replaces 2 lines just to add one.
-¶mod.ts#1a2b
-{{hrefr 1}}-{{hrefr 2}}:const TITLE = "Mr";
-const DEBUG = false;
-export function greet(name) {
-
-# RIGHT — one-line insert
-¶mod.ts#1a2b
-{{hrefr 1}}↓const DEBUG = false;
-
-# WRONG — bisects a multiline statement
-¶mod.ts#1a2b
-{{hrefr 4}}-{{hrefr 5}}:		"Dr",
-		name?.trim() || "guest",
-
-# RIGHT — widen to the full statement
-¶mod.ts#1a2b
-{{hrefr 3}}-{{hrefr 6}}:	return [
-		"Dr",
-		name?.trim() || "guest",
-	].join(" ");
+# WRONG — INSERT used to change a line (old line survives)
+1↓const X = "b";
+# WRONG — echoing read-style lines as context before the real op
+1:const X = "a";
+1-2:const X = "b";
+export const Y = X;  # raw continuation line missing required `+`
 </anti-pattern>
+
+<critical>
+- One op per range, ever.
+- Pick op precisely. Update: `:`, add: `↑`/`↓`, remove: `!`.
+- Payload is only what's NEW; never repeat anchor lines or neighbors.
+- Continuation payload lines after the op line must start with `+`.
+- Anchor exactly; don't anchor neighbors.
+</critical>

package/src/task/executor.ts

@@ -532,10 +532,10 @@ function createSubagentSettings(baseSettings: Settings): Settings {
 		...snapshot,
 		"async.enabled": false,
 		"bash.autoBackground.enabled": false,
+
 		// Subagents run headless — there is no UI to confirm prompts against, so
 		// the parent task approval is the authorization boundary. Use yolo mode
-		// to preserve unattended subagent execution while still honoring any
-		// tool-level safety override that can be handled before execution.
+		// to preserve unattended subagent execution. User `tools.approval` policies still apply.
 		"tools.approvalMode": "yolo",
 	});
 }

package/src/tools/approval.ts

@@ -87,8 +87,8 @@ function modeApprovesTier(mode: ApprovalMode, tier: ToolTier): boolean {
  *  2. User per-tool override, if set and valid.
  *  3. Active mode tier comparison.
  *
- * Tool decisions with `override: true` force a prompt in every mode unless the
- * user explicitly denies the tool; deny remains the strongest policy.
+ * In yolo mode, override-based tool prompts are ignored; user `tools.approval`
+ * settings remain authoritative.
  */
 export function resolveApproval(
 	tool: ApprovalSubject,
@@ -99,6 +99,10 @@ export function resolveApproval(
 	const decision = getToolDecision(tool, args);
 	const userPolicy = Object.hasOwn(userConfig, tool.name) ? normalizePolicy(userConfig[tool.name]) : undefined;
 
+	if (mode === "yolo") {
+		return { policy: userPolicy ?? "allow", tier: decision.tier, override: false };
+	}
+
 	if (decision.override) {
 		if (userPolicy === "deny") {
 			return { policy: "deny", tier: decision.tier, override: true };

package/src/tools/bash.ts

@@ -42,11 +42,11 @@ const BASH_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const DEFAULT_AUTO_BACKGROUND_THRESHOLD_MS = 60_000;
 
 /**
- * Bash patterns that force an approval prompt even in yolo mode.
+ * Bash patterns flagged as safety critical for approval policy.
  *
- * Kept intentionally tight — the cost of a false positive is one extra prompt;
- * the cost of a false negative is data loss or a compromised host. New patterns
- * should target shapes that are virtually never legitimate in automation.
+ * Kept intentionally tight — the cost of a false negative is data loss or a compromised host,
+ * while false positives remain actionable through user policy control.
+ * New patterns should target shapes that are virtually never legitimate in automation.
  */
 export const CRITICAL_BASH_PATTERNS = [
 	// Recursive destruction.