@pontia/pi-client-plugin 0.5.1 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pontia/pi-client-plugin",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Pi extension that connects coding-agent sessions to Pontia.",
   "keywords": [
     "pi-package",

package/src/compaction.ts

@@ -0,0 +1,225 @@
+import { randomUUID } from "node:crypto";
+import type {
+  SessionBeforeCompactEvent,
+  SessionCompactEvent,
+  SessionCompactFailedEvent,
+  CompactionResult,
+} from "@earendil-works/pi-coding-agent";
+import type { InternalEvent } from "./events.js";
+import type { SessionContext } from "./session.js";
+import { RpcError } from "./rpc-error.js";
+
+type Trigger = "manual" | "threshold" | "overflow" | "unknown";
+interface Operation {
+  id: string;
+  trigger: Trigger;
+  started?: InternalEvent;
+  terminal?: InternalEvent;
+  acknowledged: Set<string>;
+  reporting: Promise<void>;
+  awaitingNativeResult: boolean;
+  failureKey?: string;
+}
+interface State {
+  report: (event: InternalEvent) => Promise<boolean>;
+  active?: Operation;
+  operations: Map<string, Operation>;
+  signals: WeakMap<AbortSignal, Operation>;
+  failures: WeakSet<object>;
+  completed: Map<string, Operation>;
+}
+
+// Pi reloads extensions in the same process. Keep only control metadata across
+// reload, so a replaced hook or reconnect cannot allocate another operation.
+const stateKey = Symbol.for("pontia.pi.compaction");
+const processState = globalThis as typeof globalThis & { [stateKey]?: Map<string, State> };
+const states = (processState[stateKey] ??= new Map());
+
+export class PiCompaction {
+  private readonly state: State;
+
+  constructor(
+    home: string,
+    private readonly context: SessionContext,
+    report: (event: InternalEvent) => Promise<boolean>,
+  ) {
+    const key = JSON.stringify([
+      home,
+      context.sessionId,
+      context.runtimeId,
+      context.clientSessionKey,
+    ]);
+    let state = states.get(key);
+    if (!state) {
+      state = {
+        report,
+        operations: new Map(),
+        signals: new WeakMap(),
+        failures: new WeakSet(),
+        completed: new Map(),
+      };
+      states.set(key, state);
+    }
+    state.report = report;
+    this.state = state;
+  }
+
+  get running(): boolean {
+    return !!this.state.active && !this.state.active.terminal;
+  }
+
+  async reconnect(): Promise<void> {
+    for (const operation of this.state.operations.values()) {
+      if (operation.started) await this.publish(operation, !operation.awaitingNativeResult);
+    }
+  }
+
+  request(operationId: string, compact: () => void): void {
+    if (this.state.operations.has(operationId)) return;
+    if (this.running) throw new RpcError(-32006, "Pi compaction is already running");
+    const operation = this.create("manual", operationId);
+    operation.awaitingNativeResult = true;
+    try {
+      compact();
+    } catch (error) {
+      this.state.operations.delete(operationId);
+      this.state.active = undefined;
+      throw error;
+    }
+  }
+
+  async before(event: SessionBeforeCompactEvent): Promise<void> {
+    let operation = this.state.signals.get(event.signal);
+    if (!operation) {
+      operation = this.running ? this.state.active! : this.create(trigger(event.reason));
+      this.state.signals.set(event.signal, operation);
+    }
+    await this.publish(operation);
+  }
+
+  async completed(event: SessionCompactEvent): Promise<void> {
+    const entry = event.compactionEntry;
+    const operation = this.state.completed.get(entry.id) ?? this.current(event.reason);
+    this.state.completed.set(entry.id, operation);
+    operation.terminal ??= this.fact("session.compaction_completed", operation, {
+      native_compaction_id: entry.id ?? null,
+      tokens_before: tokens(entry.tokensBefore),
+      // Pi's extension event does not expose a post-compaction token count.
+      tokens_after: null,
+    });
+    // The manual context callback supplies Pi's estimatedTokensAfter result.
+    // Automatic compaction exposes only the extension event, so it stays null.
+    await this.publish(operation, !operation.awaitingNativeResult);
+  }
+
+  async failed(event: SessionCompactFailedEvent, leaf: string | null): Promise<void> {
+    if (this.state.failures.has(event)) return;
+    this.state.failures.add(event);
+    const failureKey = JSON.stringify([
+      event.reason,
+      event.aborted,
+      event.errorMessage ?? null,
+      leaf,
+    ]);
+    const previous = this.state.active;
+    const operation =
+      this.running || previous?.failureKey === failureKey
+        ? previous!
+        : this.create(trigger(event.reason));
+    operation.failureKey = failureKey;
+    operation.terminal ??= this.fact("session.compaction_failed", operation, {
+      aborted: event.aborted,
+      error_message: event.errorMessage ?? null,
+    });
+    operation.awaitingNativeResult = false;
+    await this.publish(operation);
+  }
+
+  // The callback covers native failures occurring before session_before_compact
+  // (for example, a session too small to compact). Hooks remain authoritative
+  // for cancellation and supply richer diagnostics when present.
+  async callbackError(operationId: string, error: Error): Promise<void> {
+    const operation = this.state.operations.get(operationId);
+    if (!operation) return;
+    operation.awaitingNativeResult = false;
+    operation.terminal ??= this.fact("session.compaction_failed", operation, {
+      aborted: false,
+      error_message: error.message,
+    });
+    await this.publish(operation);
+  }
+
+  async callbackComplete(operationId: string, result: CompactionResult): Promise<void> {
+    const operation = this.state.operations.get(operationId);
+    if (!operation) return;
+    operation.awaitingNativeResult = false;
+    operation.terminal ??= this.fact("session.compaction_completed", operation, {
+      native_compaction_id: null,
+      tokens_before: tokens(result.tokensBefore),
+      tokens_after: null,
+    });
+    if (
+      !operation.acknowledged.has(operation.terminal.type) &&
+      operation.terminal.type === "session.compaction_completed"
+    ) {
+      operation.terminal.data.tokens_after = tokens(result.estimatedTokensAfter);
+    }
+    await this.publish(operation);
+  }
+
+  private current(reason: unknown): Operation {
+    return this.running ? this.state.active! : this.create(trigger(reason));
+  }
+
+  private create(reason: Trigger, id = `compact_${randomUUID()}`): Operation {
+    const operation: Operation = {
+      id,
+      trigger: reason,
+      acknowledged: new Set(),
+      reporting: Promise.resolve(),
+      awaitingNativeResult: false,
+    };
+    this.state.operations.set(id, operation);
+    this.state.active = operation;
+    return operation;
+  }
+
+  private fact(
+    type: InternalEvent["type"],
+    operation: Operation,
+    metadata: Record<string, unknown> = {},
+  ): InternalEvent {
+    return {
+      session_id: this.context.sessionId,
+      type,
+      data: { operation_id: operation.id, trigger: operation.trigger, ...metadata },
+    };
+  }
+
+  private publish(operation: Operation, includeTerminal = true): Promise<void> {
+    operation.started ??= this.fact("session.compaction_started", operation);
+    operation.reporting = operation.reporting
+      .catch(() => {})
+      .then(async () => {
+        for (const event of [
+          operation.started!,
+          includeTerminal ? operation.terminal : undefined,
+        ]) {
+          if (!event || operation.acknowledged.has(event.type)) continue;
+          if (!(await this.state.report(event))) return;
+          operation.acknowledged.add(event.type);
+        }
+      });
+    return operation.reporting;
+  }
+}
+
+function trigger(reason: unknown): Trigger {
+  return reason === "manual" || reason === "threshold" || reason === "overflow"
+    ? reason
+    : "unknown";
+}
+
+function tokens(value: unknown): number | null {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}

package/src/control-socket.ts

@@ -1,7 +1,10 @@
+import { RpcError } from "./rpc-error.js";
+export { RpcError } from "./rpc-error.js";
+import { readHistory, type HistoryContext } from "./history.js";
 import { createConnection, type Socket } from "node:net";
 import { isAbsolute, join } from "node:path";
 
-export const CONTROL_VERSION = 7;
+export const CONTROL_VERSION = 8;
 export const MAX_CONTROL_FRAME_BYTES = 64 * 1024;
 // Match the former HTTP event body limit, including the RPC envelope.
 export const MAX_RPC_FRAME_BYTES = 2 * 1024 * 1024 + 1024;
@@ -30,18 +33,14 @@ export interface LifecycleControl {
   interrupt(): void;
   shutdown(): void;
 }
+export interface CompactionControl {
+  compact(operationId: string): void;
+}
 export interface PiConnection {
   request(method: string, params: object): Promise<unknown>;
   registered(identity: ControlIdentity): void;
   close(): Promise<void>;
 }
-export class RpcError extends Error {
-  readonly code: number;
-  constructor(code: number, message: string) {
-    super(message);
-    this.code = code;
-  }
-}
 
 export function piSocketPath(pontiaHome: string): string {
   const path = join(pontiaHome, "state", "pi", "rpc.sock");
@@ -68,6 +67,8 @@ class RpcSocket {
   private onSubmit: (input: ControlInput) => void;
   private models?: ModelControl;
   private lifecycle?: LifecycleControl;
+  private history?: () => HistoryContext;
+  private compaction?: CompactionControl;
   private onReplay?: (inboxMessageId: string) => void;
 
   constructor(
@@ -76,12 +77,16 @@ class RpcSocket {
     models?: ModelControl,
     onReplay?: (inboxMessageId: string) => void,
     lifecycle?: LifecycleControl,
+    history?: () => HistoryContext,
+    compaction?: CompactionControl,
   ) {
     this.socket = socket;
     this.onSubmit = onSubmit;
     this.models = models;
     this.onReplay = onReplay;
     this.lifecycle = lifecycle;
+    this.history = history;
+    this.compaction = compaction;
     socket.on("data", (chunk: Buffer) => this.receive(chunk));
     socket.on("error", (error) => this.fail(error));
     socket.on("close", () =>
@@ -181,10 +186,41 @@ class RpcSocket {
         error(-32602, "Expected named parameters");
         return;
       }
+      if (message.method === "history.read" && this.history) {
+        try {
+          respond({ result: readHistory(this.history(), params) });
+        } catch (failure) {
+          error(
+            failure instanceof RpcError ? failure.code : -32009,
+            failure instanceof Error ? failure.message : String(failure),
+          );
+        }
+        return;
+      }
       if (message.method === "ping") {
         respond({ result: { pong: true } });
         return;
       }
+      if (message.method === "compact" && this.compaction) {
+        if (
+          Object.keys(params).some((key) => key !== "operation_id") ||
+          typeof params.operation_id !== "string" ||
+          !params.operation_id.trim()
+        ) {
+          error(-32602, "compact requires an operation_id");
+          return;
+        }
+        try {
+          this.compaction.compact(params.operation_id);
+          respond({ result: { accepted: true } });
+        } catch (failure) {
+          error(
+            failure instanceof RpcError ? failure.code : -32006,
+            failure instanceof Error ? failure.message : String(failure),
+          );
+        }
+        return;
+      }
       if (this.lifecycle && (message.method === "interrupt" || message.method === "shutdown")) {
         try {
           this.lifecycle[message.method as "interrupt" | "shutdown"]();
@@ -299,6 +335,8 @@ export async function connectPi(
   models?: ModelControl,
   onReplay?: (inboxMessageId: string) => void,
   lifecycle?: LifecycleControl,
+  history?: () => HistoryContext,
+  compaction?: CompactionControl,
 ): Promise<PiConnection> {
   const path = piSocketPath(pontiaHome);
   let identity: ControlIdentity | undefined;
@@ -369,6 +407,8 @@ export async function connectPi(
       reportingOnly ? undefined : models,
       reportingOnly ? undefined : onReplay,
       reportingOnly ? undefined : lifecycle,
+      reportingOnly ? undefined : history,
+      reportingOnly ? undefined : compaction,
     );
     peers.add(peer);
     socket.once("close", () => {

package/src/events.ts

@@ -8,8 +8,10 @@ export type InternalEventType =
   | "session.ready"
   | "session.exited"
   | "session.model_updated"
-  | "session.message_updated"
   | "session.context_usage_updated"
+  | "session.compaction_started"
+  | "session.compaction_completed"
+  | "session.compaction_failed"
   | "turn.started"
   | "turn.output"
   | "turn.completed"
@@ -32,8 +34,6 @@ export interface ContextUsageObservation {
   model: string | null;
 }
 
-export type SessionMessageUpdatedReason = "append" | "update" | "final";
-
 export type PiTopologyEntryKind =
   | "user_message"
   | "assistant_message"
@@ -76,17 +76,6 @@ function turnFact(
   return { session_id: context.sessionId, turn_id: context.turnId, type, data };
 }
 
-export function buildSessionMessageUpdatedEvent(
-  context: TurnContext,
-  reason: SessionMessageUpdatedReason,
-): InternalEvent {
-  return {
-    session_id: context.sessionId,
-    type: "session.message_updated",
-    data: { reason },
-  };
-}
-
 export function buildSessionContextUsageUpdatedEvent(
   context: TurnContext,
   usage: ContextUsagePayload,

package/src/history.ts

@@ -0,0 +1,143 @@
+import { RpcError } from "./rpc-error.js";
+
+const PAGE_BYTES = 1024 * 1024;
+export const MAX_HISTORY_ENTRIES = 100_000;
+export interface HistoryContext {
+  generation: number;
+  sessionManager: {
+    getSessionId(): string;
+    getEntries(): unknown[];
+    getLeafId(): string | null;
+  };
+}
+interface Snapshot {
+  session_id: string;
+  generation: number;
+  entry_count: number;
+  upper_entry_id: string | null;
+  leaf_id: string | null;
+}
+const invalid = (message: string): never => {
+  throw new RpcError(-32602, message);
+};
+const token = (value: unknown): string => Buffer.from(JSON.stringify(value)).toString("base64url");
+function decode(value: unknown): Record<string, unknown> {
+  if (typeof value !== "string" || value.length > 4096)
+    return invalid("Invalid history continuation");
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString());
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || token(parsed) !== value)
+      return invalid("Invalid history continuation");
+    return parsed;
+  } catch {
+    return invalid("Invalid history continuation");
+  }
+}
+const identity = (value: unknown): value is string =>
+  typeof value === "string" && !!value.trim() && value.length <= 512;
+
+/** Reads the current canonical manager; tokens contain identities, never file positions. */
+export function readHistory(context: HistoryContext, params: Record<string, unknown>): object {
+  if (Object.keys(params).some((key) => !["page_size", "snapshot", "continuation"].includes(key)))
+    return invalid("Unknown history parameter");
+  const size = params.page_size === undefined ? 64 : params.page_size;
+  if (!Number.isInteger(size) || (size as number) < 1 || (size as number) > 128)
+    return invalid("Invalid history page size");
+  const manager = context.sessionManager;
+  const sessionId = manager.getSessionId();
+  if (!identity(sessionId)) return invalid("Invalid native Session identity");
+  const entries = manager.getEntries() as Record<string, unknown>[];
+  if (!Array.isArray(entries) || entries.length > MAX_HISTORY_ENTRIES)
+    return invalid("History snapshot exceeds entry limit");
+  let snapshot: Snapshot;
+  if (params.snapshot === undefined) {
+    if (params.continuation !== undefined) return invalid("Continuation requires snapshot");
+    snapshot = {
+      session_id: sessionId,
+      generation: context.generation,
+      entry_count: entries.length,
+      upper_entry_id: entries.length ? (entries[entries.length - 1].id as string) : null,
+      leaf_id: manager.getLeafId(),
+    };
+  } else {
+    const parsed = decode(params.snapshot);
+    if (
+      Object.keys(parsed).sort().join() !==
+        "entry_count,generation,leaf_id,session_id,upper_entry_id" ||
+      !Number.isInteger(parsed.entry_count) ||
+      (parsed.entry_count as number) < 0 ||
+      (parsed.entry_count as number) > MAX_HISTORY_ENTRIES ||
+      parsed.session_id !== sessionId ||
+      parsed.generation !== context.generation ||
+      !(parsed.upper_entry_id === null || identity(parsed.upper_entry_id)) ||
+      !(parsed.leaf_id === null || identity(parsed.leaf_id))
+    )
+      return invalid("History snapshot identity changed");
+    snapshot = parsed as unknown as Snapshot;
+  }
+  const upper =
+    snapshot.upper_entry_id === null
+      ? -1
+      : entries.findIndex((entry) => entry?.id === snapshot.upper_entry_id);
+  if (
+    snapshot.upper_entry_id !== null &&
+    entries.filter((entry) => entry?.id === snapshot.upper_entry_id).length !== 1
+  )
+    return invalid("Duplicate history upper identity");
+  if (snapshot.upper_entry_id !== null && upper < 0) return invalid("Invalid history upper bound");
+  if (upper + 1 !== snapshot.entry_count) return invalid("History snapshot entry count changed");
+  const ids = new Set<string>();
+  for (let index = 0; index <= upper; index++) {
+    const entry = entries[index];
+    if (
+      !entry ||
+      !identity(entry.id) ||
+      ids.has(entry.id) ||
+      !identity(entry.type) ||
+      !identity(entry.timestamp) ||
+      !(entry.parentId === null || identity(entry.parentId)) ||
+      (entry.parentId !== null && !ids.has(entry.parentId as string))
+    )
+      return invalid("Invalid history entry identity or parent");
+    ids.add(entry.id);
+  }
+  if (snapshot.leaf_id !== null && !ids.has(snapshot.leaf_id))
+    return invalid("History leaf is outside snapshot");
+  const snapshotToken = token(snapshot);
+  let start = 0;
+  if (params.continuation !== undefined) {
+    const continuation = decode(params.continuation);
+    if (
+      Object.keys(continuation).sort().join() !== "after,snapshot" ||
+      continuation.snapshot !== snapshotToken ||
+      !identity(continuation.after)
+    )
+      return invalid("Invalid history continuation");
+    const after = entries.findIndex((entry) => entry?.id === continuation.after);
+    if (after < 0 || after >= upper) return invalid("History continuation outside snapshot");
+    start = after + 1;
+  } else if (params.snapshot !== undefined) return invalid("Snapshot requires continuation");
+  const page: unknown[] = [];
+  let bytes = 0;
+  for (let index = start; index <= upper && page.length < (size as number); index++) {
+    const entry = entries[index];
+    const encoded = JSON.stringify(entry);
+    const length = Buffer.byteLength(encoded);
+    if (length > PAGE_BYTES - 8192) return invalid("History entry exceeds response budget");
+    if (bytes + length > PAGE_BYTES - 8192) break;
+    page.push(entry);
+    bytes += length + 1;
+  }
+  const end = start + page.length;
+  const continuation =
+    end <= upper ? token({ snapshot: snapshotToken, after: entries[end - 1].id }) : null;
+  return {
+    session_id: sessionId,
+    snapshot: snapshotToken,
+    entry_count: snapshot.entry_count,
+    upper_entry_id: snapshot.upper_entry_id,
+    leaf_id: snapshot.leaf_id,
+    entries: page,
+    continuation,
+  };
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { HistoryContext } from "./history.js";
+import { PiCompaction } from "./compaction.js";
 import { connectPi, RpcError, type PiConnection, type ControlInput } from "./control-socket.js";
 import { defaultHookLogFile, type EnvLike, type TurnContext } from "./context.js";
 import { appendDiagnostic, type DiagnosticEntry } from "./diagnostics.js";
@@ -7,7 +9,6 @@ import { pontiaHomeFromEnv } from "./discovery.js";
 import {
   buildSessionContextUsageUpdatedEvent,
   buildSessionExitedEvent,
-  buildSessionMessageUpdatedEvent,
   buildSessionReadyEvent,
   buildTurnCompletedEvent,
   buildTurnFailedEvent,
@@ -18,7 +19,6 @@ import {
   type InternalEvent,
   type PiTopologyContext,
   type PiTopologyEntryKind,
-  type SessionMessageUpdatedReason,
 } from "./events.js";
 import { asRecord, optionalString } from "./values.js";
 import {
@@ -37,7 +37,6 @@ import {
   assistantDeltaFromEvent,
   assistantTextFromMessage,
   errorMessageFromAgentEnd,
-  isTranscriptBoundaryMessageUpdate,
   lastAssistantTextFromMessages,
 } from "./pi-message.js";
 import { loadProfileSystemPrompt } from "./profile.js";
@@ -189,6 +188,13 @@ export function createPontiaPiExtension(
   let controlGeneration = 0;
   let piContext: ExtensionContext | undefined;
   let changingModel = false;
+  const compaction = () => {
+    const context = boundSessionContext;
+    if (!context || reportingDisabled || !readyReported) return undefined;
+    return new PiCompaction(currentPontiaHome(), context, async (event) =>
+      reportAccepted(await makeReporter(currentHookLogFile()).report(context, event)),
+    );
+  };
   const directInput = new AsyncLocalStorage<{
     submission: ControlInput;
     sessionContext: SessionContext;
@@ -319,6 +325,7 @@ export function createPontiaPiExtension(
           if (generation !== controlGeneration)
             throw new Error("Pi session changed during reconnect");
           await reportModel();
+          await compaction()?.reconnect();
         },
       },
       (inboxMessageId) => {
@@ -340,6 +347,33 @@ export function createPontiaPiExtension(
           ctx.shutdown();
         },
       },
+      () => {
+        lifecycleContext();
+        const manager = piContext!.sessionManager;
+        if (manager.getSessionId() !== boundSessionContext?.clientSessionKey)
+          throw new Error("Pi history native Session identity changed");
+        return { generation, sessionManager: manager } satisfies HistoryContext;
+      },
+      {
+        compact(operationId) {
+          const ctx = lifecycleContext();
+          if (ctx.sessionManager.getSessionId() !== boundSessionContext?.clientSessionKey)
+            throw new RpcError(-32006, "Pi compaction native Session identity changed");
+          const observation = compaction()!;
+          if (!ctx.isIdle() || ctx.hasPendingMessages() || queuedControlInput || changingModel)
+            throw new RpcError(-32006, "Pi is busy; compaction was not requested");
+          observation.request(operationId, () =>
+            ctx.compact({
+              onComplete: (result) => {
+                void observation.callbackComplete(operationId, result).catch(controlError);
+              },
+              onError: (error) => {
+                void observation.callbackError(operationId, error).catch(controlError);
+              },
+            }),
+          );
+        },
+      },
     );
     if (generation !== controlGeneration) {
       await socket.close();
@@ -475,21 +509,6 @@ export function createPontiaPiExtension(
     },
   });
 
-  async function scheduleMessageRefresh(reason: SessionMessageUpdatedReason): Promise<void> {
-    if (!activeTurn || activeTurn.ended) return;
-    await activeTurn.reporter.report(
-      activeTurn.context,
-      buildSessionMessageUpdatedEvent(activeTurn.context, reason),
-    );
-  }
-
-  async function reportFinalMessageRefresh(state: ActiveTurnState): Promise<void> {
-    await state.reporter.report(
-      state.context,
-      buildSessionMessageUpdatedEvent(state.context, "final"),
-    );
-  }
-
   async function reportContextUsageFromHookEvent(event: unknown, ctx?: unknown): Promise<void> {
     if (!activeTurn || activeTurn.ended) return;
     const observation = contextUsageFromPiHook(event, ctx);
@@ -529,6 +548,18 @@ export function createPontiaPiExtension(
     await reportModel().catch(controlError);
   });
 
+  pi.on("session_before_compact", async (event) => {
+    await compaction()?.before(event).catch(controlError);
+  });
+  pi.on("session_compact", async (event) => {
+    await compaction()?.completed(event).catch(controlError);
+  });
+  pi.on("session_compact_failed", async (event, ctx) => {
+    await compaction()
+      ?.failed(event, leafIdFromHookContext(ctx ?? piContext))
+      .catch(controlError);
+  });
+
   pi.on("session_start", async (event, ctx) => {
     if (reportingDisabled) return;
     const reason = (event as unknown as Record<string, unknown> | undefined)?.reason;
@@ -668,6 +699,7 @@ export function createPontiaPiExtension(
         await makeReporter(logFile).report(context, buildSessionReadyEvent(context)),
       );
       await reportModel().catch(controlError);
+      await compaction()?.reconnect().catch(controlError);
     } catch (error) {
       await closeControlSocket();
       const logFile = currentHookLogFile();
@@ -836,16 +868,6 @@ export function createPontiaPiExtension(
     } else if (delta) {
       activeTurn.output += delta;
     }
-
-    if (isTranscriptBoundaryMessageUpdate(event)) await scheduleMessageRefresh("update");
-  });
-
-  pi.on("tool_execution_start", async (event) => {
-    if (!event.parentToolCallId) await scheduleMessageRefresh("update");
-  });
-
-  pi.on("tool_execution_end", async (event) => {
-    if (!event.parentToolCallId) await scheduleMessageRefresh("update");
   });
 
   pi.on("message_end", async (event, ctx) => {
@@ -855,7 +877,6 @@ export function createPontiaPiExtension(
       (event as unknown as Record<string, unknown> | undefined)?.message,
     );
     if (fullText) activeTurn.output = fullText;
-    await scheduleMessageRefresh("append");
   });
 
   pi.on("agent_settled", (_event, ctx) => {
@@ -878,7 +899,6 @@ export function createPontiaPiExtension(
           state.context,
           buildTurnInterruptedEvent(state.context, terminalLeafId),
         );
-        await reportFinalMessageRefresh(state);
         return;
       }
 
@@ -888,7 +908,6 @@ export function createPontiaPiExtension(
           state.context,
           buildTurnFailedEvent(state.context, failureMessage, terminalLeafId),
         );
-        await reportFinalMessageRefresh(state);
         return;
       }
 
@@ -912,7 +931,6 @@ export function createPontiaPiExtension(
         state.context,
         buildTurnCompletedEvent(state.context, terminalLeafId),
       );
-      await reportFinalMessageRefresh(state);
     } finally {
       await state.liveOutput.close();
     }

package/src/pi-message.ts

@@ -36,23 +36,6 @@ export function assistantDeltaFromEvent(event: unknown): string | undefined {
   return undefined;
 }
 
-const transcriptBoundaryStreamEventTypes = new Set([
-  "thinking_start",
-  "thinking_end",
-  "text_start",
-  "text_end",
-  "toolcall_start",
-  "toolcall_end",
-]);
-
-export function isTranscriptBoundaryMessageUpdate(event: unknown): boolean {
-  if (!event || typeof event !== "object") return false;
-  const streamEvent = (event as Record<string, unknown>).assistantMessageEvent;
-  if (!streamEvent || typeof streamEvent !== "object") return false;
-  const type = (streamEvent as Record<string, unknown>).type;
-  return typeof type === "string" && transcriptBoundaryStreamEventTypes.has(type);
-}
-
 interface PiAgentEndEventLike {
   messages: unknown[];
 }

package/src/rpc-error.ts

@@ -0,0 +1,7 @@
+export class RpcError extends Error {
+  readonly code: number;
+  constructor(code: number, message: string) {
+    super(message);
+    this.code = code;
+  }
+}