@plannotator/pi-extension 0.27.6 → 0.27.7

package/generated/ai/providers/child-io.ts

@@ -0,0 +1,93 @@
+// @generated — DO NOT EDIT. Source: packages/ai/providers/child-io.ts
+/**
+ * Stdio guards for the JSONL/JSON-RPC child processes the AI providers drive.
+ *
+ * Both `PiProcessNode` (pi-sdk-node.ts) and `CodexAppServerProcess`
+ * (codex-app-server.ts) talk to a nested agent over pipes, and a pipe can
+ * break at any instant — the child exits, is killed, or closes stdin while a
+ * command is in flight. Two Node behaviors turn that ordinary condition into
+ * a host-killing crash:
+ *
+ *  1. `stream.write()` on a broken pipe reports `EPIPE` either synchronously
+ *     (throw) or asynchronously (an `error` event on the stream), and which
+ *     one you get is a timing race. A `destroyed` check before the write
+ *     cannot close that race: the child can close the pipe between the check
+ *     and the write.
+ *  2. An `error` event on a Node stream (or on the `ChildProcess` itself)
+ *     with NO listener is re-thrown as an `uncaughtException`. Inside an
+ *     embedded extension that is not "the provider failed" — it terminates
+ *     the HOST agent process.
+ *
+ * That is issue #1378: a Plannotator plan review opened from Pi on Windows
+ * took the whole Pi host down with `write EPIPE` out of `PiProcessNode.send()`.
+ * Windows only made it likelier to land on the async path during teardown;
+ * the mechanism is platform-independent.
+ *
+ * The contract these helpers enforce: a broken pipe is a PROVIDER failure.
+ * It never escalates past the provider, it is reported exactly like any other
+ * process end (in-flight requests reject, listeners see the process end), and
+ * the provider is left dead so the next query re-spawns it.
+ */
+
+import type { ChildProcess } from "node:child_process";
+
+/** Normalize an unknown thrown/emitted value to an Error. */
+export function toChildError(err: unknown): Error {
+	return err instanceof Error ? err : new Error(String(err));
+}
+
+/**
+ * Attach `error` listeners to the child process and every piped stream so a
+ * broken pipe can never reach `uncaughtException`.
+ *
+ * Call this immediately after `spawn()` returns — before awaiting the spawn
+ * handshake — so a stream that fails during startup is already covered. The
+ * spawn handshake may register its own one-shot `error` listener; Node allows
+ * several, and `onFailure` is expected to be idempotent.
+ */
+export function guardChildStreams(
+	proc: ChildProcess,
+	label: string,
+	onFailure: (error: Error) => void,
+): void {
+	const report = (stream: string) => (err: unknown) => {
+		onFailure(new Error(`${label} ${stream} failed: ${toChildError(err).message}`));
+	};
+	proc.on("error", report("process"));
+	proc.stdin?.on("error", report("stdin"));
+	proc.stdout?.on("error", report("stdout"));
+	proc.stderr?.on("error", report("stderr"));
+}
+
+/**
+ * Write one already-newline-terminated line to a child's stdin.
+ *
+ * Returns the Error the write failed with, or `null` when the bytes were
+ * accepted by the stream. Failures that only surface later (the write
+ * callback, or an `error` event covered by {@link guardChildStreams}) are
+ * reported through `onAsyncFailure` instead, so BOTH the sync-throw and the
+ * async-event paths end up at the caller's failure handling.
+ */
+export function writeChildLine(
+	proc: ChildProcess | null,
+	line: string,
+	label: string,
+	onAsyncFailure: (error: Error) => void,
+): Error | null {
+	const stdin = proc?.stdin;
+	if (!stdin || stdin.destroyed || stdin.writableEnded) {
+		return new Error(`${label} stdin is closed`);
+	}
+	try {
+		stdin.write(line, (err) => {
+			if (err) {
+				onAsyncFailure(
+					new Error(`${label} stdin write failed: ${toChildError(err).message}`),
+				);
+			}
+		});
+	} catch (err) {
+		return new Error(`${label} stdin write failed: ${toChildError(err).message}`);
+	}
+	return null;
+}

