@oh-my-pi/pi-coding-agent 14.5.2 → 14.5.3

package/src/edit/modes/atom.ts

@@ -1,22 +1,24 @@
 /**
  *
  * Flat locator + verb edit mode backed by hashline anchors. Each entry carries
- * one shared `loc` selector plus one or more verbs (`pre`, `splice`, `post`).
+ * one shared `loc` selector plus one or more verbs (`pre`, `splice`, `post`, `sed`).
  * The runtime resolves those verbs into internal anchor-scoped edits and still
  * reuses hashline's staleness scheme (`computeLineHash`) verbatim.
  *
  * External shapes (one entry):
- *   { path, loc: "5th",      splice:  ["..."] }
- *   { path, loc: "5th",      pre:  ["..."] }
- *   { path, loc: "5th",      post: ["..."] }
- *   { path, loc: "5th",      pre: [...], splice: [...], post: [...] }
- *   { path, loc: "$",        pre:  [...] }                            // prepend to file
- *   { path, loc: "$",        post: [...] }                            // append to file
- *   { path, loc: "$",        sed:  { pat, rep, g?, F? } }                 // sed on every line
+ *   { path, loc: "5th",      splice:  ["..."] }                          // line replace
+ *   { path, loc: "(5th)",    splice:  ["..."] }                          // block body replace
+ *   { path, loc: "[5th]",    splice:  ["..."] }                          // whole node replace
+ *   { path, loc: "[5th",     splice:  ["..."] }                          // anchor (incl) → closer-1
+ *   { path, loc: "5th]",     splice:  ["..."] }                          // opener+1 → anchor (incl)
+ *   { path, loc: "5th",      pre: [...], splice: [...], post: [...] }    // line verbs combinable
+ *   { path, loc: "$",        pre: [...] | post: [...] | sed: {...} }    // file-scoped
  *
- * `splice: []` on a single-anchor locator deletes that line. `splice:[""]` preserves
- * a blank line. Line ranges are not supported.
- * in the same entry.
+ * `splice: []` deletes; `splice: [""]` replaces with a single blank line. These
+ * apply uniformly to single-line and bracketed (region) locators.
+ *
+ * Bracket forms in `loc` are reserved for `splice` (region replacement). `pre`,
+ * `post`, and `sed` reject bracketed locators — they are line-only.
  *
  * For deleting or moving files, the agent should use bash.
  */
@@ -29,7 +31,9 @@ import { assertEditableFileContent } from "../../tools/auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { outputMeta } from "../../tools/output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
+import { checkBodyBraceBalance, type DelimiterKind, findEnclosingBlock } from "../block";
 import { generateDiffString } from "../diff";
+import { applyIndent, detectIndentStyle, stripCommonIndent } from "../indent";
 import { computeLineHash, HASHLINE_BIGRAM_RE_SRC, HASHLINE_CONTENT_SEPARATOR } from "../line-hash";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "../normalize";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
