@oh-my-pi/pi-coding-agent 14.9.2 → 14.9.3

package/src/export/html/template.js

@@ -839,9 +839,11 @@
 
       function renderEdit(name, args, result, ctx) {
         const filePath = str(args.file_path == null ? args.path : args.file_path);
-        const pathHtml = filePath === null ? invalidArgHtml() : escapeHtml(shortenPath(filePath || ''));
+        const pathHtml = filePath ? escapeHtml(shortenPath(filePath)) : '';
         let html = toolHead('edit', pathHtml);
-        if (Array.isArray(args.edits)) {
+        if (typeof args.input === 'string' && args.input.length) {
+          html += codeBlock(args.input, null);
+        } else if (Array.isArray(args.edits)) {
           html += '<div class="tool-args">';
           for (const e of args.edits) {
             const op = e && typeof e.op === 'string' ? e.op : '?';
@@ -867,7 +869,8 @@
 
       function renderAstEdit(name, args, result, ctx) {
         const lang = args.lang || null;
-        const pathHtml = args.path ? escapeHtml(shortenPath(String(args.path))) : '';
+        const paths = Array.isArray(args.paths) ? args.paths.map(p => shortenPath(String(p))).join(', ') : (args.path ? shortenPath(String(args.path)) : '');
+        const pathHtml = paths ? escapeHtml(paths) : '';
         const badges = [];
         if (lang) badges.push(lang);
         if (args.glob) badges.push('glob=' + args.glob);
@@ -931,10 +934,12 @@
       }
 
       function renderFind(name, args, result, ctx) {
-        const pattern = str(args.pattern);
-        const patHtml = pattern === null ? invalidArgHtml() : escapeHtml(pattern);
-        const badges = args.limit ? ['limit=' + args.limit] : null;
-        let html = toolHead('find', '<span class="tool-pattern">' + patHtml + '</span>', badges);
+        const paths = Array.isArray(args.paths) ? args.paths.map(p => shortenPath(String(p))).join(', ') : (str(args.pattern) || '.');
+        const patHtml = paths ? escapeHtml(paths) : invalidArgHtml();
+        const badges = [];
+        if (args.limit) badges.push('limit=' + args.limit);
+        if (args.hidden === false) badges.push('no-hidden');
+        let html = toolHead('find', '<span class="tool-pattern">' + patHtml + '</span>', badges.length ? badges : null);
         if (result) {
           const output = ctx.getResultText();
           if (output) html += formatExpandableOutput(output, 10);
@@ -1168,14 +1173,18 @@
       }
 
       function renderGh(name, args, result, ctx) {
+        const op = str(args.op);
         const badges = [];
+        if (op) badges.push(op);
         if (args.repo) badges.push(String(args.repo));
         if (args.issue) badges.push('#' + args.issue);
-        if (args.pr) badges.push('PR ' + args.pr);
+        if (args.pr) badges.push(Array.isArray(args.pr) ? 'PRs ' + args.pr.join(',') : 'PR ' + args.pr);
         if (args.branch) badges.push('branch=' + args.branch);
-        if (args.query) badges.push('query=' + args.query);
+        if (args.query) badges.push('query=' + truncate(String(args.query), 60));
         if (args.run) badges.push('run=' + args.run);
+        if (args.title) badges.push('title=' + truncate(String(args.title), 40));
         let html = toolHead(name, '', badges);
+        if (args.body) html += '<div class="tool-output"><div>' + escapeHtml(truncate(String(args.body), 400)) + '</div></div>';
         if (result) {
           const output = ctx.getResultText();
           if (output) html += formatExpandableOutput(output, 12, 'markdown');
@@ -1249,6 +1258,178 @@
         return html;
       }
 
+      // Parse `*** Begin <LANG>` cell headers (canonical) and the legacy
+      // `===== <info> =====` headers used by older transcripts. Cells emitted
+      // before the format cutover still need to render in HTML exports.
+      function parseEvalCells(input) {
+        const text = String(input);
+        if (/^[*]{2,}\s*Begin\b/im.test(text)) return parseEvalCellsNew(text);
+        return parseEvalCellsLegacy(text);
+      }
+
+      function evalLangAlias(token) {
+        const t = String(token || '').toUpperCase();
+        if (t === 'PY' || t === 'PYTHON' || t === 'IPY' || t === 'IPYTHON') return 'py';
+        if (t === 'JS' || t === 'JAVASCRIPT') return 'js';
+        if (t === 'TS' || t === 'TYPESCRIPT') return 'ts';
+        return null;
+      }
+
+      function parseEvalCellsNew(text) {
+        const STARS = '\\*{2,}';
+        const BEGIN = new RegExp('^' + STARS + '\\s*Begin\\b\\s*(\\S+)?\\s*$', 'i');
+        const END = new RegExp('^' + STARS + '\\s*End\\b.*$', 'i');
+        const TITLE = new RegExp('^' + STARS + '\\s*Title\\s*:\\s*(.+?)\\s*$', 'i');
+        const TIMEOUT = new RegExp('^' + STARS + '\\s*Timeout\\s*:\\s*(\\S+)\\s*$', 'i');
+        const RESET = new RegExp('^' + STARS + '\\s*Reset\\s*$', 'i');
+        const lines = text.split('\n');
+        if (lines.length && lines[lines.length - 1] === '') lines.pop();
+        const cells = [];
+        let i = 0;
+        while (i < lines.length && lines[i].trim() === '') i++;
+        while (i < lines.length) {
+          const beginMatch = BEGIN.exec(lines[i]);
+          if (!beginMatch) { i++; continue; }
+          const lang = evalLangAlias(beginMatch[1]) || 'py';
+          i++;
+          let title = '';
+          const attrs = [];
+          while (i < lines.length) {
+            const tm = TITLE.exec(lines[i]);
+            if (tm) { if (!title) title = tm[1]; i++; continue; }
+            const to = TIMEOUT.exec(lines[i]);
+            if (to) { attrs.push('t=' + to[1]); i++; continue; }
+            if (RESET.test(lines[i])) { attrs.push('rst'); i++; continue; }
+            break;
+          }
+          const codeLines = [];
+          while (i < lines.length) {
+            if (END.test(lines[i])) { i++; break; }
+            if (BEGIN.test(lines[i])) break;
+            codeLines.push(lines[i]);
+            i++;
+          }
+          while (codeLines.length && codeLines[codeLines.length - 1].trim() === '') codeLines.pop();
+          cells.push({ lang, title, attrs, code: codeLines.join('\n') });
+          while (i < lines.length && lines[i].trim() === '') i++;
+        }
+        return cells;
+      }
+
+      function parseEvalCellsLegacy(input) {
+        const HEADER = /^={5,}\s*(.*?)\s*={5,}\s*$/;
+        const lines = String(input).split('\n');
+        const cells = [];
+        let inheritedLang = 'py';
+        let current = null;
+        for (const line of lines) {
+          const m = line.match(HEADER);
+          if (m) {
+            if (current) cells.push(current);
+            const info = m[1] || '';
+            let lang = inheritedLang;
+            let title = '';
+            const langMatch = info.match(/^(py|js|ts)(?::"([^"]*)")?/);
+            if (langMatch) {
+              lang = langMatch[1];
+              if (langMatch[2]) title = langMatch[2];
+            }
+            if (!title) {
+              const idMatch = info.match(/id:"([^"]*)"/);
+              if (idMatch) title = idMatch[1];
+            }
+            inheritedLang = lang;
+            const attrs = [];
+            const tMatch = info.match(/(?:^|\s)t:(\S+)/);
+            if (tMatch) attrs.push('t=' + tMatch[1]);
+            if (/(?:^|\s)rst(?:\s|$)/.test(info)) attrs.push('rst');
+            current = { lang, title, attrs, code: '' };
+          } else {
+            if (!current) current = { lang: inheritedLang, title: '', attrs: [], code: '' };
+            current.code += (current.code ? '\n' : '') + line;
+          }
+        }
+        if (current) cells.push(current);
+        return cells.map(c => ({ ...c, code: c.code.replace(/\s+$/, '') }));
+      }
+
+      function evalLangToHljs(lang) {
+        return lang === 'py' ? 'python' : lang === 'js' ? 'javascript' : lang === 'ts' ? 'typescript' : null;
+      }
+
+      function renderEval(name, args, result, ctx) {
+        let html = toolHead('eval');
+        if (typeof args.input !== 'string') {
+          html += '<div class="tool-error">[missing input]</div>';
+        } else {
+          const cells = parseEvalCells(args.input);
+          if (cells.length === 0) {
+            html += codeBlock(args.input, 'python');
+          } else {
+            for (const cell of cells) {
+              html += '<div class="tool-cell">';
+              const titleParts = [];
+              if (cell.title) titleParts.push(cell.title);
+              titleParts.push(cell.lang);
+              if (cell.attrs && cell.attrs.length) titleParts.push(...cell.attrs);
+              html += '<div class="tool-cell-title">' + escapeHtml(titleParts.join(' · ')) + '</div>';
+              html += codeBlock(cell.code, evalLangToHljs(cell.lang));
+              html += '</div>';
+            }
+          }
+        }
+        if (result) {
+          html += ctx.renderResultImages();
+          const output = ctx.getResultText();
+          if (output) html += formatExpandableOutput(output, 12);
+        }
+        return html;
+      }
+
+      function renderSearch(name, args, result, ctx) {
+        const pattern = str(args.pattern);
+        const paths = Array.isArray(args.paths) ? args.paths.map(p => shortenPath(String(p))).join(', ') : (args.path ? shortenPath(String(args.path)) : '.');
+        const patHtml = pattern === null ? invalidArgHtml() : escapeHtml(pattern);
+        let head = '<span class="tool-name">search</span> <span class="tool-pattern">/' + patHtml + '/</span>';
+        head += ' <span class="tool-arg-key">in</span> <span class="tool-path">' + escapeHtml(paths) + '</span>';
+        const badges = [];
+        if (args.i) badges.push('i');
+        if (args.skip) badges.push('skip=' + args.skip);
+        if (args.gitignore === false) badges.push('no-gitignore');
+        for (const b of badges) head += ' <span class="tool-badge">' + escapeHtml(b) + '</span>';
+        let html = '<div class="tool-header">' + head + '</div>';
+        if (result) {
+          const output = ctx.getResultText();
+          if (output) html += formatExpandableOutput(output, 12);
+        }
+        return html;
+      }
+
+      function renderRecipe(name, args, result, ctx) {
+        const op = str(args.op) || '?';
+        let html = toolHead('recipe', '<span class="tool-arg-val">' + escapeHtml(op) + '</span>');
+        if (result) {
+          html += ctx.renderResultImages();
+          const output = ctx.getResultText();
+          if (output) html += formatExpandableOutput(output, 10);
+        }
+        return html;
+      }
+
+      function renderIrc(name, args, result, ctx) {
+        const op = str(args.op) || '?';
+        const badges = [op];
+        if (args.to) badges.push('to=' + args.to);
+        if (args.awaitReply === false) badges.push('no-reply');
+        let html = toolHead('irc', '', badges);
+        if (args.message) html += '<div class="tool-output"><div>' + escapeHtml(String(args.message)) + '</div></div>';
+        if (result) {
+          const output = ctx.getResultText();
+          if (output) html += formatExpandableOutput(output, 8);
+        }
+        return html;
+      }
+
 
       function renderGenericTool(name, args, result, ctx) {
         let html = toolHead(name);
@@ -1266,6 +1447,7 @@
 
       const TOOL_RENDERERS = {
         bash: renderBash,
+        eval: renderEval,
         js: renderJsLike,
         python: renderJsLike,
         notebook: renderJsLike,
@@ -1275,6 +1457,7 @@
         ast_edit: renderAstEdit,
         ast_grep: renderAstGrep,
         grep: renderGrep,
+        search: renderSearch,
         find: renderFind,
         lsp: renderLsp,
         todo_write: renderTodoWrite,
@@ -1300,16 +1483,25 @@
         poll: renderJob,
         cancel_job: renderJob,
         job: renderJob,
+        recipe: renderRecipe,
+        irc: renderIrc,
       };
 
       function renderToolCall(call) {
         const result = findToolResult(call.id);
         const isError = result?.isError || false;
         const statusClass = result ? (isError ? 'error' : 'success') : 'pending';
-        const args = call.arguments || {};
+        const rawArgs = call.arguments || {};
+        const intent = typeof rawArgs._i === 'string' ? rawArgs._i.trim() : '';
+        // Strip internal _i intent so renderers don't dump it as JSON.
+        const args = {};
+        for (const k of Object.keys(rawArgs)) {
+          if (k !== '_i') args[k] = rawArgs[k];
+        }
         const name = call.name;
 
         const ctx = {
+          intent,
           getResultText: () => {
             if (!result) return '';
             const textBlocks = result.content.filter(c => c.type === 'text');
@@ -1331,6 +1523,7 @@
 
         const renderer = TOOL_RENDERERS[name] || renderGenericTool;
         let html = '<div class="tool-execution ' + statusClass + '">';
+        if (intent) html += '<div class="tool-intent">' + escapeHtml(intent) + '</div>';
         try {
           html += renderer(name, args, result, ctx);
         } catch (err) {
@@ -1638,11 +1831,12 @@
         }
 
         if (tools && tools.length > 0) {
-          html += `<div class="tools-list">
-            <div class="tools-header">Available Tools</div>
-            <div class="tools-content">
-              ${tools.map(t => `<div class="tool-item"><span class="tool-item-name">${escapeHtml(t.name)}</span> - <span class="tool-item-desc">${escapeHtml(t.description)}</span></div>`).join('')}
-            </div>
+          const namesHtml = tools.map(t => `<span class="tool-name-chip">${escapeHtml(t.name)}</span>`).join('');
+          const fullHtml = tools.map(t => `<div class="tool-item"><span class="tool-item-name">${escapeHtml(t.name)}</span> - <span class="tool-item-desc">${escapeHtml(t.description)}</span></div>`).join('');
+          html += `<div class="tools-list collapsed" onclick="this.classList.toggle('collapsed')">
+            <div class="tools-header">Available Tools (${tools.length})</div>
+            <div class="tools-collapsed">${namesHtml}</div>
+            <div class="tools-content">${fullHtml}</div>
           </div>`;
         }
 

package/src/hashline/constants.ts

@@ -6,3 +6,23 @@ export const RANGE_INTERIOR_HASH = "**";
 
 /** Header marker introducing a new file section in multi-section input. */
 export const FILE_HEADER_PREFIX = "@";
+
+/** Optional patch envelope start marker; silently consumed when present. */
+export const BEGIN_PATCH_MARKER = "*** Begin Patch";
+
+/** Optional patch envelope end marker; terminates parsing when encountered. */
+export const END_PATCH_MARKER = "*** End Patch";
+
+/**
+ * Recovery sentinel emitted by the agent loop when a contaminated
+ * `to=functions.edit` stream is truncated mid-call (see
+ * `docs/ERRATA-GPT5-HARMONY.md`). Behaves like `END_PATCH_MARKER` for
+ * parsing — terminates the line loop — and additionally surfaces a
+ * warning in the tool result so the model knows to re-issue any
+ * remaining edits.
+ */
+export const ABORT_MARKER = "*** Abort";
+
+/** Warning text appended to the tool result when ABORT_MARKER terminates parsing. */
+export const ABORT_WARNING =
+	"Tool stream truncated mid-call due to detected output corruption. Applied ops above are valid. Re-issue any remaining edits.";

package/src/hashline/grammar.lark

@@ -1,29 +1,22 @@
-%import common.LF
-%import common.WS_INLINE
-
-start: section+
-
-section: file_header line_op*
-
-file_header: "@" path LF
+start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
 
-line_op: insert_before_op payload+
-       | insert_after_op payload+
-       | replace_op payload*
-       | delete_op
-       | blank
+hunk: update_hunk
+update_hunk: "@" filename LF line_op*
 
-insert_before_op: "<" insert_target LF
-insert_after_op: "+" insert_target LF
-replace_op: "=" range LF
-delete_op: "-" range LF
-payload: $HSEP$ line_text? LF
+filename: /(.+)/
 
-line_text: /[^\r\n]+/
+line_op: insert_before | insert_after | replace | delete | blank
+insert_before: ("<" | "< ") anchor LF payload+
+insert_after: ("+" | "+ ") anchor LF payload+
+replace: ("=" | "= ") range LF payload*
+delete: ("-" | "- ") range LF
+payload: $HSEP$ /(.*)/ LF
+blank: LF
 
-insert_target: LID | "EOF" | "BOF"
+anchor: LID | "EOF" | "BOF"
 range: LID ".." LID
+LID: /[1-9]\d*$HFMT$/
 
-path: /(?:[^\s\r\n]+|"[^"\r\n]+"|'[^'\r\n]+')/
-LID: /[1-9][0-9]*$HFMT$/
-blank: LF
+%import common.LF

package/src/hashline/hash.ts

@@ -137,48 +137,18 @@ export const HL_BODY_SEP = "|";
 export const HL_BODY_SEP_RE_RAW = regexEscape(HL_BODY_SEP);
 
 const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
-const RE_STRUCTURAL_STRIP = /[\s{}]/g;
-
-/**
- * Bigram returned for lines that contain only whitespace and `{`/`}`.
- * Picks the English ordinal suffix for the line number (`1` → `st`,
- * `2` → `nd`, `3` → `rd`, `11`/`12`/`13` → `th`, else `th`) so the
- * line digits + bigram BPE-merge into a single ordinal token (`1st`, `42nd`,
- * `100th`, …). Brace-only lines therefore cost one token for the whole
- * `LINE+ID` anchor instead of two.
- */
-function structuralBigram(line: number): string {
-	const mod100 = line % 100;
-	if (mod100 >= 11 && mod100 <= 13) return "th";
-	switch (line % 10) {
-		case 1:
-			return "st";
-		case 2:
-			return "nd";
-		case 3:
-			return "rd";
-		default:
-			return "th";
-	}
-}
 
 /**
  * Compute a 2-character hash of a single line via xxHash32 mod 647 over
- * {@link HL_BIGRAMS}. Lines that contain only whitespace and `{`/`}` collapse
- * to an ordinal-suffix bigram (see {@link structuralBigram}) so brace-only
- * structure shares one merged ordinal token (`1st`, `42nd`, `100th`, …).
- * Other lines with no letter or digit mix the line number into the seed so
- * adjacent identical punctuation-only lines get distinct hashes; lines with
- * significant content stay line-number-independent so a line is identifiable
- * across small shifts.
+ * {@link HL_BIGRAMS}. Lines with no letter or digit mix the line number
+ * into the seed so adjacent identical punctuation-only lines (e.g. brace-only
+ * lines) get distinct hashes; lines with significant content stay
+ * line-number-independent so a line is identifiable across small shifts.
  *
  * The line input should not include a trailing newline.
  */
 export function computeLineHash(idx: number, line: string): string {
 	line = line.replace(/\r/g, "").trimEnd();
-	if (line.replace(RE_STRUCTURAL_STRIP, "").length === 0) {
-		return structuralBigram(idx);
-	}
 	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
 	return HL_BIGRAMS[Bun.hash.xxHash32(line, seed) % HL_BIGRAMS_COUNT];
 }

package/src/hashline/input.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { FILE_HEADER_PREFIX } from "./constants";
+import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER, FILE_HEADER_PREFIX } from "./constants";
 import { HL_EDIT_SEP } from "./hash";
 import type { SplitHashlineOptions } from "./types";
 import { stripTrailingCarriageReturn } from "./utils";
@@ -38,10 +38,22 @@ function parseHashlineHeaderLine(line: string, cwd?: string): HashlineInputSecti
 	return { path: parsedPath, diff: "" };
 }
 
+function isPatchEnvelopeMarker(line: string): boolean {
+	const trimmed = line.trimEnd();
+	return trimmed === BEGIN_PATCH_MARKER || trimmed === END_PATCH_MARKER;
+}
+
 function stripLeadingBlankLines(input: string): string {
 	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
 	const lines = stripped.split("\n");
-	while (lines.length > 0 && lines[0].replace(/\r$/, "").trim().length === 0) lines.shift();
+	while (lines.length > 0) {
+		const head = lines[0].replace(/\r$/, "");
+		if (head.trim().length === 0 || head.trimEnd() === BEGIN_PATCH_MARKER) {
+			lines.shift();
+			continue;
+		}
+		break;
+	}
 	return lines.join("\n");
 }
 
@@ -96,6 +108,8 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 
 	for (const rawLine of lines) {
 		const line = stripTrailingCarriageReturn(rawLine);
+		if (line.trimEnd() === END_PATCH_MARKER || line.trimEnd() === ABORT_MARKER) break;
+		if (isPatchEnvelopeMarker(line)) continue;
 		const header = parseHashlineHeaderLine(line, options.cwd);
 		if (header !== null) {
 			flush();

package/src/hashline/parser.ts

@@ -1,4 +1,4 @@
-import { RANGE_INTERIOR_HASH } from "./constants";
+import { ABORT_MARKER, ABORT_WARNING, BEGIN_PATCH_MARKER, END_PATCH_MARKER, RANGE_INTERIOR_HASH } from "./constants";
 import { describeAnchorExamples, HL_EDIT_SEP, HL_HASH_CAPTURE_RE_RAW } from "./hash";
 import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
 import { stripTrailingCarriageReturn } from "./utils";
@@ -118,6 +118,17 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 			i++;
 			continue;
 		}
+		if (line === END_PATCH_MARKER) {
+			break;
+		}
+		if (line === ABORT_MARKER) {
+			warnings.push(ABORT_WARNING);
+			break;
+		}
+		if (line === BEGIN_PATCH_MARKER) {
+			i++;
+			continue;
+		}
 		if (line.startsWith(HL_EDIT_SEP)) {
 			throw new Error(`line ${lineNum}: payload line has no preceding +, <, or = operation.`);
 		}

package/src/internal-urls/agent-protocol.ts

@@ -42,6 +42,7 @@ async function listAvailableOutputs(artifactsDir: string): Promise<string[]> {
  */
 export class AgentProtocolHandler implements ProtocolHandler {
 	readonly scheme = "agent";
+	readonly immutable = true;
 
 	constructor(private readonly options: AgentProtocolOptions) {}
 

package/src/internal-urls/artifact-protocol.ts

@@ -44,6 +44,7 @@ async function listAvailableArtifacts(artifactsDir: string): Promise<string[]> {
  */
 export class ArtifactProtocolHandler implements ProtocolHandler {
 	readonly scheme = "artifact";
+	readonly immutable = true;
 
 	constructor(private readonly options: ArtifactProtocolOptions) {}