package/generated/ai/providers/codex-app-server.ts

@@ -44,8 +44,10 @@ import {
   killWindowsProcessTree,
   resolveWindowsCommandShim,
 } from "./command-path.ts";
+import { guardChildStreams, writeChildLine } from "./child-io.ts";
 
 const PROVIDER_NAME = "codex-sdk";
+const CODEX_PROCESS_LABEL = "Codex app-server";
 const DEFAULT_MODEL = "gpt-5.6-sol";
 const CLIENT_NAME = "plannotator";
 /** Kill an idle app-server process after this long with no query. */
@@ -335,6 +337,10 @@ class CodexAppServerProcess {
     }
 
     this.proc = proc;
+    // Cover every pipe BEFORE the spawn handshake: an `error` event on a child
+    // stream with no listener becomes an uncaughtException and kills the host
+    // process, not just this provider (#1378).
+    guardChildStreams(proc, CODEX_PROCESS_LABEL, (error) => this.failProcess(error));
     proc.once("exit", () => {
       this.handleProcessEnd(new Error("Codex app-server exited unexpectedly"));
     });
@@ -378,6 +384,23 @@ class CodexAppServerProcess {
     this.send({ method: "initialized", params: {} });
   }
 
+  /**
+   * A pipe to the child broke: resolve it as a provider failure and reap the
+   * child, leaving `alive` false so the next query re-spawns (#1378).
+   */
+  private failProcess(error: Error): void {
+    const proc = this.proc;
+    this.startPromise = null;
+    this.handleProcessEnd(error);
+    if (proc) {
+      try {
+        if (!killWindowsProcessTree(proc.pid)) proc.kill();
+      } catch {
+        // Already gone.
+      }
+    }
+  }
+
   private handleProcessEnd(error: Error): void {
     if (!this.proc && this.pendingRequests.size === 0) return;
     this._alive = false;
@@ -439,9 +462,22 @@ class CodexAppServerProcess {
     }
   }
 
