@ian-pascoe/pi-lsp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ian Pascoe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# @ian-pascoe/pi-lsp
+
+Configured language-server tools and post-edit diagnostics for
+[Pi](https://github.com/earendil-works/pi).
+
+## Install
+
+```bash
+pi install npm:@ian-pascoe/pi-lsp
+# or
+pi install git:github.com/ian-pascoe/pi-extensions
+```
+
+For a local checkout, run `pi -e ./packages/pi-lsp/src/index.ts`.
+
+Install every language-server executable separately. Pi LSP contains no server catalog or
+installer. It launches configured commands over stdio with the Pi process's environment and
+permissions.
+
+## Settings
+
+Pi LSP reads only the `lsp` key from Pi's global `settings.json` and trusted project
+`.pi/settings.json`:
+
+```json
+{
+  "lsp": {
+    "timeouts": {
+      "initializeMs": 45000,
+      "requestMs": 3000,
+      "diagnosticsMs": 3000,
+      "shutdownMs": 5000
+    },
+    "servers": {
+      "typescript": {
+        "command": "pnpm",
+        "args": ["exec", "tsc", "--lsp", "--stdio"],
+        "languages": [
+          {
+            "extensions": [".ts", ".mts", ".cts"],
+            "languageId": "typescript"
+          },
+          {
+            "extensions": [".tsx"],
+            "languageId": "typescriptreact"
+          }
+        ],
+        "rootMarkers": ["tsconfig.json", "package.json", ".git"],
+        "initializationOptions": {},
+        "settings": {},
+        "environment": {}
+      }
+    }
+  }
+}
+```
+
+Every field is optional except an enabled server's non-empty `command` and `languages`. Each
+language needs a non-empty `languageId` and at least one extension or exact filename. Extensions
+include their leading period. `rootMarkers` are basename glob patterns; the nearest matching
+ancestor becomes the server root and Pi's working directory is the fallback.
+
+Global and project timeouts merge by field. A project server replaces the complete global server
+with the same ID; set a project server to `null` to remove it. `initializationOptions` is sent only
+during initialization. `settings` is used for `workspace/didChangeConfiguration` and
+`workspace/configuration`. Environment strings override `process.env`; `null` removes a variable.
+A malformed layer or unknown field disables LSP startup and remains visible through `status`.
+Untrusted project settings are ignored.
+
+Pi's `/reload` reloads configuration. Servers start on first use, live for one Pi session, and stay
+unavailable after a process or protocol failure until `restart` or `/reload`.
+
+## `lsp` tool
+
+The extension registers one strict `lsp` tool with these operations:
+
+```text
+status                       capabilities                  restart
+diagnostics                  workspace_diagnostics         completion
+hover                        signature_help                declaration
+goto_definition              goto_type_definition          goto_implementation
+find_references              document_highlights           document_symbols
+workspace_symbols            document_links                call_hierarchy
+incoming_calls               outgoing_calls                type_hierarchy
+supertypes                   subtypes                      selection_ranges
+folding_ranges               code_lenses                   inlay_hints
+document_colors              format_document               format_range
+format_on_type               prepare_rename                rename
+code_actions                 apply
+```
+
+File operations use `file_path`. Position operations also use one-based `line` and `character`;
+characters count Unicode code points, regardless of the server's negotiated UTF-8, UTF-16, or
+UTF-32 encoding. `selection_ranges` accepts a `positions` array. `find_references` accepts
+`include_declaration`.
+
+`workspace_symbols` requires `query` and a root-anchor `file_path`. `workspace_diagnostics`,
+`capabilities`, and `restart` require `server_id` and a root-anchor `file_path`. Other reads query
+every matching capable server unless narrowed by `server_id`; successful responses remain visible
+when another server fails. A mutation may omit `server_id` only when exactly one matching capable
+server exists.
+
+Formatting requires `tab_size` and `insert_spaces`. It optionally accepts
+`trim_trailing_whitespace`, `insert_final_newline`, and `trim_final_newlines`. Range formatting also
+requires `start` and `end`; on-type formatting requires a position and `trigger_character`.
+`rename` requires `new_name`. `code_actions` accepts a range and optional `only_kinds` filters.
+
+Workspace diagnostics use protocol workspace pull when available and cached push diagnostics
+otherwise. They never crawl the project to open files. Non-file result URIs such as `jar:` remain
+readable.
+
+In Pi's interactive transcript, each LSP call stays compact until tool output is expanded. The
+collapsed row shows the operation, target, and outcome; the expanded row adds structured server or
+mutation details followed by the exact tool output. Rendering uses Pi's active theme and native
+tool-output expansion controls.
+
+## Workspace Edit Preview and apply
+
+`rename`, formatting, and edit-bearing code actions return a persisted Workspace Edit Preview.
+They never write immediately. Command-bearing code actions remain visible but cannot be applied.
+Server-initiated `workspace/applyEdit` requests are rejected with `applied: false` and exposed as a
+preview in the active tool result.
+
+Apply a preview with `{ "operation": "apply", "preview_id": "..." }`. Before Pi's `tool_call`
+hooks run, `prepareArguments()` replaces any supplied `mutation_manifest` with canonical absolute
+entries shaped as:
+
+```json
+{
+  "mutation_manifest": [
+    {
+      "operation": "modify",
+      "path": "/absolute/canonical/content/target"
+    },
+    {
+      "operation": "rename",
+      "path": "/absolute/old/name",
+      "destination_path": "/absolute/new/name"
+    }
+  ]
+}
+```
+
+`operation` is `create`, `modify`, `delete`, or `rename`; only rename also has
+`destination_path`. A permission extension may inspect or
+block this manifest. Pi LSP validates it again after all hooks, then rechecks preview state,
+existence, hashes, modes, and destinations inside Pi's sorted per-file mutation queues. Paths are
+not restricted to the workspace.
+
+Application uses temporary-file replacement, preserves modes and UTF-8 BOMs, and keeps originals
+for reverse rollback. Content edits follow existing symlinks and expose the canonical target;
+rename and delete address the named directory entry. The guarded batch is rollback-capable, not
+crash-atomic. A recovery failure reports every unrecovered path.
+
+## Post-edit Diagnostics
+
+Pi LSP appends fresh diagnostics to results from:
+
+- any `edit` or `write` tool whose input has a string `path`;
+- `apply_patch` results using the current `pi-codex-conversion` success/partial-result details;
+- successful or partially applied LSP previews.
+
+Changed, created, and renamed destination files are diagnosed; deleted files are not. Every
+recognized result gets an explicit outcome, including `no diagnostics`, `no configured server`,
+timeout, unavailable server, or an `apply_patch` adapter-version warning. Diagnostics preserve
+duplicates from independent servers and never change the original tool's success or error state.
+
+Findings, matched-server failures, timeouts, and adapter warnings also appear in one expandable
+Post-edit Diagnostics Entry after the current tool batch. Clean results and files without a
+configured server stay silent in the transcript. This entry is excluded from model context; the
+model sees diagnostics only in the original mutation result.
+
+## Limits and lifecycle
+
+Every operation uses Pi's 2,000-line/50-KB output limit. Complete truncated text is saved as a
+Result Spill and the result names its path. Each server's latest 1 MB of stderr is saved in the
+session temp directory and failure messages name that path.
+
+Documents must be valid UTF-8. Each server keeps at most 100 synchronized documents and closes
+least-recently-used documents. Session shutdown requests a graceful LSP shutdown, then terminates
+the process within the configured timeout.
+
+## Security
+
+Trusted project settings can launch arbitrary local executables with all permissions of the Pi
+process. Review settings and server binaries before trusting a project. Mutation manifests can be
+blocked by another extension, but Pi LSP itself intentionally imposes no workspace path boundary.

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@ian-pascoe/pi-lsp",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Configured language-server tools and post-edit diagnostics for Pi",
+  "keywords": [
+    "lsp",
+    "pi",
+    "pi-extension",
+    "pi-package"
+  ],
+  "homepage": "https://github.com/ian-pascoe/pi-extensions#readme",
+  "bugs": {
+    "url": "https://github.com/ian-pascoe/pi-extensions/issues"
+  },
+  "license": "MIT",
+  "author": "Ian Pascoe <ian.g.pascoe@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ian-pascoe/pi-extensions.git",
+    "directory": "packages/pi-lsp"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "test": "vitest run --config ../../vitest.config.ts --root .",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "cross-spawn": "^7.0.6",
+    "vscode-languageserver-protocol": "^3.17.5"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { default } from "./pi-lsp-extension.js";

package/src/lsp-position-encoding.ts

@@ -0,0 +1,134 @@
+/** A negotiated LSP character-unit encoding supported by the protocol. */
+export type LspPositionEncoding = "utf-8" | "utf-16" | "utf-32";
+
+/** A one-based source position whose character counts Unicode code points. */
+export interface LspCodePointPosition {
+  /** One-based document line. */
+  readonly line: number;
+  /** One-based Unicode-code-point character within the line. */
+  readonly character: number;
+}
+
+/** A zero-based LSP protocol position whose character uses the negotiated encoding. */
+export interface LspProtocolPosition {
+  /** Zero-based document line. */
+  readonly line: number;
+  /** Zero-based encoded character offset within the line. */
+  readonly character: number;
+}
+
+/** Normalize a server's negotiated position encoding, defaulting protocol omissions to UTF-16. */
+export function normalizeLspPositionEncoding(encoding: string | undefined): LspPositionEncoding {
+  if (encoding === "utf-8") return "utf-8";
+  if (encoding === "utf-32") return "utf-32";
+  return "utf-16";
+}
+
+function documentLines(documentText: string): readonly string[] {
+  return documentText.split(/\r\n|[\n\r]/u);
+}
+
+function requirePositiveInteger(value: number, description: string): void {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`Pi LSP: ${description} must be a positive integer`);
+  }
+}
+
+function requireNonNegativeInteger(value: number, description: string): void {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`Pi LSP: ${description} must be a non-negative integer`);
+  }
+}
+
+function requireCodePointLine(
+  lines: readonly string[],
+  position: LspCodePointPosition,
+): readonly string[] {
+  requirePositiveInteger(position.line, "code-point position line");
+  requirePositiveInteger(position.character, "code-point position character");
+  const line = lines[position.line - 1];
+  if (line === undefined) {
+    throw new Error("Pi LSP: code-point position line exceeds document length");
+  }
+  return Array.from(line);
+}
+
+function requireProtocolLine(lines: readonly string[], position: LspProtocolPosition): string {
+  requireNonNegativeInteger(position.line, "protocol position line");
+  requireNonNegativeInteger(position.character, "protocol position character");
+  const line = lines[position.line];
+  if (line === undefined) {
+    throw new Error("Pi LSP: protocol position line exceeds document length");
+  }
+  return line;
+}
+
+function encodedCharacterLength(character: string, encoding: LspPositionEncoding): number {
+  switch (encoding) {
+    case "utf-8":
+      return Buffer.byteLength(character, "utf8");
+    case "utf-16":
+      return character.length;
+    case "utf-32":
+      return 1;
+  }
+}
+
+/** Return the negotiated LSP character length of one line of document text. */
+export function measureLspPositionCharacters(text: string, encoding: LspPositionEncoding): number {
+  if (encoding === "utf-8") return Buffer.byteLength(text, "utf8");
+  if (encoding === "utf-32") return Array.from(text).length;
+  return text.length;
+}
+
+function protocolCharacterOffset(
+  characters: readonly string[],
+  codePointOffset: number,
+  encoding: LspPositionEncoding,
+): number {
+  let encodedOffset = 0;
+  for (const character of characters.slice(0, codePointOffset)) {
+    encodedOffset += encodedCharacterLength(character, encoding);
+  }
+  return encodedOffset;
+}
+
+/** Convert a one-based Unicode code-point position to a zero-based negotiated LSP position. */
+export function convertLspCodePointPosition(
+  documentText: string,
+  position: LspCodePointPosition,
+  encoding: LspPositionEncoding,
+): LspProtocolPosition {
+  const characters = requireCodePointLine(documentLines(documentText), position);
+  const codePointOffset = position.character - 1;
+  if (codePointOffset > characters.length) {
+    throw new Error("Pi LSP: code-point position character exceeds line length");
+  }
+  return {
+    line: position.line - 1,
+    character: protocolCharacterOffset(characters, codePointOffset, encoding),
+  };
+}
+
+/** Convert a zero-based negotiated LSP position to one-based Unicode code-point coordinates. */
+export function convertLspProtocolPosition(
+  documentText: string,
+  position: LspProtocolPosition,
+  encoding: LspPositionEncoding,
+): LspCodePointPosition {
+  const line = requireProtocolLine(documentLines(documentText), position);
+  const characters = Array.from(line);
+  let encodedOffset = 0;
+  for (let codePointOffset = 0; codePointOffset <= characters.length; codePointOffset++) {
+    if (encodedOffset === position.character) {
+      return { line: position.line + 1, character: codePointOffset + 1 };
+    }
+    const character = characters[codePointOffset];
+    if (character === undefined) break;
+    encodedOffset += encodedCharacterLength(character, encoding);
+    if (encodedOffset > position.character) {
+      throw new Error("Pi LSP: protocol position splits a Unicode character");
+    }
+  }
+  throw new Error("Pi LSP: protocol position character exceeds line length");
+}