@@ -59,7 +63,7 @@ const textSchema = Type.Array(Type.String());
 export const atomEditSchema = Type.Object(
 	{
 		loc: Type.String({
-			description: 'edit location: "1ab", "$", or path override like "a.ts:1ab"',
+			description: "edit location",
 			examples: ["1ab", "$", "src/foo.ts:1ab"],
 		}),
 		splice: Type.Optional(textSchema),
@@ -68,10 +72,9 @@ export const atomEditSchema = Type.Object(
 		sed: Type.Optional(
 			Type.Object(
 				{
-					pat: Type.String({ description: "pattern to find" }),
-					rep: Type.String({ description: "replacement text" }),
-					g: Type.Optional(Type.Boolean({ description: "global replace", default: false })),
-					F: Type.Optional(Type.Boolean({ description: "literal replace", default: false })),
+					pat: Type.String({ description: "regex" }),
+					rep: Type.String({ description: "expression to replace with" }),
+					g: Type.Optional(Type.Boolean({ description: "global flag", default: false })),
 				},
 				{
 					additionalProperties: false,
@@ -105,13 +108,41 @@ export type AtomEdit =
 	| { op: "append_file"; lines: string[] }
 	| { op: "prepend_file"; lines: string[] }
 	| { op: "sed"; pos: Anchor; spec: SedSpec; expression: string }
-	| { op: "sed_file"; spec: SedSpec; expression: string };
+	| { op: "sed_file"; spec: SedSpec; expression: string }
+	| { op: "splice_block"; pos: Anchor; spec: SpliceBlockSpec; bracket: BracketShape };
 
 export interface SedSpec {
 	pattern: string;
 	replacement: string;
 	global: boolean;
-	literal: boolean;
+}
+
+export interface SpliceBlockSpec {
+	body: string[];
+	kind: DelimiterKind;
+}
+
+type BracketShape = "none" | "body" | "node" | "left_incl" | "left_excl" | "right_incl" | "right_excl";
+
+// File-extension lookup for the block delimiter family used when `loc`
+// has bracket forms. Most languages are brace-family; lisp-family uses `(`.
+// Anything not listed defaults to `{` (covers the long tail of brace-style
+// languages without enumerating every extension).
+const LISP_EXTENSIONS = new Set(["clj", "cljs", "cljc", "edn", "lisp", "lsp", "el", "scm", "ss", "rkt", "fnl"]);
+
+function fileExtension(path: string | undefined): string | undefined {
+	if (!path) return undefined;
+	const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	const base = slash >= 0 ? path.slice(slash + 1) : path;
+	const dot = base.lastIndexOf(".");
+	if (dot <= 0) return undefined;
+	return base.slice(dot + 1).toLowerCase();
+}
+
+function resolveBlockDelimiterForPath(path: string | undefined): DelimiterKind {
+	const ext = fileExtension(path);
+	if (ext && LISP_EXTENSIONS.has(ext)) return "(";
+	return "{";
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -135,7 +166,9 @@ const ANCHOR_PREFIX_RE = new RegExp(`^\\s*[>+-]*\\s*\\d+${HASHLINE_BIGRAM_RE_SRC
 // `C:\path\a.ts:160sr` still resolve correctly because the first colon's RHS
 // fails the anchor pattern.
 const ANCHOR_TAG_RE_SRC = `\\s*[>+-]*\\s*\\d+${HASHLINE_BIGRAM_RE_SRC}`;
-const PATH_LOC_SPLIT_RE = new RegExp(`^(.+?):(${ANCHOR_TAG_RE_SRC}(?:-${ANCHOR_TAG_RE_SRC})?(?:[|:].*)?)$`);
+const PATH_LOC_SPLIT_RE = new RegExp(
+	`^(.+?):([\\[(]?${ANCHOR_TAG_RE_SRC}(?:-${ANCHOR_TAG_RE_SRC})?(?:[|:].*)?[\\])]?)$`,
+);
 
 function stripNullAtomFields(edit: AtomToolEdit): AtomToolEdit {
 	let next: Record<string, unknown> | undefined;
@@ -148,7 +181,7 @@ function stripNullAtomFields(edit: AtomToolEdit): AtomToolEdit {
 	return (next ?? fields) as AtomToolEdit;
 }
 
-type ParsedAtomLoc = { kind: "anchor"; pos: Anchor } | { kind: "file" };
+type ParsedAtomLoc = { kind: "anchor"; pos: Anchor; bracket: BracketShape } | { kind: "file" };
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Resolution
@@ -227,28 +260,52 @@ export function resolveAtomEntryPaths(
 }
 
 function parseLoc(raw: string, editIndex: number): ParsedAtomLoc {
-	if (raw === "$") return { kind: "file" };
+	const trimmed = raw.trim();
+	if (trimmed === "$") return { kind: "file" };
+
+	const leading = trimmed[0];
+	const trailing = trimmed[trimmed.length - 1];
+	const hasLeading = leading === "[" || leading === "(";
+	const hasTrailing = trailing === "]" || trailing === ")";
+	if ((leading === "(" && trailing === "]") || (leading === "[" && trailing === ")")) {
+		throw new Error(
+			`Edit ${editIndex}: mixed bracket inclusivity in loc is ambiguous; use [anchor, (anchor, anchor], anchor), [anchor], or a bare anchor.`,
+		);
+	}
+
+	let inner = trimmed;
+	if (hasLeading) inner = inner.slice(1);
+	if (hasTrailing) inner = inner.slice(0, -1);
+
 	// Detect range syntax explicitly: "<anchor>-<anchor>". A bare `-` inside the
 	// loc (e.g. line content like `i--`) should not trigger the range error.
-	const dash = raw.indexOf("-");
+	const dash = inner.indexOf("-");
 	if (dash > 0) {
-		const left = raw.slice(0, dash);
-		const right = raw.slice(dash + 1);
+		const left = inner.slice(0, dash);
+		const right = inner.slice(dash + 1);
 		if (tryParseAtomTag(left) !== undefined && tryParseAtomTag(right) !== undefined) {
 			throw new Error(
 				`Edit ${editIndex}: atom loc does not support line ranges. Use a single anchor like "160sr" or "$".`,
 			);
 		}
 	}
-	const pos = parseAnchor(raw, "loc");
+	const pos = parseAnchor(inner, "loc");
 	// Capture an optional content suffix after the anchor: `82zu|  for (...)`.
 	// The suffix acts as a hint for anchor disambiguation when the model's hash
 	// is wrong but the content reveals the intended line.
-	const hint = extractAnchorContentHint(raw);
+	const hint = extractAnchorContentHint(inner);
 	if (hint !== undefined) {
 		pos.contentHint = hint;
 	}
-	return { kind: "anchor", pos };
+
+	let bracket: BracketShape = "none";
+	if (leading === "[" && trailing === "]") bracket = "node";
+	else if (leading === "[") bracket = "left_incl";
+	else if (leading === "(" && trailing === ")") bracket = "body";
+	else if (leading === "(") bracket = "left_excl";
+	else if (trailing === "]") bracket = "right_incl";
+	else if (trailing === ")") bracket = "right_excl";
+	return { kind: "anchor", pos, bracket };
 }
 
 function extractAnchorContentHint(raw: string): string | undefined {
@@ -266,7 +323,7 @@ function extractAnchorContentHint(raw: string): string | undefined {
 
 function parseSedSpec(input: unknown, editIndex: number): SedSpec {
 	if (input === null || typeof input !== "object" || Array.isArray(input)) {
-		throw new Error(`Edit ${editIndex}: sed must be an object with shape {pat, rep, g?, F?}.`);
+		throw new Error(`Edit ${editIndex}: sed must be an object with shape {pat, rep, g?}.`);
 	}
 	const obj = input as Record<string, unknown>;
 	const pat = obj.pat;
@@ -282,27 +339,24 @@ function parseSedSpec(input: unknown, editIndex: number): SedSpec {
 	if (typeof rep !== "string") {
 		throw new Error(`Edit ${editIndex}: sed.rep must be a string.`);
 	}
-	const readBool = (key: "g" | "F", defaultValue: boolean): boolean => {
-		const v = obj[key];
-		if (v === undefined) return defaultValue;
-		if (typeof v !== "boolean") {
-			throw new Error(`Edit ${editIndex}: sed.${key} must be a boolean when provided.`);
+	const rawGlobal = obj.g;
+	let global = false;
+	if (rawGlobal !== undefined) {
+		if (typeof rawGlobal !== "boolean") {
+			throw new Error(`Edit ${editIndex}: sed.g must be a boolean when provided.`);
 		}
-		return v;
-	};
-	const global = readBool("g", false);
-	const literal = readBool("F", false);
-	return { pattern: pat, replacement: rep, global, literal };
+		global = rawGlobal;
+	}
+	return { pattern: pat, replacement: rep, global };
 }
 
 function formatSedExpression(spec: SedSpec): string {
-	const obj: { pat: string; rep: string; g?: boolean; F?: boolean } = {
+	const obj: { pat: string; rep: string; g?: boolean } = {
 		pat: spec.pattern,
 		rep: spec.replacement,
 	};
 	// Only emit non-default flags so error messages stay compact (g defaults false).
 	if (spec.global) obj.g = true;
-	if (spec.literal) obj.F = true;
 	return JSON.stringify(obj);
 }
 
@@ -322,9 +376,6 @@ function applySedToLine(
 	currentLine: string,
 	spec: SedSpec,
 ): { result: string; matched: boolean; error?: string; literalFallback?: boolean } {
-	if (spec.literal) {
-		return applyLiteralSed(currentLine, spec);
-	}
 	let flags = "";
 	if (spec.global) flags += "g";
 	let re: RegExp | undefined;
@@ -367,7 +418,7 @@ function classifyAtomEdit(edit: AtomToolEdit): string {
 	return verbs.length > 0 ? verbs.join("+") : "unknown";
 }
 
-function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
+function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0, path?: string): AtomEdit[] {
 	const entry = stripNullAtomFields(edit);
 	const verbKeysPresent = ATOM_VERB_KEYS.filter(k => entry[k] !== undefined);
 	if (verbKeysPresent.length === 0) {
@@ -399,6 +450,25 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 		return resolved;
 	}
 
+	if (loc.bracket !== "none") {
+		// Bracketed locator: only `splice` is meaningful (region replacement).
+		const hasInvalidVerb = entry.pre !== undefined || entry.post !== undefined || entry.sed !== undefined;
+		if (hasInvalidVerb) {
+			throw new Error(
+				`Edit ${editIndex}: bracket forms in loc are splice-only; remove pre/post/sed or use a bare anchor.`,
+			);
+		}
+		if (entry.splice === undefined) {
+			throw new Error(
+				`Edit ${editIndex}: bracket loc requires \`splice\`. Bare anchors are line-only; brackets address a region.`,
+			);
+		}
+		const kind = resolveBlockDelimiterForPath(path);
+		const body = hashlineParseText(entry.splice);
+		resolved.push({ op: "splice_block", pos: loc.pos, spec: { body, kind }, bracket: loc.bracket });
+		return resolved;
+	}
+
 	if (entry.pre !== undefined) {
 		resolved.push({ op: "pre", pos: loc.pos, lines: hashlineParseText(entry.pre) });
 	}
@@ -442,6 +512,7 @@ function* getAtomAnchors(edit: AtomEdit): Iterable<Anchor> {
 		case "post":
 		case "del":
 		case "sed":
+		case "splice_block":
 			yield edit.pos;
 			return;
 		default:
@@ -542,6 +613,151 @@ export interface AtomNoopEdit {
 	current: string;
 }
 
+interface SpliceBlockApplyResult {
+	text: string;
+	firstChangedLine: number | undefined;
+}
+
+type SpliceBlockEdit = Extract<AtomEdit, { op: "splice_block" }>;
+
+function lineStartOffset(text: string, line: number): number {
+	let currentLine = 1;
+	let offset = 0;
+	while (offset < text.length && currentLine < line) {
+		if (text[offset] === "\n") currentLine++;
+		offset++;
+	}
+	return offset;
+}
+
+function lineEndOffset(text: string, line: number): number {
+	let offset = lineStartOffset(text, line);
+	while (offset < text.length && text[offset] !== "\n") offset++;
+	return offset;
+}
+
+function lineEndIncludingNewlineOffset(text: string, line: number): number {
+	const offset = lineEndOffset(text, line);
+	return text[offset] === "\n" ? offset + 1 : offset;
+}
+
+function spliceBlockLocatorLabel(bracket: BracketShape): string {
+	switch (bracket) {
+		case "none":
+		case "body":
+			return "(anchor)";
+		case "node":
+			return "[anchor]";
+		case "left_incl":
+			return "[anchor";
+		case "left_excl":
+			return "(anchor";
+		case "right_incl":
+			return "anchor]";
+		case "right_excl":
+			return "anchor)";
+	}
+}
+
+function applySpliceBlockEdits(
+	originalText: string,
+	edits: SpliceBlockEdit[],
+	warnings: string[],
+): SpliceBlockApplyResult {
+	// Sort by anchor line descending so applying earlier ops doesn't shift
+	// later anchors. (Multiple splice_block ops within one call are assumed
+	// non-overlapping; overlapping ranges are not supported.)
+	const sorted = [...edits].sort((a, b) => b.pos.line - a.pos.line);
+	const destStyle = detectIndentStyle(originalText);
+	let text = originalText;
+	let firstChangedLine: number | undefined;
+
+	for (const edit of sorted) {
+		const kind: DelimiterKind = edit.spec.kind;
+		const found = findEnclosingBlock(text, edit.pos.line, { kind, depth: 0 });
+		if ("message" in found) {
+			throw new Error(`splice at anchor ${edit.pos.line}: ${found.message}`);
+		}
+		const replacedLineCount = found.closeLine - found.openLine + 1;
+		warnings.push(
+			`splice locator ${spliceBlockLocatorLabel(edit.bracket)} replaced \`${kind}\` block at lines ${found.openLine}-${found.closeLine} ` +
+				`(${replacedLineCount} lines, 1 of ${found.enclosingCount} enclosing \`${kind}\` blocks).`,
+		);
+		const balanceErr = checkBodyBraceBalance(edit.spec.body.join("\n"), kind);
+		if (balanceErr) {
+			throw new Error(`splice at anchor ${edit.pos.line}: ${balanceErr}`);
+		}
+
+		const stripped = stripCommonIndent(edit.spec.body);
+		const bodyPrefix = found.bodyLineIndent ?? `${found.openerLineIndent}${defaultIndentUnit(destStyle)}`;
+
+		let replacementText: string;
+		let replaceStart: number;
+		let replaceEnd: number;
+
+		switch (edit.bracket) {
+			case "node": {
+				const indented = applyIndent(stripped, found.openerLineIndent, destStyle);
+				replacementText = indented.join("\n");
+				replaceStart = found.openLineStart;
+				replaceEnd = found.closeOffsetExclusive;
+				break;
+			}
+			case "left_incl":
+			case "left_excl": {
+				const indented = applyIndent(stripped, bodyPrefix, destStyle);
+				replacementText = `${indented.join("\n")}\n${found.openerLineIndent}`;
+				replaceStart =
+					edit.bracket === "left_incl"
+						? lineStartOffset(text, edit.pos.line)
+						: lineEndIncludingNewlineOffset(text, edit.pos.line);
+				replaceEnd = found.bodyEnd;
+				break;
+			}
+			case "right_incl":
+			case "right_excl": {
+				const indented = applyIndent(stripped, bodyPrefix, destStyle);
+				replacementText = `\n${indented.join("\n")}\n`;
+				replaceStart = found.bodyStart;
+				replaceEnd =
+					edit.bracket === "right_incl"
+						? lineEndIncludingNewlineOffset(text, edit.pos.line)
+						: lineStartOffset(text, edit.pos.line);
+				break;
+			}
+			case "none":
+			case "body": {
+				const goInline = found.sameLine && stripped.length === 1;
+				if (goInline) {
+					const single = stripped.length === 0 ? "" : stripped[0]!.trim();
+					const pad = kind === "{" ? " " : "";
+					replacementText = single.length > 0 ? `${pad}${single}${pad}` : pad;
+				} else {
+					const indented = applyIndent(stripped, bodyPrefix, destStyle);
+					replacementText = `\n${indented.join("\n")}\n${found.openerLineIndent}`;
+				}
+				replaceStart = found.bodyStart;
+				replaceEnd = found.bodyEnd;
+				break;
+			}
+		}
+
+		const before = text.slice(0, replaceStart);
+		const after = text.slice(replaceEnd);
+		const newText = before + replacementText + after;
+
+		text = newText;
+		if (firstChangedLine === undefined || found.openLine < firstChangedLine) {
+			firstChangedLine = found.openLine;
+		}
+	}
+	return { text, firstChangedLine };
+}
+
+function defaultIndentUnit(style: { kind: "tab" | "space"; width: number }): string {
+	return style.kind === "tab" ? "\t" : " ".repeat(Math.max(1, style.width));
+}
+
 export function applyAtomEdits(
 	text: string,
 	edits: AtomEdit[],
@@ -578,6 +794,26 @@ export function applyAtomEdits(
 	}
 	validateNoConflictingAnchorOps(effective);
 
+	// splice_block ops own their entire block range. To keep line numbers sane,
+	// they cannot mix with other anchor-scoped ops in the same call. They may
+	// coexist with each other (sorted by openLine descending so earlier ops
+	// don't shift later anchors).
+	const spliceBlockEdits = effective.filter(
+		(e): e is Extract<AtomEdit, { op: "splice_block" }> => e.op === "splice_block",
+	);
+	if (spliceBlockEdits.length > 0) {
+		const result = applySpliceBlockEdits(text, spliceBlockEdits, warnings);
+		if (result.firstChangedLine !== undefined) {
+			if (firstChangedLine === undefined || result.firstChangedLine < firstChangedLine) {
+				firstChangedLine = result.firstChangedLine;
+			}
+		}
+		// Continue pipeline against the post-splice_block text.
+		fileLines.length = 0;
+		for (const line of result.text.split("\n")) fileLines.push(line);
+		effective = effective.filter(e => e.op !== "splice_block");
+	}
+
 	const trackFirstChanged = (line: number) => {
 		if (firstChangedLine === undefined || line < firstChangedLine) {
 			firstChangedLine = line;
@@ -661,7 +897,7 @@ export function applyAtomEdits(
 					}
 					if (literalFallback) {
 						warnings.push(
-							`sed expression ${JSON.stringify(edit.expression)} did not match as a regex on line ${edit.pos.line}; applied literal substring substitution instead. Use the \`F\` flag (e.g. \`s/.../.../F\`) for literal patterns or escape regex metacharacters.`,
+							`sed expression ${JSON.stringify(edit.expression)} did not match as a regex on line ${edit.pos.line}; applied literal substring substitution instead. Escape regex metacharacters in the pattern to match as a regex.`,
 						);
 					}
 					replacement = [result];
@@ -753,7 +989,7 @@ export function applyAtomEdits(
 			anyMatched = true;
 			if (r.literalFallback && !warnedLiteralFallback) {
 				warnings.push(
-					`sed expression ${JSON.stringify(edit.expression)} did not match as a regex; applied literal substring substitution. Use the \`F\` flag (e.g. \`s/.../.../F\`) for literal patterns or escape regex metacharacters.`,
+					`sed expression ${JSON.stringify(edit.expression)} did not match as a regex; applied literal substring substitution. Escape regex metacharacters in the pattern to match as a regex.`,
 				);
 				warnedLiteralFallback = true;
 			}
@@ -797,7 +1033,7 @@ export async function executeAtomSingle(
 ): Promise<AgentToolResult<EditToolDetails, typeof atomEditParamsSchema>> {
 	const { session, path, edits, signal, batchRequest, writethrough, beginDeferredDiagnosticsForPath } = options;
 
-	const contentEdits = edits.flatMap((edit, i) => resolveAtomToolEdit(edit, i));
+	const contentEdits = edits.flatMap((edit, i) => resolveAtomToolEdit(edit, i, path));
 
 	enforcePlanModeWrite(session, path, { op: "update" });
 

package/src/lsp/utils.ts

@@ -4,6 +4,7 @@ import * as fs from "node:fs/promises";
 import path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { type Theme, theme } from "../modes/theme/theme";
+import { formatGroupedFiles } from "../tools/grouped-file-output";
 import { resolveToCwd } from "../tools/path-utils";
 import type {
 	CodeAction,
@@ -154,7 +155,7 @@ const DIAG_PATH_RE = /^(.+?):(\d+:\d+\s+.*)$/;
 /**
  * Reformat pre-formatted diagnostic messages into grep-style directory/file groups.
  * Input:  ["path:line:col [sev] msg", ...]
- * Output: "# dir\n## └─ file.ts\n  line:col [sev] msg"
+ * Output: "# dir/\n## file.ts\n  line:col [sev] msg"
  *
  * Messages that don't match the expected format are appended ungrouped at the end.
  */
@@ -183,41 +184,10 @@ export function formatGroupedDiagnosticMessages(messages: string[]): string {
 		return ungrouped.join("\n");
 	}
 
-	const filesByDirectory = new Map<string, string[]>();
-	for (const filePath of fileOrder) {
-		const directory = path.dirname(filePath).replace(/\\/g, "/");
-		if (!filesByDirectory.has(directory)) {
-			filesByDirectory.set(directory, []);
-		}
-		filesByDirectory.get(directory)?.push(filePath);
-	}
-
-	const lines: string[] = [];
-	for (const [directory, directoryFiles] of filesByDirectory) {
-		if (directory === ".") {
-			for (const filePath of directoryFiles) {
-				if (lines.length > 0) {
-					lines.push("");
-				}
-				lines.push(`# ${path.basename(filePath)}`);
-				for (const diagnostic of diagnosticsByFile.get(filePath) ?? []) {
-					lines.push(`  ${diagnostic}`);
-				}
-			}
-			continue;
-		}
-
-		if (lines.length > 0) {
-			lines.push("");
-		}
-		lines.push(`# ${directory}`);
-		for (const filePath of directoryFiles) {
-			lines.push(`## └─ ${path.basename(filePath)}`);
-			for (const diagnostic of diagnosticsByFile.get(filePath) ?? []) {
-				lines.push(`  ${diagnostic}`);
-			}
-		}
-	}
+	const grouped = formatGroupedFiles(fileOrder, filePath => ({
+		modelLines: (diagnosticsByFile.get(filePath) ?? []).map(diagnostic => `  ${diagnostic}`),
+	}));
+	const lines: string[] = grouped.model;
 
 	if (ungrouped.length > 0) {
 		lines.push("");

package/src/modes/controllers/event-controller.ts

@@ -52,6 +52,7 @@ export class EventController {
 			ttsr_triggered: e => this.#handleTtsrTriggered(e),
 			todo_reminder: e => this.#handleTodoReminder(e),
 			todo_auto_clear: e => this.#handleTodoAutoClear(e),
+			irc_message: e => this.#handleIrcMessage(e),
 		} satisfies AgentSessionEventHandlers;
 	}
 
@@ -203,6 +204,17 @@ export class EventController {
 		}
 	}
 
+	async #handleIrcMessage(event: Extract<AgentSessionEvent, { type: "irc_message" }>): Promise<void> {
+		const signature = `${event.message.role}:${event.message.customType}:${event.message.timestamp}`;
+		if (this.#renderedCustomMessages.has(signature)) {
+			return;
+		}
+		this.#renderedCustomMessages.add(signature);
+		this.#resetReadGroup();
+		this.ctx.addMessageToChat(event.message);
+		this.ctx.ui.requestRender();
+	}
+
 	async #handleMessageUpdate(event: Extract<AgentSessionEvent, { type: "message_update" }>): Promise<void> {
 		if (this.ctx.streamingComponent && event.message.role === "assistant") {
 			this.ctx.streamingMessage = event.message;