@posthog/agent 2.3.326 → 2.3.346

package/dist/types.d.ts

@@ -39,10 +39,12 @@ interface Task {
     };
     latest_run?: TaskRun;
 }
-type ArtifactType = "plan" | "context" | "reference" | "output" | "artifact" | "tree_snapshot";
+type ArtifactType = "plan" | "context" | "reference" | "output" | "artifact" | "tree_snapshot" | "user_attachment";
 interface TaskRunArtifact {
+    id?: string;
     name: string;
     type: ArtifactType;
+    source?: string;
     size?: number;
     content_type?: string;
     storage_path?: string;
@@ -112,6 +114,14 @@ interface AgentConfig {
     skipLogPersistence?: boolean;
     /** Local cache path for instant log loading (e.g., ~/.posthog-code) */
     localCachePath?: string;
+    /**
+     * Annotate files the agent reads with PostHog enrichment (event volume,
+     * flag rollout/staleness, experiment links). Defaults to enabled when
+     * `posthog` config is present; set `{ enabled: false }` to opt out.
+     */
+    enricher?: {
+        enabled?: boolean;
+    };
     debug?: boolean;
     onLog?: OnLogCallback;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.326",
+  "version": "2.3.346",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -86,14 +86,14 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
-    "@posthog/shared": "1.0.0",
-    "@posthog/git": "1.0.0"
+    "@posthog/git": "1.0.0",
+    "@posthog/shared": "1.0.0"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.16.1",
+    "@agentclientprotocol/sdk": "0.19.0",
     "ajv": "^8.17.1",
     "@anthropic-ai/claude-agent-sdk": "0.2.112",
-    "@anthropic-ai/sdk": "^0.78.0",
+    "@anthropic-ai/sdk": "0.89.0",
     "@hono/node-server": "^1.19.9",
     "@opentelemetry/api-logs": "^0.208.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.208.0",
@@ -108,7 +108,8 @@
     "tar": "^7.5.0",
     "uuid": "13.0.0",
     "yoga-wasm-web": "^0.3.3",
-    "zod": "^4.2.0"
+    "zod": "^4.2.0",
+    "@posthog/enricher": "1.0.0"
   },
   "files": [
     "dist/**/*",

package/src/adapters/acp-connection.ts

@@ -1,6 +1,6 @@
 import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 import type { SessionLogWriter } from "../session-log-writer";
-import type { ProcessSpawnedCallback } from "../types";
+import type { PostHogAPIConfig, ProcessSpawnedCallback } from "../types";
 import { Logger } from "../utils/logger";
 import {
   createBidirectionalStreams,
@@ -26,6 +26,10 @@ export type AcpConnectionConfig = {
   allowedModelIds?: Set<string>;
   /** Callback invoked when the agent calls the create_output tool for structured output */
   onStructuredOutput?: (output: Record<string, unknown>) => Promise<void>;
+  /** PostHog API config; when set, enables file-read enrichment unless disabled. */
+  posthogApiConfig?: PostHogAPIConfig;
+  /** Defaults to true when posthogApiConfig is set. Set to false to disable enrichment. */
+  enricherEnabled?: boolean;
 };
 
 export type AcpConnection = {
@@ -54,6 +58,13 @@ export function createAcpConnection(
   return createClaudeConnection(config);
 }
 
+function resolveEnricherApiConfig(
+  config: AcpConnectionConfig,
+): PostHogAPIConfig | undefined {
+  const enabled = !!config.posthogApiConfig && config.enricherEnabled !== false;
+  return enabled ? config.posthogApiConfig : undefined;
+}
+
 function createClaudeConnection(config: AcpConnectionConfig): AcpConnection {
   const logger =
     config.logger?.child("AcpConnection") ??
@@ -102,6 +113,7 @@ function createClaudeConnection(config: AcpConnectionConfig): AcpConnection {
     agent = new ClaudeAcpAgent(client, {
       ...config.processCallbacks,
       onStructuredOutput: config.onStructuredOutput,
+      posthogApiConfig: resolveEnricherApiConfig(config),
     });
     return agent;
   }, agentStream);
@@ -192,6 +204,7 @@ function createCodexConnection(config: AcpConnectionConfig): AcpConnection {
     agent = new CodexAcpAgent(client, {
       codexProcessOptions: config.codexOptions ?? {},
       processCallbacks: config.processCallbacks,
+      posthogApiConfig: resolveEnricherApiConfig(config),
     });
     return agent;
   }, agentStream);

package/src/adapters/claude/UPSTREAM.md

@@ -5,8 +5,8 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 ## Fork Point
 
 - **Forked**: v0.10.9, commit `5411e0f4`, Dec 2 2025
-- **Last sync**: v0.22.2, commit `07db59e`, March 25 2026
-- **SDK**: `@anthropic-ai/claude-agent-sdk` 0.2.76, `@agentclientprotocol/sdk` 0.16.1
+- **Last sync**: v0.30.0, commit `e9dd452`, April 20 2026
+- **SDK**: `@anthropic-ai/claude-agent-sdk` 0.2.112 (0.2.114 breaks session init, see agentclientprotocol/claude-agent-acp#575), `@agentclientprotocol/sdk` 0.19.0
 
 ## File Mapping
 
@@ -50,11 +50,31 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 | permissionMode | Hardcoded `"default"` | Reads from `meta.permissionMode` | More flexible mode selection |
 | Session storage | `this.sessions[sessionId]` (multi) | `this.session` (single) | Architectural choice |
 | bypassPermissions | `updatedPermissions` with `destination: "session"` | No `updatedPermissions` | Different permission persistence |
-| Auth methods | Always returns `claude-login` auth method | Returns empty `authMethods` | Auth handled externally |
+| Auth methods | `claude-ai-login` + `console-login` | Returns empty `authMethods` | Auth handled externally |
+| Session fingerprinting | Implicit teardown on cwd/mcp change | Explicit `refreshSession()` | Caller-initiated is more predictable |
+| Shutdown on ACP close | Process exits | No standalone process | Agent is embedded in server |
+
+## Changes Ported in v0.30.0 Sync
+
+- **SDK bumps**: claude-agent-sdk 0.2.112 -> 0.2.114, ACP SDK 0.16.1 -> 0.19.0, anthropic SDK -> 0.89.0
+- **Null-safe usage tokens** (v0.29.2): Guard against null usage fields from SDK
+- **SettingsManager race fix** (v0.25.0): `initPromise` prevents concurrent `initialize()`/`setCwd()` corruption
+- **Malformed settings warning** (v0.25.0): Log warning for non-ENOENT settings file errors
+- **Idle state end-of-turn** (v0.23.0): `CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS=1` + `session_state_changed` idle handler
+- **Mid-stream usage updates** (v0.29.1): Fire `usage_update` from `message_start`/`message_delta` stream events
+- **Raw SDK message relay** (v0.27.0): `emitRawSDKMessages` on `NewSessionMeta` for opt-in diagnostics
+- **Effort level sync** (v0.25.x): `xhigh` level added, `applyFlagSettings` on effort change
+- **Auto permission mode** (v0.25.0): Added to `CODE_EXECUTION_MODES`, available modes, ExitPlanMode options
+
+## Skipped in v0.30.0 Sync
+
+- **Separate auth methods** (v0.25.0): PostHog returns empty authMethods
+- **Session fingerprinting** (v0.25.3): PostHog uses explicit `refreshSession()` instead
+- **Process exit on ACP close** (v0.27.0): PostHog embeds agent in server
 
 ## Next Sync
 
-1. Check upstream changelog since v0.22.2
+1. Check upstream changelog since v0.30.0
 2. Diff upstream source against PostHog Code using the file mapping above
 3. Port in phases: bug fixes first, then features
 4. After each phase: `pnpm --filter agent typecheck && pnpm --filter agent build && pnpm lint`

package/src/adapters/claude/claude-agent.ts

@@ -51,6 +51,12 @@ import {
   POSTHOG_METHODS,
   POSTHOG_NOTIFICATIONS,
 } from "../../acp-extensions";
+import {
+  createEnrichment,
+  type Enrichment,
+  type FileEnrichmentDeps,
+} from "../../enrichment/file-enricher";
+import type { PostHogAPIConfig } from "../../types";
 import { unreachable, withTimeout } from "../../utils/common";
 import { Logger } from "../../utils/logger";
 import { Pushable } from "../../utils/streams";
@@ -62,6 +68,7 @@ import {
   handleSystemMessage,
   handleUserAssistantMessage,
 } from "./conversion/sdk-to-acp";
+import type { EnrichedReadCache } from "./hooks";
 import {
   fetchMcpToolMetadata,
   getConnectedMcpServerNames,
@@ -92,6 +99,7 @@ import type {
   BackgroundTerminal,
   EffortLevel,
   NewSessionMeta,
+  SDKMessageFilter,
   Session,
   ToolUseCache,
 } from "./types";
@@ -111,11 +119,25 @@ function sanitizeTitle(text: string): string {
   return `${sanitized.slice(0, MAX_TITLE_LENGTH - 1)}…`;
 }
 
+function shouldEmitRawMessage(
+  config: boolean | SDKMessageFilter[],
+  message: { type: string; subtype?: string },
+): boolean {
+  if (config === true) return true;
+  if (config === false) return false;
+  return config.some(
+    (f) =>
+      f.type === message.type &&
+      (f.subtype === undefined || f.subtype === message.subtype),
+  );
+}
+
 export interface ClaudeAcpAgentOptions {
   onProcessSpawned?: (info: ProcessSpawnedInfo) => void;
   onProcessExited?: (pid: number) => void;
   onMcpServersReady?: (serverNames: string[]) => void;
   onStructuredOutput?: (output: Record<string, unknown>) => Promise<void>;
+  posthogApiConfig?: PostHogAPIConfig;
 }
 
 export class ClaudeAcpAgent extends BaseAcpAgent {
@@ -125,12 +147,29 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   backgroundTerminals: { [key: string]: BackgroundTerminal } = {};
   clientCapabilities?: ClientCapabilities;
   private options?: ClaudeAcpAgentOptions;
+  private enrichment?: Enrichment;
+  private enrichedReadCache: EnrichedReadCache = new Map();
 
   constructor(client: AgentSideConnection, options?: ClaudeAcpAgentOptions) {
     super(client);
     this.options = options;
     this.toolUseCache = {};
     this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
+    this.enrichment = createEnrichment(options?.posthogApiConfig, this.logger);
+  }
+
+  protected getEnrichmentDeps(): FileEnrichmentDeps | undefined {
+    return this.enrichment?.deps;
+  }
+
+  override async closeSession(): Promise<void> {
+    try {
+      await super.closeSession();
+    } finally {
+      this.enrichment?.dispose();
+      this.enrichment = undefined;
+      this.enrichedReadCache.clear();
+    }
   }
 
   async initialize(request: InitializeRequest): Promise<InitializeResponse> {
@@ -331,6 +370,12 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     this.session.promptRunning = true;
     let handedOff = false;
     let lastAssistantTotalUsage: number | null = null;
+    let lastStreamUsage = {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_read_input_tokens: 0,
+      cache_creation_input_tokens: 0,
+    };
     if (this.session.lastContextWindowSize == null) {
       this.session.lastContextWindowSize = this.getContextWindowForModel(
         this.session.modelId ?? "",
@@ -355,6 +400,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       client: this.client,
       toolUseCache: this.toolUseCache,
       fileContentCache: this.fileContentCache,
+      enrichedReadCache: this.enrichedReadCache,
       logger: this.logger,
       supportsTerminalOutput,
     };
@@ -375,6 +421,16 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
           break;
         }
 
+        if (
+          this.session.emitRawSDKMessages &&
+          shouldEmitRawMessage(this.session.emitRawSDKMessages, message)
+        ) {
+          await this.client.extNotification("_claude/sdkMessage", {
+            sessionId: params.sessionId,
+            message: message as Record<string, unknown>,
+          });
+        }
+
         switch (message.type) {
           case "system":
             if (message.subtype === "compact_boundary") {
@@ -394,6 +450,35 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             if (message.subtype === "local_command_output") {
               promptReplayed = true;
             }
+            if (
+              message.subtype === "session_state_changed" &&
+              (message as Record<string, unknown>).state === "idle"
+            ) {
+              if (!promptReplayed) {
+                this.logger.debug("Skipping idle state before prompt replay", {
+                  sessionId: params.sessionId,
+                });
+                break;
+              }
+
+              const acc = this.session.accumulatedUsage;
+              const totalUsed =
+                acc.inputTokens +
+                acc.outputTokens +
+                acc.cachedReadTokens +
+                acc.cachedWriteTokens;
+
+              await this.client.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "usage_update",
+                  used: totalUsed,
+                  size: lastContextWindowSize,
+                },
+              });
+
+              return { stopReason: "end_turn" };
+            }
             await handleSystemMessage(message, context);
             break;
 
@@ -411,15 +496,15 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               return { stopReason: "cancelled" };
             }
 
-            // Accumulate usage from this result
+            // Accumulate usage from this result (guard against null from SDK)
             this.session.accumulatedUsage.inputTokens +=
-              message.usage.input_tokens;
+              message.usage.input_tokens ?? 0;
             this.session.accumulatedUsage.outputTokens +=
-              message.usage.output_tokens;
+              message.usage.output_tokens ?? 0;
             this.session.accumulatedUsage.cachedReadTokens +=
-              message.usage.cache_read_input_tokens;
+              message.usage.cache_read_input_tokens ?? 0;
             this.session.accumulatedUsage.cachedWriteTokens +=
-              message.usage.cache_creation_input_tokens;
+              message.usage.cache_creation_input_tokens ?? 0;
 
             // SDK can underreport context window (e.g. 200k for 1M models).
             // Use SDK value only if it's larger than what gateway reported.
@@ -514,9 +599,56 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             return { stopReason: result.stopReason ?? "end_turn", usage };
           }
 
-          case "stream_event":
+          case "stream_event": {
+            if (
+              message.parent_tool_use_id === null &&
+              (message.event.type === "message_start" ||
+                message.event.type === "message_delta")
+            ) {
+              if (message.event.type === "message_start") {
+                const u = message.event.message.usage;
+                lastStreamUsage = {
+                  input_tokens: u.input_tokens ?? 0,
+                  output_tokens: u.output_tokens ?? 0,
+                  cache_read_input_tokens: u.cache_read_input_tokens ?? 0,
+                  cache_creation_input_tokens:
+                    u.cache_creation_input_tokens ?? 0,
+                };
+              } else {
+                const u = message.event.usage;
+                lastStreamUsage = {
+                  input_tokens: u.input_tokens ?? lastStreamUsage.input_tokens,
+                  output_tokens: u.output_tokens,
+                  cache_read_input_tokens:
+                    u.cache_read_input_tokens ??
+                    lastStreamUsage.cache_read_input_tokens,
+                  cache_creation_input_tokens:
+                    u.cache_creation_input_tokens ??
+                    lastStreamUsage.cache_creation_input_tokens,
+                };
+              }
+
+              const nextTotal =
+                lastStreamUsage.input_tokens +
+                lastStreamUsage.output_tokens +
+                lastStreamUsage.cache_read_input_tokens +
+                lastStreamUsage.cache_creation_input_tokens;
+
+              if (nextTotal !== lastAssistantTotalUsage) {
+                lastAssistantTotalUsage = nextTotal;
+                await this.client.sessionUpdate({
+                  sessionId: params.sessionId,
+                  update: {
+                    sessionUpdate: "usage_update",
+                    used: nextTotal,
+                    size: lastContextWindowSize,
+                  },
+                });
+              }
+            }
             await handleStreamEvent(message, context);
             break;
+          }
 
           case "user":
           case "assistant": {
@@ -565,16 +697,16 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               const usage = (
                 message.message as unknown as Record<string, unknown>
               ).usage as {
-                input_tokens: number;
-                output_tokens: number;
-                cache_read_input_tokens: number;
-                cache_creation_input_tokens: number;
+                input_tokens: number | null;
+                output_tokens: number | null;
+                cache_read_input_tokens: number | null;
+                cache_creation_input_tokens: number | null;
               };
               lastAssistantTotalUsage =
-                usage.input_tokens +
-                usage.output_tokens +
-                usage.cache_read_input_tokens +
-                usage.cache_creation_input_tokens;
+                (usage.input_tokens ?? 0) +
+                (usage.output_tokens ?? 0) +
+                (usage.cache_read_input_tokens ?? 0) +
+                (usage.cache_creation_input_tokens ?? 0);
 
               await this.client.sessionUpdate({
                 sessionId: params.sessionId,
@@ -858,6 +990,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       const newEffort = resolvedValue as EffortLevel;
       this.session.effort = newEffort;
       this.session.queryOptions.effort = newEffort;
+      await this.session.query.applyFlagSettings({
+        // @ts-expect-error SDK Settings.effortLevel omits "max" but runtime accepts it
+        effortLevel: newEffort,
+      });
     }
 
     this.session.configOptions = this.session.configOptions.map((o) =>
@@ -993,6 +1129,8 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       onProcessSpawned: this.options?.onProcessSpawned,
       onProcessExited: this.options?.onProcessExited,
       effort,
+      enrichmentDeps: this.enrichment?.deps,
+      enrichedReadCache: this.enrichedReadCache,
     });
 
     // Use the same abort controller that buildSessionOptions gave to the query
@@ -1019,6 +1157,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       promptRunning: false,
       pendingMessages: new Map(),
       nextPendingOrder: 0,
+      emitRawSDKMessages: meta?.claudeCode?.emitRawSDKMessages ?? false,
 
       // Custom properties
       cwd,
@@ -1297,6 +1436,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       if (this.session.effort) {
         this.session.effort = undefined;
         this.session.queryOptions.effort = undefined;
+        void this.session.query.applyFlagSettings({
+          effortLevel: undefined,
+        });
       }
       return;
     }
@@ -1310,6 +1452,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     if (resolvedValue !== currentValue && this.session.effort) {
       this.session.effort = resolvedValue as EffortLevel;
       this.session.queryOptions.effort = resolvedValue as EffortLevel;
+      void this.session.query.applyFlagSettings({
+        // @ts-expect-error SDK Settings.effortLevel omits "max" but runtime accepts it
+        effortLevel: resolvedValue,
+      });
     }
 
     const effortConfig: SessionConfigOption = {
@@ -1354,6 +1500,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         client: this.client,
         toolUseCache: this.toolUseCache,
         fileContentCache: this.fileContentCache,
+        enrichedReadCache: this.enrichedReadCache,
         logger: this.logger,
         registerHooks: false,
       };

package/src/adapters/claude/conversion/acp-to-sdk.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { promptToClaude } from "./acp-to-sdk";
+
+describe("promptToClaude", () => {
+  it("renders file resource links as explicit workspace attachments", () => {
+    const result = promptToClaude({
+      sessionId: "session-1",
+      prompt: [
+        {
+          type: "resource_link",
+          uri: "file:///tmp/workspace/.posthog/attachments/run-1/report.pdf",
+          name: "report.pdf",
+        },
+      ],
+    });
+
+    expect(result.message.content).toEqual([
+      {
+        type: "text",
+        text: [
+          "Attached file available in the workspace:",
+          "- name: report.pdf",
+          "- path: /tmp/workspace/.posthog/attachments/run-1/report.pdf",
+          "Use the available tools to inspect this file if needed.",
+        ].join("\n"),
+      },
+    ]);
+  });
+
+  it("preserves non-file resource links as links", () => {
+    const result = promptToClaude({
+      sessionId: "session-1",
+      prompt: [
+        {
+          type: "resource_link",
+          uri: "https://example.com/report.pdf",
+          name: "report.pdf",
+        },
+      ],
+    });
+
+    expect(result.message.content).toEqual([
+      {
+        type: "text",
+        text: "https://example.com/report.pdf",
+      },
+    ]);
+  });
+});

package/src/adapters/claude/conversion/acp-to-sdk.ts

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { PromptRequest } from "@agentclientprotocol/sdk";
 import type { SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { ContentBlockParam } from "@anthropic-ai/sdk/resources";
@@ -11,11 +12,6 @@ function sdkText(value: string): ContentBlockParam {
 
 function formatUriAsLink(uri: string): string {
   try {
-    if (uri.startsWith("file://")) {
-      const filePath = uri.slice(7);
-      const name = path.basename(filePath) || filePath;
-      return `[@${name}](${uri})`;
-    }
     if (uri.startsWith("zed://")) {
       const name = path.basename(uri) || uri;
       return `[@${name}](${uri})`;
@@ -26,6 +22,21 @@ function formatUriAsLink(uri: string): string {
   }
 }
 
+function formatFileAttachment(uri: string): string {
+  try {
+    const filePath = fileURLToPath(uri);
+    const name = path.basename(filePath) || filePath;
+    return [
+      "Attached file available in the workspace:",
+      `- name: ${name}`,
+      `- path: ${filePath}`,
+      "Use the available tools to inspect this file if needed.",
+    ].join("\n");
+  } catch {
+    return `Attached file available at ${uri}`;
+  }
+}
+
 function transformMcpCommand(text: string): string {
   const mcpMatch = text.match(/^\/mcp:([^:\s]+):(\S+)(\s+.*)?$/);
   if (mcpMatch) {
@@ -46,7 +57,13 @@ function processPromptChunk(
       break;
 
     case "resource_link":
-      content.push(sdkText(formatUriAsLink(chunk.uri)));
+      content.push(
+        sdkText(
+          chunk.uri.startsWith("file://")
+            ? formatFileAttachment(chunk.uri)
+            : formatUriAsLink(chunk.uri),
+        ),
+      );
       break;
 
     case "resource":

package/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -21,7 +21,7 @@ import { POSTHOG_NOTIFICATIONS } from "@/acp-extensions";
 import { image, text } from "../../../utils/acp-content";
 import { unreachable } from "../../../utils/common";
 import type { Logger } from "../../../utils/logger";
-import { registerHookCallback } from "../hooks";
+import { type EnrichedReadCache, registerHookCallback } from "../hooks";
 import type { Session, ToolUpdateMeta, ToolUseCache } from "../types";
 import {
   type ClaudePlanEntry,
@@ -51,6 +51,7 @@ type ChunkHandlerContext = {
   sessionId: string;
   toolUseCache: ToolUseCache;
   fileContentCache: { [key: string]: string };
+  enrichedReadCache?: EnrichedReadCache;
   client: AgentSideConnection;
   logger: Logger;
   parentToolCallId?: string;
@@ -67,6 +68,7 @@ export interface MessageHandlerContext {
   client: AgentSideConnection;
   toolUseCache: ToolUseCache;
   fileContentCache: { [key: string]: string };
+  enrichedReadCache?: EnrichedReadCache;
   logger: Logger;
   registerHooks?: boolean;
   supportsTerminalOutput?: boolean;
@@ -248,7 +250,7 @@ function extractTextFromContent(content: unknown): string | null {
   return null;
 }
 
-function stripCatLineNumbers(text: string): string {
+export function stripCatLineNumbers(text: string): string {
   return text.replace(/^ *\d+[\t→]/gm, "");
 }
 
@@ -318,6 +320,7 @@ function handleToolResultChunk(
       supportsTerminalOutput: ctx.supportsTerminalOutput,
       toolUseId: chunk.tool_use_id,
       cachedFileContent: ctx.fileContentCache,
+      enrichedReadCache: ctx.enrichedReadCache,
     },
   );
 
@@ -448,6 +451,7 @@ function toAcpNotifications(
   supportsTerminalOutput?: boolean,
   cwd?: string,
   mcpToolUseResult?: Record<string, unknown>,
+  enrichedReadCache?: EnrichedReadCache,
 ): SessionNotification[] {
   if (typeof content === "string") {
     const update: SessionUpdate = {
@@ -468,6 +472,7 @@ function toAcpNotifications(
     sessionId,
     toolUseCache,
     fileContentCache,
+    enrichedReadCache,
     client,
     logger,
     parentToolCallId,
@@ -498,6 +503,7 @@ function streamEventToAcpNotifications(
   registerHooks?: boolean,
   supportsTerminalOutput?: boolean,
   cwd?: string,
+  enrichedReadCache?: EnrichedReadCache,
 ): SessionNotification[] {
   const event = message.event;
   switch (event.type) {
@@ -514,6 +520,8 @@ function streamEventToAcpNotifications(
         registerHooks,
         supportsTerminalOutput,
         cwd,
+        undefined,
+        enrichedReadCache,
       );
     case "content_block_delta":
       return toAcpNotifications(
@@ -528,6 +536,8 @@ function streamEventToAcpNotifications(
         registerHooks,
         supportsTerminalOutput,
         cwd,
+        undefined,
+        enrichedReadCache,
       );
     case "message_start":
     case "message_delta":
@@ -717,6 +727,7 @@ export async function handleStreamEvent(
     context.registerHooks,
     context.supportsTerminalOutput,
     context.session.cwd,
+    context.enrichedReadCache,
   )) {
     await client.sessionUpdate(notification);
     context.session.notificationHistory.push(notification);
@@ -840,6 +851,7 @@ export async function handleUserAssistantMessage(
     context.supportsTerminalOutput,
     session.cwd,
     mcpToolUseResult,
+    context.enrichedReadCache,
   )) {
     await client.sessionUpdate(notification);
     session.notificationHistory.push(notification);