package/src/lsp-post-edit-diagnostics-rendering.ts

@@ -0,0 +1,249 @@
+import { relative } from "node:path";
+import { keyText, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text, type Component } from "@earendil-works/pi-tui";
+import { type Static, Type } from "typebox";
+import { Value } from "typebox/value";
+import {
+  PostEditDiagnosticOutcomeSchema,
+  type PostEditDiagnosticOutcome,
+} from "./lsp-post-edit-diagnostics.js";
+
+/** Custom session entry type used for model-invisible Post-edit Diagnostics presentation. */
+export const POST_EDIT_DIAGNOSTICS_ENTRY_TYPE = "pi-lsp-post-edit-diagnostics";
+
+/** Persisted data for one model-invisible Post-edit Diagnostics Entry. */
+export const PostEditDiagnosticsEntryDataSchema = Type.Object(
+  {
+    cwd: Type.String({ minLength: 1 }),
+    outcomes: Type.Array(PostEditDiagnosticOutcomeSchema),
+  },
+  { additionalProperties: false },
+);
+
+/** Validated data rendered by one model-invisible Post-edit Diagnostics Entry. */
+export type PostEditDiagnosticsEntryData = Static<typeof PostEditDiagnosticsEntryDataSchema>;
+
+/** Theme operations used by Post-edit Diagnostics Entry rendering. */
+export type PostEditDiagnosticsEntryTheme = Pick<Theme, "bg" | "bold" | "fg">;
+
+type ReportablePostEditDiagnosticOutcome = Exclude<
+  PostEditDiagnosticOutcome,
+  { kind: "no_diagnostics" | "no_configured_server" }
+>;
+
+type DiagnosticSeverity = "error" | "warning" | "information" | "hint" | "diagnostic";
+
+function isReportablePostEditDiagnosticOutcome(
+  outcome: PostEditDiagnosticOutcome,
+): outcome is ReportablePostEditDiagnosticOutcome {
+  return outcome.kind !== "no_diagnostics" && outcome.kind !== "no_configured_server";
+}
+
+function diagnosticSeverity(severity: number): DiagnosticSeverity {
+  switch (severity) {
+    case 1:
+      return "error";
+    case 2:
+      return "warning";
+    case 3:
+      return "information";
+    case 4:
+      return "hint";
+    default:
+      return "diagnostic";
+  }
+}
+
+function severityColor(severity: DiagnosticSeverity): ThemeColor {
+  switch (severity) {
+    case "error":
+      return "error";
+    case "warning":
+      return "warning";
+    case "information":
+      return "accent";
+    case "hint":
+    case "diagnostic":
+      return "muted";
+  }
+}
+
+function pluralizedCount(count: number, singular: string, plural = `${singular}s`): string {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+
+function entrySummary(data: PostEditDiagnosticsEntryData, theme: PostEditDiagnosticsEntryTheme) {
+  const counts = new Map<DiagnosticSeverity, number>();
+  const files = new Set<string>();
+  let adapterWarnings = 0;
+  let timeouts = 0;
+  let serverIssues = 0;
+  for (const outcome of data.outcomes) {
+    switch (outcome.kind) {
+      case "diagnostic": {
+        const severity = diagnosticSeverity(outcome.diagnostic.severity);
+        counts.set(severity, (counts.get(severity) ?? 0) + 1);
+        files.add(outcome.diagnostic.path);
+        break;
+      }
+      case "timeout":
+        timeouts++;
+        files.add(outcome.path);
+        break;
+      case "unavailable_server":
+        serverIssues++;
+        files.add(outcome.path);
+        break;
+      case "warning":
+        adapterWarnings++;
+        break;
+      case "no_diagnostics":
+      case "no_configured_server":
+        break;
+    }
+  }
+
+  const warnings = (counts.get("warning") ?? 0) + adapterWarnings;
+  const metrics = [
+    [counts.get("error") ?? 0, "error", "errors", "error"],
+    [warnings, "warning", "warnings", "warning"],
+    [counts.get("information") ?? 0, "info", "info", "accent"],
+    [counts.get("hint") ?? 0, "hint", "hints", "muted"],
+    [counts.get("diagnostic") ?? 0, "diagnostic", "diagnostics", "muted"],
+    [timeouts, "timeout", "timeouts", "warning"],
+    [serverIssues, "server issue", "server issues", "warning"],
+  ] as const;
+  return [
+    theme.fg("toolTitle", theme.bold("Post-edit diagnostics")),
+    ...metrics
+      .filter(([count]) => count > 0)
+      .map(([count, singular, plural, color]) =>
+        theme.fg(color, pluralizedCount(count, singular, plural)),
+      ),
+    theme.fg("muted", pluralizedCount(files.size, "file")),
+  ].join(theme.fg("dim", "  ·  "));
+}
+
+function displayPath(cwd: string, path: string): string {
+  const relativePath = relative(cwd, path);
+  return relativePath !== "" && !relativePath.startsWith("..") ? relativePath : path;
+}
+
+function outcomePath(outcome: ReportablePostEditDiagnosticOutcome): string | undefined {
+  return outcome.kind === "diagnostic"
+    ? outcome.diagnostic.path
+    : outcome.kind === "warning"
+      ? undefined
+      : outcome.path;
+}
+
+function compareReportableOutcomes(
+  left: ReportablePostEditDiagnosticOutcome,
+  right: ReportablePostEditDiagnosticOutcome,
+): number {
+  const leftPath = outcomePath(left) ?? "";
+  const rightPath = outcomePath(right) ?? "";
+  if (leftPath !== rightPath) return leftPath.localeCompare(rightPath);
+  if (left.kind === "diagnostic" && right.kind === "diagnostic") {
+    return (
+      left.diagnostic.severity - right.diagnostic.severity ||
+      left.diagnostic.line - right.diagnostic.line ||
+      left.diagnostic.character - right.diagnostic.character ||
+      left.diagnostic.serverId.localeCompare(right.diagnostic.serverId)
+    );
+  }
+  if (left.kind === "diagnostic") return -1;
+  if (right.kind === "diagnostic") return 1;
+  return left.kind.localeCompare(right.kind);
+}
+
+function diagnosticLine(
+  outcome: Extract<ReportablePostEditDiagnosticOutcome, { kind: "diagnostic" }>,
+  theme: PostEditDiagnosticsEntryTheme,
+): string {
+  const diagnostic = outcome.diagnostic;
+  const severity = diagnosticSeverity(diagnostic.severity);
+  return `${theme.fg(severityColor(severity), `${diagnostic.line}:${diagnostic.character}`)}  ${diagnostic.message}  ${theme.fg("muted", diagnostic.serverId)}`;
+}
+
+function unavailableLine(
+  outcome: Extract<ReportablePostEditDiagnosticOutcome, { kind: "timeout" | "unavailable_server" }>,
+  theme: PostEditDiagnosticsEntryTheme,
+): string {
+  const label = outcome.kind === "timeout" ? "Diagnostics timed out" : "Server unavailable";
+  return `${theme.fg("warning", label)}${outcome.serverId === undefined ? "" : `  ${theme.fg("muted", outcome.serverId)}`}`;
+}
+
+function appendExpandedOutcomes(
+  container: Container,
+  data: PostEditDiagnosticsEntryData,
+  theme: PostEditDiagnosticsEntryTheme,
+): void {
+  const reportable = data.outcomes
+    .filter(isReportablePostEditDiagnosticOutcome)
+    .sort(compareReportableOutcomes);
+  const outcomesByPath = new Map<string, ReportablePostEditDiagnosticOutcome[]>();
+  const warnings: Extract<ReportablePostEditDiagnosticOutcome, { kind: "warning" }>[] = [];
+  for (const outcome of reportable) {
+    if (outcome.kind === "warning") {
+      warnings.push(outcome);
+      continue;
+    }
+    const path = outcomePath(outcome);
+    if (path === undefined) continue;
+    const entries = outcomesByPath.get(path) ?? [];
+    entries.push(outcome);
+    outcomesByPath.set(path, entries);
+  }
+
+  for (const [path, outcomes] of outcomesByPath) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("accent", theme.bold(displayPath(data.cwd, path))), 0, 0));
+    for (const outcome of outcomes) {
+      if (outcome.kind === "warning") continue;
+      container.addChild(
+        new Text(
+          outcome.kind === "diagnostic"
+            ? diagnosticLine(outcome, theme)
+            : unavailableLine(outcome, theme),
+          0,
+          0,
+        ),
+      );
+    }
+  }
+  if (warnings.length > 0) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("warning", theme.bold("Warnings")), 0, 0));
+    for (const warning of warnings) container.addChild(new Text(warning.message, 0, 0));
+  }
+}
+
+/** Create a Post-edit Diagnostics Entry only when outcomes deserve transcript attention. */
+export function createPostEditDiagnosticsEntryData(
+  cwd: string,
+  outcomes: readonly PostEditDiagnosticOutcome[],
+): PostEditDiagnosticsEntryData | undefined {
+  const reportable = outcomes.filter(isReportablePostEditDiagnosticOutcome);
+  return reportable.length === 0
+    ? undefined
+    : Value.Parse(PostEditDiagnosticsEntryDataSchema, { cwd, outcomes: reportable });
+}
+
+/** Render one model-invisible Post-edit Diagnostics Entry with native Pi expansion and theming. */
+export function renderPostEditDiagnosticsEntry(
+  data: PostEditDiagnosticsEntryData,
+  expanded: boolean,
+  theme: PostEditDiagnosticsEntryTheme,
+): Component {
+  const container = new Container();
+  const hint = expanded
+    ? ""
+    : `${theme.fg("dim", `  ·  ${keyText("app.tools.expand")}`)}${theme.fg("muted", " to expand")}`;
+  container.addChild(new Text(`${entrySummary(data, theme)}${hint}`, 0, 0));
+  if (expanded) appendExpandedOutcomes(container, data, theme);
+
+  const box = new Box(1, 0, (text) => theme.bg("customMessageBg", text));
+  box.addChild(container);
+  return box;
+}