fix: simplify session completion notifications

Remove PTY tail parsing from completion notifications and use fixed completion hints instead, so terminal UI chrome no longer leaks into notification content.

Author: pallyoung

packages/web/src/app/providers.lifecycle.test.tsx

@@ -32,8 +32,6 @@ vi.mock("../ws", () => ({
 
 vi.mock("../features/notifications", () => ({
   useSessionNotifications: () => {},
-  appendSessionOutputAtom: null,
-  clearSessionOutputAtom: null,
 }));
 
 function renderProviders(store = createStore()) {

packages/web/src/app/providers.test.tsx

@@ -9,7 +9,6 @@ import {
   workspacesLoadErrorAtom,
   workspacesLoadStateAtom,
 } from "../atoms/workspaces";
-import { SESSION_OUTPUT_TAIL_BYTES, sessionOutputTailAtom } from "../features/notifications/atoms";
 import { supervisorCyclesAtom, supervisorsAtom } from "../features/supervisor/atoms";
 import { terminalMetaAtomFamily } from "../features/terminal-panel/atoms";
 import { fileTreeStaleAtomFamily } from "../features/workspace/atoms";
@@ -114,188 +113,22 @@ describe("routeEventToAtom", () => {
     expect(store.get(fileTreeStaleAtomFamily("ws-1"))).toBe(false);
   });
 
-  it("appends cleaned terminal output text to the matching session tail buffer", () => {
+  it("marks terminal metadata exited on terminal exit events", () => {
     const store = createStore();
-    store.set(sessionsAtom, {
-      "sess-1": {
-        id: "sess-1",
-        workspaceId: "ws-1",
-        terminalId: "term-1",
-        providerId: "claude",
-        state: "running",
-        capability: "full",
-        startedAt: 1,
-        lastActiveAt: 1,
-      },
-    });
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 7,
-        size: 11,
-        bytes: new TextEncoder().encode("hello\n"),
-      },
-      store
-    );
-
-    expect(store.get(sessionOutputTailAtom)).toEqual({
-      "sess-1": "hello\n",
-    });
-  });
-
-  it("strips ANSI sequences split across multiple terminal output events", () => {
-    const store = createStore();
-    store.set(sessionsAtom, {
-      "sess-1": {
-        id: "sess-1",
-        workspaceId: "ws-1",
-        terminalId: "term-1",
-        providerId: "claude",
-        state: "running",
-        capability: "full",
-        startedAt: 1,
-        lastActiveAt: 1,
-      },
-    });
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 7,
-        size: 4,
-        bytes: new TextEncoder().encode("\x1b[32"),
-      },
-      store
-    );
-
-    expect(store.get(sessionOutputTailAtom)).toEqual({});
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 8,
-        size: 11,
-        bytes: new TextEncoder().encode("mhello\x1b[0m\n"),
-      },
-      store
-    );
-
-    expect(store.get(sessionOutputTailAtom)).toEqual({
-      "sess-1": "hello\n",
-    });
-  });
-
-  it("preserves multibyte utf-8 characters split across terminal output events", () => {
-    const store = createStore();
-    store.set(sessionsAtom, {
-      "sess-1": {
-        id: "sess-1",
-        workspaceId: "ws-1",
-        terminalId: "term-1",
-        providerId: "claude",
-        state: "running",
-        capability: "full",
-        startedAt: 1,
-        lastActiveAt: 1,
-      },
-    });
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 7,
-        size: 2,
-        bytes: new Uint8Array([0x41, 0xe2]),
-      },
-      store
-    );
-
-    expect(store.get(sessionOutputTailAtom)).toEqual({
-      "sess-1": "A",
-    });
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 8,
-        size: 3,
-        bytes: new Uint8Array([0x9c, 0x93, 0x42]),
-      },
-      store
-    );
-
-    expect(store.get(sessionOutputTailAtom)).toEqual({
-      "sess-1": "A✓B",
+    store.set(terminalMetaAtomFamily("term-1"), {
+      id: "term-1",
+      workspaceId: "ws-1",
+      kind: "agent",
+      alive: true,
+      title: "Claude",
     });
-  });
 