+  /**
+   * Send a JSON-RPC message without waiting for a response.
+   *
+   * A closed or broken stdin is a provider failure, never a throw at the
+   * caller and never an unhandled stream error: both the synchronous throw
+   * and the asynchronous `error`/write-callback paths land in failProcess,
+   * which rejects anything in flight.
+   */
   send(message: RpcMessage): void {
-    if (!this.proc?.stdin || this.proc.stdin.destroyed) return;
-    this.proc.stdin.write(`${JSON.stringify(message)}\n`);
+    const error = writeChildLine(
+      this.proc,
+      `${JSON.stringify(message)}\n`,
+      CODEX_PROCESS_LABEL,
+      (err) => this.failProcess(err),
+    );
+    if (error) this.failProcess(error);
   }
 
   sendAndWait(message: RpcMessage, timeoutMs = RPC_TIMEOUT_MS): Promise<RpcMessage> {

package/generated/ai/providers/pi-sdk-node.ts

@@ -25,11 +25,13 @@ import {
 	killWindowsProcessTree,
 	resolveWindowsCommandShim,
 } from "./command-path.ts";
+import { guardChildStreams, writeChildLine } from "./child-io.ts";
 
 // Re-export mapPiEvent from shared (runtime-agnostic)
 export { mapPiEvent } from "./pi-events.ts";
 
 const PROVIDER_NAME = "pi-sdk";
+const PI_PROCESS_LABEL = "Pi process";
 
 // ---------------------------------------------------------------------------
 // JSONL subprocess wrapper (Node.js)
@@ -37,7 +39,8 @@ const PROVIDER_NAME = "pi-sdk";
 
 type EventListener = (event: Record<string, unknown>) => void;
 
-class PiProcessNode {
+/** Exported for the stdio-failure regression tests (#1378). */
+export class PiProcessNode {
 	private proc: ChildProcess | null = null;
 	private listeners: EventListener[] = [];
 	private pendingRequests = new Map<
@@ -62,9 +65,12 @@ class PiProcessNode {
 		let proc: ChildProcess;
 		try {
 			const [file, ...args] = command;
+			// stderr is "ignore", not "pipe": we never read it, and an
+			// un-drained stderr pipe deadlocks the child once its buffer fills
+			// (same reasoning as codex-app-server.ts).
 			proc = spawn(file, args, {
 				cwd,
-				stdio: ["pipe", "pipe", "pipe"],
+				stdio: ["pipe", "pipe", "ignore"],
 			});
 		} catch (err) {
 			const error = err instanceof Error ? err : new Error(String(err));
@@ -73,6 +79,10 @@ class PiProcessNode {
 		}
 
 		this.proc = proc;
+		// Cover every pipe BEFORE the spawn handshake: an `error` event on a
+		// child stream with no listener becomes an uncaughtException and kills
+		// the host agent process, not just this provider (#1378).
+		guardChildStreams(proc, PI_PROCESS_LABEL, (error) => this.failProcess(error));
 		proc.once("exit", () => {
 			this.handleProcessEnd(new Error("Pi process exited unexpectedly"));
 		});
@@ -99,6 +109,24 @@ class PiProcessNode {
 		});
 	}
 
+	/**
+	 * A pipe to the child broke. Resolve it as a provider failure: reject
+	 * everything in flight, tell listeners the process ended, and reap the
+	 * child so it cannot linger with an unusable RPC channel. `alive` flips
+	 * false, so the next query re-spawns a fresh process.
+	 */
+	private failProcess(error: Error): void {
+		const proc = this.proc;
+		this.handleProcessEnd(error);
+		if (proc) {
+			try {
+				if (!killWindowsProcessTree(proc.pid)) proc.kill();
+			} catch {
+				// Already gone.
+			}
+		}
+	}
+
 	private handleProcessEnd(error: Error): void {
 		if (!this.proc && this.pendingRequests.size === 0) return;
 
@@ -153,9 +181,23 @@ class PiProcessNode {
 		}
 	}
 
+	/**
+	 * Send a command without waiting for a response.
+	 *
+	 * A closed or broken stdin is a provider failure, never a throw at the
+	 * caller and never an unhandled stream error: both the synchronous throw
+	 * and the asynchronous `error`/write-callback paths land in failProcess,
+	 * which rejects anything in flight (including the `sendAndWait` request
+	 * this call may be carrying).
+	 */
 	send(command: Record<string, unknown>): void {
-		if (!this.proc?.stdin || this.proc.stdin.destroyed) return;
-		this.proc.stdin.write(`${JSON.stringify(command)}\n`);
+		const error = writeChildLine(
+			this.proc,
+			`${JSON.stringify(command)}\n`,
+			PI_PROCESS_LABEL,
+			(err) => this.failProcess(err),
+		);
+		if (error) this.failProcess(error);
 	}
 
 	sendAndWait(

package/generated/ai/providers/pi-sdk.ts

@@ -58,11 +58,14 @@ class PiProcess {
 				"rpc",
 			];
 		try {
+			// stderr is "ignore", not "pipe": we never read it, and an
+			// un-drained stderr pipe deadlocks the child once its buffer fills
+			// (same reasoning as codex-app-server.ts).
 			this.proc = Bun.spawn(command, {
 				cwd,
 				stdin: "pipe",
 				stdout: "pipe",
-				stderr: "pipe",
+				stderr: "ignore",
 			});
 		} catch (err) {
 			const error = err instanceof Error ? err : new Error(String(err));
@@ -78,6 +81,22 @@ class PiProcess {
 		});
 	}
 
+	/**
+	 * A pipe to the child broke: resolve it as a provider failure and reap the
+	 * child, leaving `alive` false so the next query re-spawns.
+	 */
+	private failProcess(error: Error): void {
+		const proc = this.proc;
+		this.handleProcessEnd(error);
+		if (proc) {
+			try {
+				if (!killWindowsProcessTree(proc.pid)) proc.kill();
+			} catch {
+				// Already gone.
+			}
+		}
+	}
+
 	private handleProcessEnd(error: Error): void {
 		if (!this.proc && this.pendingRequests.size === 0) return;
 
@@ -144,13 +163,42 @@ class PiProcess {
 		}
 	}
 
-	/** Send a command without waiting for a response. */
+	/**
+	 * Send a command without waiting for a response.
+	 *
+	 * The write is guarded for the same reason the Node variant's is (#1378):
+	 * the child can close the pipe between the liveness check and the write,
+	 * and a raw EPIPE escaping here would surface as a synchronous throw at
+	 * the caller (or an unhandled rejection out of flush()) instead of a
+	 * provider failure. Failing the process rejects anything in flight.
+	 */
 	send(command: Record<string, unknown>): void {
-		if (!this.proc?.stdin || typeof this.proc.stdin === "number") return;
+		const stdin = this.proc?.stdin;
+		if (!stdin || typeof stdin === "number") {
+			this.failProcess(new Error("Pi process stdin is closed"));
+			return;
+		}
 		// Bun.spawn stdin is a FileSink with .write(), not a WritableStream
-		const sink = this.proc.stdin as { write(data: string): void; flush(): void };
-		sink.write(`${JSON.stringify(command)}\n`);
-		sink.flush();
+		const sink = stdin as { write(data: string): void; flush(): unknown };
+		try {
+			sink.write(`${JSON.stringify(command)}\n`);
+			const flushed = sink.flush();
+			if (flushed && typeof (flushed as Promise<number>).then === "function") {
+				(flushed as Promise<number>).catch((err: unknown) => {
+					this.failProcess(
+						new Error(
+							`Pi process stdin write failed: ${err instanceof Error ? err.message : String(err)}`,
+						),
+					);
+				});
+			}
+		} catch (err) {
+			this.failProcess(
+				new Error(
+					`Pi process stdin write failed: ${err instanceof Error ? err.message : String(err)}`,
+				),
+			);
+		}
 	}
 
 	/** Send a command and wait for the correlated response. */

package/generated/call-flow-types.ts

@@ -161,7 +161,7 @@ export interface ParsedCallDiffWorkerResult {
   diagnostics: CallFlowDiagnostic[];
 }
 
-const MAX_TREES = 100;
+const MAX_TREES = 2_000;
 const MAX_NODES = 5_000;
 const MAX_TREE_DEPTH = 32;
 const MAX_DIAGNOSTICS = 100;
@@ -218,9 +218,16 @@ export function parseCallDiffWorkerResult(value: unknown): ParsedCallDiffWorkerR
   if (!isRecord(value.result) || !Array.isArray(value.result.trees)) {
     throw new Error("CallDiff worker response is missing its diff trees.");
   }
-  if (value.result.trees.length > MAX_TREES) {
-    throw new Error("CallDiff result exceeded Plannotator's tree limits.");
-  }
+  // A large-but-valid result (many small entry trees — common in Swift, TS,
+  // and other per-function languages) degrades instead of failing: keep the
+  // first MAX_TREES trees and say so in diagnostics (#1351). The caps that
+  // guard against genuinely unbounded worker output (total nodes, depth, raw
+  // length) still throw below.
+  const totalTreeCount = value.result.trees.length;
+  const truncatedTrees = totalTreeCount > MAX_TREES;
+  const boundedTreeCandidates = truncatedTrees
+    ? value.result.trees.slice(0, MAX_TREES)
+    : value.result.trees;
 
   let nodeCount = 0;
   const parseNode = (candidate: unknown, depth: number): CallFlowNode => {
@@ -254,7 +261,7 @@ export function parseCallDiffWorkerResult(value: unknown): ParsedCallDiffWorkerR
   };
 
   const raw = boundedRaw(value.result.ascii);
-  const trees = value.result.trees.map((candidate): CallFlowTree => {
+  const trees = boundedTreeCandidates.map((candidate): CallFlowTree => {
     if (!isRecord(candidate)) throw new Error("CallDiff worker returned an invalid tree.");
     const entry = boundedString(candidate.entry, "tree entry");
     const tree = parseNode(candidate.tree, 0);
@@ -287,6 +294,12 @@ export function parseCallDiffWorkerResult(value: unknown): ParsedCallDiffWorkerR
       });
     }
   }
+  if (truncatedTrees) {
+    diagnostics.push({
+      level: "warning",
+      message: `Showing the first ${MAX_TREES.toLocaleString("en-US")} of ${totalTreeCount.toLocaleString("en-US")} call trees; the rest were truncated to bound the result.`,
+    });
+  }
 
   return {
     version: boundedString(value.version, "version", 100),

package/generated/config.ts

@@ -46,7 +46,8 @@ export type PromptRuntime =
   | "copilot-cli"
   | "pi"
   | "codex"
-  | "gemini-cli";
+  | "gemini-cli"
+  | "oh-my-pi";
 
 interface PromptSectionConfig {
   [key: string]: string | Partial<Record<PromptRuntime, PromptSectionOverrides>> | undefined;

package/generated/jj-core.ts

@@ -9,6 +9,7 @@ import {
   type JjEvoLogEntry,
   JJ_TRUNK_REVSET,
   jjLineBaseRevset,
+  parseRemoteBookmark,
   validateFilePath,
 } from "./review-core.ts";
 
@@ -27,6 +28,31 @@ export interface ReviewJjRuntime {
   ) => Promise<GitCommandResult>;
 }
 
+// `reachable(@, mutable())` is JJ's definition of the stack being worked on.
+// Its root parents are where that line diverged from immutable history.
+//
+// `latest(..., 1)` is what keeps the query single-record. A criss-cross history
+// can leave several fork points, and the parser below reads one record only, so
+// the tie-break belongs in the revset where it is deliberate and testable
+// rather than in a silent "first row wins" slice. It also matters for
+// correctness: bookmark preference (remote before local) is only meaningful
+// within one commit, so a multi-row answer could otherwise pick a remote
+// bookmark from one commit over a local bookmark on a nearer one.
+const JJ_LINE_BASE_REVSET = "latest(fork_point(roots(reachable(@, mutable()))-), 1)";
+
+// `jj git push --change` mints bookmarks under `git.push-bookmark-prefix`
+// (default `push-`). They name one change, not a line of work, so they are
+// never a useful review base. They reach the fork point in practice: a
+// colleague's pushed change bookmark arrives as an untracked remote bookmark,
+// which makes its commit immutable and therefore a candidate base, and the
+// reviewer would be told they are comparing against `push-vmopwunwxopv@origin`.
+const JJ_GENERATED_PUSH_BOOKMARK_PREFIX = "push-";
+
+// `commit_id` renders in full, so an all-zero id is the virtual root commit.
+// A repo with no immutable history forks there, and a 40-zero hash means
+// nothing to a reviewer, so keep the `trunk()` sentinel for that case.
+const JJ_ROOT_COMMIT_ID = /^0+$/;
+
 export async function detectJjWorkspace(
   runtime: ReviewJjRuntime,
   cwd?: string,
@@ -369,13 +395,35 @@ export async function selectDefaultJjCompareTarget(
     "log",
     "--no-graph",
     "-r",
-    JJ_TRUNK_REVSET,
+    JJ_LINE_BASE_REVSET,
     "-T",
-    "json(bookmarks)",
+    'json(bookmarks) ++ "\\t" ++ commit_id ++ "\\n"',
   ], { cwd });
+  // Every unresolvable case falls back to `trunk()`, which is what this
+  // returned before the line-of-work base was inferred at all. The only live
+  // caller is `getJjContext`, which runs on the review startup path with no
+  // handler above it, so throwing here does not report a problem: it aborts
+  // `plannotator review` with a stack trace before the server is built. That
+  // also covers a `jj` too old for `fork_point`/`reachable`, where the revset
+  // itself fails and the previous default is still perfectly serviceable.
   if (result.exitCode !== 0) return JJ_TRUNK_REVSET;
 
-  return parseJjResolvedBookmarks(result.stdout)[0] ?? JJ_TRUNK_REVSET;
+  const [record] = splitJjTemplateRecords(result.stdout);
+  if (!record) return JJ_TRUNK_REVSET;
+
+  const fields = splitJjTemplateFields(record);
+  const bookmark = parseJjResolvedBookmarks(fields?.[0] ?? record)
+    .find((name) => !isGeneratedPushBookmark(name));
+  if (bookmark) return bookmark;
+
+  const commitId = fields?.[1]?.trim();
+  if (commitId && !JJ_ROOT_COMMIT_ID.test(commitId)) return commitId;
+  return JJ_TRUNK_REVSET;
+}
+
+function isGeneratedPushBookmark(target: string): boolean {
+  const name = parseRemoteBookmark(target)?.name ?? target;
+  return name.startsWith(JJ_GENERATED_PUSH_BOOKMARK_PREFIX);
 }
 
 function parseJjResolvedBookmarks(value: string): string[] {

package/generated/prompts.ts

@@ -25,6 +25,7 @@ export const PLAN_TOOL_NAMES: Record<PromptRuntime, string> = {
   pi: "plannotator_submit_plan",
   codex: "ExitPlanMode",
   "gemini-cli": "exit_plan_mode",
+  "oh-my-pi": "ExitPlanMode",
 };
 
 export function getPlanToolName(runtime?: PromptRuntime | null): string {

package/generated/review-core.ts

@@ -315,12 +315,23 @@ export function parseRemoteBookmark(target: string): { name: string; remote: str
   return { name: target.slice(0, at), remote: target.slice(at + 1) };
 }
 
+// A full `commit_id`: 40 hex digits for a SHA-1 repo, 64 for SHA-256. Matching
+// the full length only is deliberate, so an ordinary bookmark whose name
+// happens to be hex (`cafebabe`) is still treated as a bookmark.
+const JJ_FULL_COMMIT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+
 export function jjCompareTargetRevset(target: string): string {
   const remoteBookmark = parseRemoteBookmark(target);
   if (remoteBookmark) {
     return `remote_bookmarks(exact:${quoteJjString(remoteBookmark.name)}, exact:${quoteJjString(remoteBookmark.remote)})`;
   }
 
+  // The resolved line base is a bare commit id whenever its fork point carries
+  // no usable bookmark. It has no separators, so it would otherwise read as a
+  // local bookmark name and build `bookmarks(exact:"<sha>")`, which resolves to
+  // no revisions at all and makes the whole Line of work diff fail.
+  if (JJ_FULL_COMMIT_ID.test(target)) return target;
+
   const localBookmark = parseJjBookmarkName(target);
   return localBookmark ? `bookmarks(exact:${quoteJjString(localBookmark)})` : target;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/pi-extension",
-  "version": "0.27.6",
+  "version": "0.27.7",
   "type": "module",
   "description": "Plannotator Pi extension - interactive plan review with annotations, annotate agent messages, and review code/PRs",
   "author": "backnotprop",
@@ -21,9 +21,13 @@
     "ai-agent",
     "coding-agent"
   ],
+  "//pi": "skills/ is vendored by vendor.sh from apps/skills/core/plannotator and is gitignored, so the shipped copy cannot drift from the single source.",
   "pi": {
     "extensions": [
       "./"
+    ],
+    "skills": [
+      "skills/plannotator/SKILL.md"
     ]
   },
   "files": [
@@ -42,6 +46,7 @@
     "server/",
     "todo-providers/",
     "generated/",
+    "skills/",
     "README.md",
     "plannotator.html",
     "review-editor.html"