@hienlh/ppm 0.20.5 → 0.20.6

package/src/services/chat.service.ts

@@ -1,4 +1,8 @@
 import { providerRegistry } from "../providers/registry.ts";
+import { configService } from "./config.service.ts";
+import { createHash } from "node:crypto";
+import { buildSharedProviderContext } from "./provider-shared-context.ts";
+import { stripSharedContext, withSharedContext } from "../shared/provider-context.ts";
 import type {
   Session,
   SessionConfig,
@@ -9,6 +13,20 @@ import type {
 } from "../providers/provider.interface.ts";
 
 class ChatService {
+  // Delivery hints only: a restart/eviction safely sends a fresh snapshot.
+  private sharedSnapshots = new Map<string, string>();
+
+  private rememberSharedContext(providerId: string, sessionId: string, context?: string): void {
+    if (!context) return;
+    const key = `${providerId}:${sessionId}`;
+    this.sharedSnapshots.delete(key);
+    this.sharedSnapshots.set(key, createHash("sha256").update(context).digest("hex"));
+    if (this.sharedSnapshots.size > 512) this.sharedSnapshots.delete(this.sharedSnapshots.keys().next().value!);
+  }
+
+  invalidateSharedContext(providerId: string, sessionId: string): void {
+    this.sharedSnapshots.delete(`${providerId}:${sessionId}`);
+  }
   async createSession(
     providerId?: string,
     config: SessionConfig = {},
@@ -32,6 +50,7 @@ class ChatService {
   ): Promise<Session> {
     const provider = providerRegistry.get(providerId);
     if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    this.invalidateSharedContext(providerId, sessionId);
     return provider.resumeSession(sessionId);
   }
 
@@ -68,6 +87,7 @@ class ChatService {
   ): Promise<void> {
     const provider = providerRegistry.get(providerId);
     if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    this.invalidateSharedContext(providerId, sessionId);
     return provider.deleteSession(sessionId);
   }
 
@@ -82,7 +102,77 @@ class ChatService {
       yield { type: "error", message: `Provider "${providerId}" not found` };
       return;
     }
-    yield* provider.sendMessage(sessionId, message, opts);
+    const prepared = await this.prepareSendOptions(providerId, sessionId, message, opts);
+    this.rememberSharedContext(providerId, sessionId, prepared.sharedContext);
+    let finished = false;
+    let activeSessionId = sessionId;
+    try {
+      for await (const event of provider.sendMessage(sessionId,
+        provider.supportsSharedContext ? message : withSharedContext(message, prepared.sharedContext),
+        { ...prepared, sharedContext: provider.supportsSharedContext ? prepared.sharedContext : undefined })) {
+        if (event.type === "error" || (event.type === "done" && event.resultSubtype?.startsWith("error")) || (event.type === "system" && event.subtype === "compact_done")) {
+          this.invalidateSharedContext(providerId, activeSessionId);
+        }
+        const migratedId = event.type === "session_migrated" ? event.newSessionId : event.type === "done" ? event.sessionId : undefined;
+        if (migratedId && migratedId !== activeSessionId) {
+          const snapshot = this.sharedSnapshots.get(`${providerId}:${activeSessionId}`);
+          if (snapshot) {
+            this.sharedSnapshots.set(`${providerId}:${migratedId}`, snapshot);
+            this.invalidateSharedContext(providerId, activeSessionId);
+          }
+          activeSessionId = migratedId;
+        }
+        yield event;
+      }
+      finished = true;
+    } finally {
+      if (!finished) this.invalidateSharedContext(providerId, activeSessionId);
+    }
+  }
+
+  /** Prepare context for both a new stream and a live stream's follow-up turn. */
+  async prepareSendOptions(
+    providerId: string,
+    sessionId: string,
+    message: string,
+    opts?: SendMessageOpts,
+  ): Promise<SendMessageOpts> {
+    if (!providerRegistry.get(providerId)) throw new Error(`Provider "${providerId}" not found`);
+    let sharedContext: string | undefined;
+    if (configService.get("ai").share_provider_context === false || /^\s*\/(compact|clear|new)(\s|$)/i.test(message)) {
+      this.invalidateSharedContext(providerId, sessionId);
+    }
+    // Slash commands belong to the runtime parser. A context prefix would turn
+    // /compact (or a provider skill) into an ordinary prompt.
+    if (configService.get("ai").share_provider_context !== false && !message.trimStart().startsWith("/")) {
+      const { getSessionProjectPath } = await import("./db.service.ts");
+      const projectPath = this.getSession(sessionId)?.projectPath ?? getSessionProjectPath(sessionId);
+      if (projectPath) {
+        const providers = providerRegistry.listAll().flatMap(({ id }) => {
+          const item = providerRegistry.get(id);
+          return item ? [item] : [];
+        });
+        sharedContext = await buildSharedProviderContext(projectPath, providers, { recipientProviderId: providerId });
+        const hash = createHash("sha256").update(sharedContext).digest("hex");
+        if (this.sharedSnapshots.get(`${providerId}:${sessionId}`) === hash) sharedContext = undefined;
+      }
+    }
+    return { ...opts, sharedContext };
+  }
+
+  /** Push a live follow-up through the same context policy as sendMessage. */
+  async pushMessage(providerId: string, sessionId: string, message: string, opts?: SendMessageOpts): Promise<void> {
+    const provider = providerRegistry.get(providerId);
+    if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    const streaming = provider as typeof provider & {
+      pushMessage?: (id: string, content: string, options: SendMessageOpts) => void;
+    };
+    if (!streaming.pushMessage) return;
+    const prepared = await this.prepareSendOptions(providerId, sessionId, message, opts);
+    streaming.pushMessage(sessionId,
+      provider.supportsSharedContext ? message : withSharedContext(message, prepared.sharedContext),
+      { ...prepared, sharedContext: provider.supportsSharedContext ? prepared.sharedContext : undefined });
+    this.rememberSharedContext(providerId, sessionId, prepared.sharedContext);
   }
 
   /** Look up a session across all providers (for WS handler) */
@@ -106,7 +196,10 @@ class ChatService {
   async getMessages(providerId: string, sessionId: string): Promise<ChatMessage[]> {
     const provider = providerRegistry.get(providerId);
     if (!provider) return [];
-    return await provider.getMessages?.(sessionId) ?? [];
+    const messages = await provider.getMessages?.(sessionId) ?? [];
+    return messages.map((message) => message.role === "user"
+      ? { ...message, content: stripSharedContext(message.content) }
+      : message);
   }
 }
 

package/src/services/codex-native-memory.ts

@@ -0,0 +1,66 @@
+import { Database } from "bun:sqlite";
+import { readdirSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const MAX_MEMORIES = 24;
+const MAX_CHARS = 24_000;
+
+function latestDatabase(home: string, name: string): string | undefined {
+  try {
+    const candidates = readdirSync(home).filter((file) => new RegExp(`^${name}_\\d+\\.sqlite$`).test(file));
+    candidates.sort((a, b) => Number(b.match(/_(\d+)/)?.[1]) - Number(a.match(/_(\d+)/)?.[1]));
+    return candidates[0] ? join(home, candidates[0]) : undefined;
+  } catch { return undefined; }
+}
+
+/** Read native distilled memories only for threads belonging to this exact project. */
+export function readCodexNativeMemory(projectPath: string, codexHomes: string[]): Array<{ path: string; content: string }> {
+  const result: Array<{ path: string; content: string }> = [];
+  const windows = process.platform === "win32";
+  let canonicalProject = resolve(projectPath);
+  try { canonicalProject = realpathSync(canonicalProject); } catch { /* A deleted project can still have native memory. */ }
+  const project = canonicalProject.replaceAll("\\", "/").replace(/\/+$/, "");
+  let remaining = MAX_CHARS;
+  const seen = new Set<string>();
+  for (const home of new Set(codexHomes)) {
+    if (!remaining || result.length >= MAX_MEMORIES) break;
+    const statePath = latestDatabase(home, "state");
+    if (!statePath) continue;
+    // Older native releases stored stage1_outputs in the state database itself.
+    const memoryPath = latestDatabase(home, "memories") ?? statePath;
+    let state: Database | undefined;
+    let memories: Database | undefined;
+    try {
+      state = new Database(statePath, { readonly: true });
+      const columns = state.query("PRAGMA table_info(threads)").all() as Array<{ name: string }>;
+      const cwd = "rtrim(replace(cwd, char(92), '/'), '/')";
+      const enabled = columns.some((column) => column.name === "memory_mode") ? " AND memory_mode != 'disabled'" : "";
+      const recent = columns.some((column) => column.name === "updated_at") ? " ORDER BY updated_at DESC" : "";
+      const threads = state.query(`SELECT id FROM threads WHERE ${windows ? `lower(${cwd})` : cwd} = ?${enabled}${recent} LIMIT 256`)
+        .all(windows ? project.toLowerCase() : project) as Array<{ id: string }>;
+      if (!threads.length) continue;
+      memories = new Database(memoryPath, { readonly: true });
+      const placeholders = threads.map(() => "?").join(",");
+      const rows = memories.query(`SELECT thread_id, substr(raw_memory, 1, 12000) AS raw_memory, length(raw_memory) AS full_length FROM stage1_outputs WHERE thread_id IN (${placeholders}) ORDER BY generated_at DESC LIMIT ?`)
+        .all(...threads.map((thread) => thread.id), MAX_MEMORIES) as Array<{ thread_id: string; raw_memory: string; full_length: number }>;
+      for (const row of rows) {
+        const raw = row.raw_memory?.trim();
+        if (!raw || raw.includes("\0") || seen.has(raw) || remaining < 200) continue;
+        const path = `${memoryPath}#stage1_outputs/${row.thread_id}`;
+        const excerpt = raw.slice(0, Math.max(0, remaining - 180));
+        const truncated = row.full_length > excerpt.length;
+        const content = excerpt + (truncated ? "\n[Excerpt truncated. Read the raw_memory column of this source database row for the remaining native memory.]" : "");
+        seen.add(raw);
+        result.push({ path, content });
+        remaining -= content.length;
+        if (result.length >= MAX_MEMORIES) break;
+      }
+    } catch {
+      // Missing, locked, or newer incompatible native schemas must not block chat.
+    } finally {
+      memories?.close();
+      state?.close();
+    }
+  }
+  return result;
+}

package/src/services/edge-forwarder.ts

@@ -1,191 +1,191 @@
-/**
- * Edge forwarder — owns the public port and pipes raw TCP to the server's
- * current loopback port.
- *
- * ─── CRITICAL INVARIANT: THIS PROCESS MUST NEVER SPAWN A CHILD ───
- *
- * On Windows a child spawned with fd stdio inherits every inheritable handle,
- * including a listening socket. When such a descendant is orphaned it keeps the
- * socket open, so the port stays in LISTEN under a dead PID and can never be
- * rebound — a "zombie port". The server hits this constantly because it spawns
- * chat/tool/MCP subprocesses; those inherit its listener and wedge its port.
- *
- * The edge exists precisely because it spawns nothing, so its socket cannot be
- * inherited and its port cannot zombie. cloudflared can therefore stay pinned
- * to it forever and the public URL stops rotating. Adding any child-process
- * call to this file reintroduces the exact bug the edge was built to remove.
- *
- * Raw TCP, never HTTP: WebSocket upgrades and SSE streams pass through
- * untouched, and forwarded requests keep the headers cloudflared set.
- */
-import net from "node:net";
-import { resolveTargetPort, _resetTargetCache } from "./edge-target-resolver.ts";
-
-/** Delay between attempts while waiting for the server to come back. */
-const CONNECT_RETRY_MS = 250;
-/**
- * How long a client connection waits for a reachable server before giving up.
- * During an upgrade the server is briefly absent; refusing instantly would
- * surface as a broken page rather than a slow one.
- */
-const CONNECT_WINDOW_MS = 5000;
-
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-/** Resolve once the socket is connected; reject on the first connect error. */
-function connectUpstream(port: number): Promise<net.Socket> {
-  return new Promise((resolvePromise, reject) => {
-    const upstream = net.connect({
-      port,
-      host: "127.0.0.1", // never taken from status.json — loopback only
-      allowHalfOpen: true,
-    });
-    const onError = (err: Error) => {
-      upstream.destroy();
-      reject(err);
-    };
-    upstream.once("error", onError);
-    upstream.once("connect", () => {
-      upstream.removeListener("error", onError);
-      resolvePromise(upstream);
-    });
-  });
-}
-
-/**
- * Largest amount of client data held while waiting for the server. Bounds the
- * memory a slow upload can pin during an upgrade window.
- */
-const MAX_PENDING_BYTES = 8 * 1024 * 1024;
-
-/**
- * Pipe one client connection to the server.
- *
- * Resolving the upstream is async, so the first bytes usually arrive before
- * there is anywhere to send them. They must be captured by a `data` listener
- * attached synchronously on this very tick and replayed once the upstream
- * exists.
- *
- * `socket.pause()` is NOT a substitute — verified against Bun 1.3.13: bytes
- * that arrive while paused are lost, and a later `pipe()`/`resume()` does not
- * bring them back. A socket with no `data` listener drops them outright too.
- * Both variants silently swallowed the first request in testing.
- */
-async function handleConnection(
-  client: net.Socket,
-  connectWindowMs: number,
-): Promise<void> {
-  const pending: Buffer[] = [];
-  let pendingBytes = 0;
-  let clientEnded = false;
-  const onEarlyData = (chunk: Buffer) => {
-    pendingBytes += chunk.length;
-    if (pendingBytes > MAX_PENDING_BYTES) {
-      client.destroy();
-      return;
-    }
-    pending.push(chunk);
-  };
-  client.on("data", onEarlyData);
-  client.once("end", () => { clientEnded = true; });
-
-  let upstream: net.Socket | null = null;
-  let clientGone = false;
-
-  // A socket error with no listener is an unhandled 'error' event, which would
-  // take the whole edge process — and the public port — down with it.
-  const teardown = () => {
-    upstream?.destroy();
-    client.destroy();
-  };
-  client.on("error", teardown);
-  client.once("close", () => { clientGone = true; });
-
-  const deadline = Date.now() + connectWindowMs;
-  while (!clientGone && Date.now() < deadline) {
-    const port = resolveTargetPort();
-    if (port !== null) {
-      try {
-        upstream = await connectUpstream(port);
-        break;
-      } catch {
-        // Server not up yet (or moved mid-restart) — re-resolve and retry.
-        _resetTargetCache();
-      }
-    }
-    await sleep(CONNECT_RETRY_MS);
-  }
-
-  if (clientGone) return;
-  if (!upstream) {
-    client.destroy();
-    return;
-  }
-
-  upstream.on("error", teardown);
-
-  // Replay what arrived during the connect, then hand both directions to the
-  // stream machinery. Removing the listener and piping happen in the same tick,
-  // so no chunk can slip through the gap.
-  client.off("data", onEarlyData);
-  for (const chunk of pending) upstream.write(chunk);
-  pending.length = 0;
-
-  client.pipe(upstream);
-  upstream.pipe(client);
-
-  // The client may have half-closed while we were still connecting.
-  if (clientEnded) upstream.end();
-}
-
-export interface EdgeForwarderOptions {
-  publicPort: number;
-  host?: string;
-  /** How long a client waits for a reachable server. Defaults to 5s. */
-  connectWindowMs?: number;
-}
-
-/**
- * Bind the public port and start forwarding. Resolves once listening so the
- * caller can fail fast when the port is unavailable.
- */
-export function startEdgeForwarder(
-  opts: EdgeForwarderOptions,
-): Promise<net.Server> {
-  const host = opts.host ?? "0.0.0.0";
-  const connectWindowMs = opts.connectWindowMs ?? CONNECT_WINDOW_MS;
-  return new Promise((resolvePromise, reject) => {
-    // allowHalfOpen keeps the other direction alive when one side sends FIN —
-    // long-lived chat WS and SSE streams depend on it.
-    const server = net.createServer({ allowHalfOpen: true }, (client) => {
-      void handleConnection(client, connectWindowMs);
-    });
-    server.once("error", reject);
-    server.listen(opts.publicPort, host, () => {
-      server.removeListener("error", reject);
-      resolvePromise(server);
-    });
-  });
-}
-
-// ─── Process entry ─────────────────────────────────────────────────────
-// Mirrors the `__serve__` guard in src/server/index.ts: the supervisor
-// re-invokes the binary as `<bin> __edge__ <publicPort> <host>`.
-if (process.argv.includes("__edge__")) {
-  const idx = process.argv.indexOf("__edge__");
-  const publicPort = parseInt(process.argv[idx + 1] ?? "", 10);
-  const host = process.argv[idx + 2] ?? "0.0.0.0";
-
-  if (!Number.isInteger(publicPort) || publicPort <= 0 || publicPort > 65535) {
-    process.stderr.write(`[edge] Invalid public port: ${process.argv[idx + 1]}\n`);
-    process.exit(2);
-  }
-
-  try {
-    await startEdgeForwarder({ publicPort, host });
-    process.stderr.write(`[edge] Listening on ${host}:${publicPort}\n`);
-  } catch (err) {
-    process.stderr.write(`[edge] Failed to bind ${host}:${publicPort}: ${err}\n`);
-    process.exit(1);
-  }
-}
+/**
+ * Edge forwarder — owns the public port and pipes raw TCP to the server's
+ * current loopback port.
+ *
+ * ─── CRITICAL INVARIANT: THIS PROCESS MUST NEVER SPAWN A CHILD ───
+ *
+ * On Windows a child spawned with fd stdio inherits every inheritable handle,
+ * including a listening socket. When such a descendant is orphaned it keeps the
+ * socket open, so the port stays in LISTEN under a dead PID and can never be
+ * rebound — a "zombie port". The server hits this constantly because it spawns
+ * chat/tool/MCP subprocesses; those inherit its listener and wedge its port.
+ *
+ * The edge exists precisely because it spawns nothing, so its socket cannot be
+ * inherited and its port cannot zombie. cloudflared can therefore stay pinned
+ * to it forever and the public URL stops rotating. Adding any child-process
+ * call to this file reintroduces the exact bug the edge was built to remove.
+ *
+ * Raw TCP, never HTTP: WebSocket upgrades and SSE streams pass through
+ * untouched, and forwarded requests keep the headers cloudflared set.
+ */
+import net from "node:net";
+import { resolveTargetPort, _resetTargetCache } from "./edge-target-resolver.ts";
+
+/** Delay between attempts while waiting for the server to come back. */
+const CONNECT_RETRY_MS = 250;
+/**
+ * How long a client connection waits for a reachable server before giving up.
+ * During an upgrade the server is briefly absent; refusing instantly would
+ * surface as a broken page rather than a slow one.
+ */
+const CONNECT_WINDOW_MS = 5000;
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+/** Resolve once the socket is connected; reject on the first connect error. */
+function connectUpstream(port: number): Promise<net.Socket> {
+  return new Promise((resolvePromise, reject) => {
+    const upstream = net.connect({
+      port,
+      host: "127.0.0.1", // never taken from status.json — loopback only
+      allowHalfOpen: true,
+    });
+    const onError = (err: Error) => {
+      upstream.destroy();
+      reject(err);
+    };
+    upstream.once("error", onError);
+    upstream.once("connect", () => {
+      upstream.removeListener("error", onError);
+      resolvePromise(upstream);
+    });
+  });
+}
+
+/**
+ * Largest amount of client data held while waiting for the server. Bounds the
+ * memory a slow upload can pin during an upgrade window.
+ */
+const MAX_PENDING_BYTES = 8 * 1024 * 1024;
+
+/**
+ * Pipe one client connection to the server.
+ *
+ * Resolving the upstream is async, so the first bytes usually arrive before
+ * there is anywhere to send them. They must be captured by a `data` listener
+ * attached synchronously on this very tick and replayed once the upstream
+ * exists.
+ *
+ * `socket.pause()` is NOT a substitute — verified against Bun 1.3.13: bytes
+ * that arrive while paused are lost, and a later `pipe()`/`resume()` does not
+ * bring them back. A socket with no `data` listener drops them outright too.
+ * Both variants silently swallowed the first request in testing.
+ */
+async function handleConnection(
+  client: net.Socket,
+  connectWindowMs: number,
+): Promise<void> {
+  const pending: Buffer[] = [];
+  let pendingBytes = 0;
+  let clientEnded = false;
+  const onEarlyData = (chunk: Buffer) => {
+    pendingBytes += chunk.length;
+    if (pendingBytes > MAX_PENDING_BYTES) {
+      client.destroy();
+      return;
+    }
+    pending.push(chunk);
+  };
+  client.on("data", onEarlyData);
+  client.once("end", () => { clientEnded = true; });
+
+  let upstream: net.Socket | null = null;
+  let clientGone = false;
+
+  // A socket error with no listener is an unhandled 'error' event, which would
+  // take the whole edge process — and the public port — down with it.
+  const teardown = () => {
+    upstream?.destroy();
+    client.destroy();
+  };
+  client.on("error", teardown);
+  client.once("close", () => { clientGone = true; });
+
+  const deadline = Date.now() + connectWindowMs;
+  while (!clientGone && Date.now() < deadline) {
+    const port = resolveTargetPort();
+    if (port !== null) {
+      try {
+        upstream = await connectUpstream(port);
+        break;
+      } catch {
+        // Server not up yet (or moved mid-restart) — re-resolve and retry.
+        _resetTargetCache();
+      }
+    }
+    await sleep(CONNECT_RETRY_MS);
+  }
+
+  if (clientGone) return;
+  if (!upstream) {
+    client.destroy();
+    return;
+  }
+
+  upstream.on("error", teardown);
+
+  // Replay what arrived during the connect, then hand both directions to the
+  // stream machinery. Removing the listener and piping happen in the same tick,
+  // so no chunk can slip through the gap.
+  client.off("data", onEarlyData);
+  for (const chunk of pending) upstream.write(chunk);
+  pending.length = 0;
+
+  client.pipe(upstream);
+  upstream.pipe(client);
+
+  // The client may have half-closed while we were still connecting.
+  if (clientEnded) upstream.end();
+}
+
+export interface EdgeForwarderOptions {
+  publicPort: number;
+  host?: string;
+  /** How long a client waits for a reachable server. Defaults to 5s. */
+  connectWindowMs?: number;
+}
+
+/**
+ * Bind the public port and start forwarding. Resolves once listening so the
+ * caller can fail fast when the port is unavailable.
+ */
+export function startEdgeForwarder(
+  opts: EdgeForwarderOptions,
+): Promise<net.Server> {
+  const host = opts.host ?? "0.0.0.0";
+  const connectWindowMs = opts.connectWindowMs ?? CONNECT_WINDOW_MS;
+  return new Promise((resolvePromise, reject) => {
+    // allowHalfOpen keeps the other direction alive when one side sends FIN —
+    // long-lived chat WS and SSE streams depend on it.
+    const server = net.createServer({ allowHalfOpen: true }, (client) => {
+      void handleConnection(client, connectWindowMs);
+    });
+    server.once("error", reject);
+    server.listen(opts.publicPort, host, () => {
+      server.removeListener("error", reject);
+      resolvePromise(server);
+    });
+  });
+}
+
+// ─── Process entry ─────────────────────────────────────────────────────
+// Mirrors the `__serve__` guard in src/server/index.ts: the supervisor
+// re-invokes the binary as `<bin> __edge__ <publicPort> <host>`.
+if (process.argv.includes("__edge__")) {
+  const idx = process.argv.indexOf("__edge__");
+  const publicPort = parseInt(process.argv[idx + 1] ?? "", 10);
+  const host = process.argv[idx + 2] ?? "0.0.0.0";
+
+  if (!Number.isInteger(publicPort) || publicPort <= 0 || publicPort > 65535) {
+    process.stderr.write(`[edge] Invalid public port: ${process.argv[idx + 1]}\n`);
+    process.exit(2);
+  }
+
+  try {
+    await startEdgeForwarder({ publicPort, host });
+    process.stderr.write(`[edge] Listening on ${host}:${publicPort}\n`);
+  } catch (err) {
+    process.stderr.write(`[edge] Failed to bind ${host}:${publicPort}: ${err}\n`);
+    process.exit(1);
+  }
+}

package/src/services/jsonl-transcript-parser.ts

@@ -8,6 +8,7 @@ import { resolve } from "node:path";
 import { homedir } from "node:os";
 import type { ChatEvent, ChatMessage } from "../types/chat.ts";
 import { stringifyToolResultContent } from "../shared/tool-result-content.ts";
+import { stripSharedContext } from "../shared/provider-context.ts";
 
 const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
 const TEAMMATE_MSG_RE = /<teammate-message[^>]*>[\s\S]*?<\/teammate-message>/g;
@@ -117,7 +118,7 @@ export function parseSessionMessage(
   return {
     id: msg.uuid,
     role,
-    content: textContent,
+    content: role === "user" ? stripSharedContext(textContent) : textContent,
     events: events.length > 0 ? events : undefined,
     timestamp: msg.timestamp ?? new Date().toISOString(),
     sdkUuid: msg.uuid,