-  it("does not leak ANSI fragments when the cleaned tail buffer trims from the head at the size cap", () => {
-    const store = createStore();
-    store.set(sessionsAtom, {
-      "sess-1": {
-        id: "sess-1",
-        workspaceId: "ws-1",
-        terminalId: "term-1",
-        providerId: "claude",
-        state: "running",
-        capability: "full",
-        startedAt: 1,
-        lastActiveAt: 1,
-      },
-    });
+    routeEventToAtom("workspace.ws-1.terminal.term-1.exit", { code: 1 }, store);
 
-    store.set(sessionOutputTailAtom, {
-      "sess-1": "x".repeat(SESSION_OUTPUT_TAIL_BYTES - 2),
+    expect(store.get(terminalMetaAtomFamily("term-1"))).toMatchObject({
+      alive: false,
+      exitCode: 1,
     });
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 7,
-        size: 4,
-        bytes: new TextEncoder().encode("\x1b[32"),
-      },
-      store
-    );
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 8,
-        size: 6,
-        bytes: new TextEncoder().encode("mOK\n"),
-      },
-      store
-    );
-
-    const tail = store.get(sessionOutputTailAtom)["sess-1"];
-    expect(tail).toBe("x".repeat(SESSION_OUTPUT_TAIL_BYTES - 3) + "OK\n");
-    expect(tail.startsWith("[32m")).toBe(false);
-  });
-
-  it("ignores terminal output bytes when no matching session exists", () => {
-    const store = createStore();
-
-    routeEventToAtom(
-      "workspace.ws-1.terminal.term-1.output",
-      {
-        transport: "binary",
-        streamId: 7,
-        size: 5,
-        bytes: new TextEncoder().encode("hello"),
-      },
-      store
-    );
-
-    expect(store.get(sessionOutputTailAtom)).toEqual({});
   });
 
   it("removes local session artifacts on session removed lifecycle events", () => {
@@ -321,14 +154,10 @@ describe("routeEventToAtom", () => {
       exitCode: 1,
       title: "Claude",
     });
-    store.set(sessionOutputTailAtom, {
-      "sess-1": "tail output",
-    });
 
     routeEventToAtom("workspace.ws-1.session.sess-1.lifecycle", { event: "removed" }, store);
 
     expect(store.get(sessionsAtom)).toEqual({});
     expect(store.get(terminalMetaAtomFamily("term-1"))).toBeNull();
-    expect(store.get(sessionOutputTailAtom)).toEqual({});
   });
 });

packages/web/src/app/providers.tsx

@@ -34,12 +34,7 @@ import {
 } from "../atoms";
 import { authenticatedAtom } from "../atoms/app-ui";
 import type { DispatchCommand } from "../atoms/connection";
-import {
-  appendSessionOutputAtom,
-  clearSessionOutputAtom,
-  useSessionNotifications,
-} from "../features/notifications";
-import { stripAnsiChunk } from "../features/notifications/format";
+import { useSessionNotifications } from "../features/notifications";
 import { supervisorCyclesAtom, supervisorsAtom } from "../features/supervisor/atoms";
 import { terminalMetaAtomFamily } from "../features/terminal-panel/atoms";
 import {
@@ -48,7 +43,7 @@ import {
   gitBranchListAtomFamily,
   gitStateAtomFamily,
 } from "../features/workspace/atoms";
-import type { ConnectionStatus, EventListener, TerminalBinaryPayload } from "../ws";
+import type { ConnectionStatus, EventListener } from "../ws";
 import { resolveWsUrl, WsClient } from "../ws";
 
 /**
@@ -57,8 +52,6 @@ import { resolveWsUrl, WsClient } from "../ws";
  */
 let globalWsClient: WsClient | null = null;
 let pendingDisconnectTimer: NodeJS.Timeout | null = null;
-const sessionOutputDecoders = new Map<string, TextDecoder>();
-const sessionOutputAnsiCarry = new Map<string, string>();
 
 interface WorkspaceRefreshHint {
   refreshGit: boolean;
@@ -84,8 +77,6 @@ export function resetAppProvidersSingletonsForTests() {
     pendingDisconnectTimer = null;
   }
   globalWsClient = null;
-  sessionOutputDecoders.clear();
-  sessionOutputAnsiCarry.clear();
 }
 
 function mergeRefreshHints(
@@ -144,38 +135,6 @@ function parseWorkspaceRefreshHint(
   };
 }
 
-/**
- * Shared decoder for terminal output chunks. PTY data is a UTF-8 byte stream.
- * Decoding once-per-event is cheap, but keeping the TextDecoder around saves
- * allocations at high stream rates.
- */
-function clearTerminalOutputStreamState(terminalId: string): void {
-  sessionOutputDecoders.delete(terminalId);
-  sessionOutputAnsiCarry.delete(terminalId);
-}
-
-function decodeTerminalOutputBytes(terminalId: string, chunk: Uint8Array): string {
-  let decoder = sessionOutputDecoders.get(terminalId);
-  if (!decoder) {
-    decoder = new TextDecoder("utf-8", { fatal: false });
-    sessionOutputDecoders.set(terminalId, decoder);
-  }
-
-  const decoded = decoder.decode(chunk, { stream: true });
-  if (!decoded) {
-    return "";
-  }
-
-  const { cleaned, carry } = stripAnsiChunk(decoded, sessionOutputAnsiCarry.get(terminalId) ?? "");
-  if (carry) {
-    sessionOutputAnsiCarry.set(terminalId, carry);
-  } else {
-    sessionOutputAnsiCarry.delete(terminalId);
-  }
-
-  return cleaned;
-}
-
 interface AppProvidersProps {
   children: React.ReactNode;
 }
@@ -600,10 +559,8 @@ export function routeEventToAtom(topic: string, payload: unknown, store: Store):
         if (data.event === "removed") {
           const removedSession = store.get(sessionsAtom)[sessionId];
           if (removedSession?.terminalId) {
-            clearTerminalOutputStreamState(removedSession.terminalId);
             store.set(terminalMetaAtomFamily(removedSession.terminalId), null);
           }
-          store.set(clearSessionOutputAtom, sessionId);
           store.set(sessionsAtom, (prev: Record<string, Session>) => {
             if (!(sessionId in prev)) {
               return prev;
@@ -695,7 +652,6 @@ export function routeEventToAtom(topic: string, payload: unknown, store: Store):
       // workspace.{id}.terminal.{terminalId}.created
       if (terminalSubtopic === "created") {
         const data = payload as { id: string; kind: string; title?: string; cwd?: string };
-        clearTerminalOutputStreamState(terminalId);
         const atom = terminalMetaAtomFamily(terminalId);
         store.set(atom, {
           id: data.id,
@@ -708,28 +664,9 @@ export function routeEventToAtom(topic: string, payload: unknown, store: Store):
       }
 
       // workspace.{id}.terminal.{terminalId}.output
+      // Terminal panels consume output directly via xterm.js — no router-level
+      // handling needed.
       if (terminalSubtopic === "output") {
-        // Terminal panels render output directly into xterm.js. We skim a
-        // copy here only when the terminal is bound to a known *agent* session,
-        // so the notification engine can include a tail summary in its body.
-        // Shell terminals (no session) are ignored to keep the buffer small.
-        const data = payload as TerminalBinaryPayload;
-        const bytes = data?.bytes;
-        if (!bytes || !ArrayBuffer.isView(bytes) || bytes.byteLength === 0) return;
-        const sessions = store.get(sessionsAtom);
-        const session = Object.values(sessions).find((s) => s.terminalId === terminalId);
-        if (!session) return;
-
-        const cleaned = decodeTerminalOutputBytes(
-          terminalId,
-          new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-        );
-        if (cleaned) {
-          store.set(appendSessionOutputAtom, {
-            sessionId: session.id,
-            text: cleaned,
-          });
-        }
         return;
       }
 
@@ -745,14 +682,6 @@ export function routeEventToAtom(topic: string, payload: unknown, store: Store):
             alive: false,
           });
         }
-        // Clean up the output tail buffer for the session this terminal belonged
-        // to (if any). Avoids unbounded growth across long-lived browser tabs.
-        const sessions = store.get(sessionsAtom);
-        const session = Object.values(sessions).find((s) => s.terminalId === terminalId);
-        clearTerminalOutputStreamState(terminalId);
-        if (session) {
-          store.set(clearSessionOutputAtom, session.id);
-        }
         return;
       }
     }